Lua - Programmer Sheet

Number Literals

number
string
boolean
table
function
userdata
thread
nil
Variable type can be obtained with type(variable) Note: Table index starts at 0, but can be extended to 0 or negative numbers

Math Library

math.abs(number)
math.acos(radians), math.asin(radians), math.atan(radians)
math.ceil(number), math.floor(number)
math.cos(radians), math.sin(radians), math.tan(radians)
math.deg(radians), math.rad(degrees)
math.exp(number), math.log(number)
math.min(num1, num2, ...), math.max(num1, num2, ...)
math.sqrt(number)
math.random(), math.random(upper), math.random(lower, upper)
math.randomseed(seed)
math.huge --represents infinity
math.pi
On trigonometric calculations, the number is expressed as radians. On math.random() lower and upper are inclusive. math.huge can be also represented with -math.huge

Arithmetic Expressions

Sum	+
Negation/Subtraction	-
Product	*
Division	/
Modulo	%
Power	^

Relational Expressions

Equal to	==
Not equal to	~=
Less than	<
Greater than	>
Less than or equal to	<=
Greater than or equal to	>=

Logical Operators

not
and
or
Even though Lua does not have a Ternary operator (condition ? truevalue : falsevalue), we can use and and or to achieve a similar effect: value = (condition and truevalue) or falsevalue In this case and returns truevalue when the condition is true and falsevalue otherwise

Control Structures

if/else statement

if (condition1) then
    block
elseif (condition2) then
    block
else
    block
end

while loop

while (condition) do
    block
end

repeat loop

Like while loop, but condition is inverted
repeat
   block
until (condition)

Numeric for loop

for variable = start, stop, step do
   block
end

Iterator for loop

for var1, var2, var3 in iterator do
   block
end

String

string.byte(s [, i [, j]])	Return the numerical code the i-th through j-th character of the string passed.
string.char(i1, i2, ...)	Generate a string representing the character numerical code passed as arguments.
string.find(s, pattern [, index [, plain]])	Find the first occurrence of the pattern in the string passed
string.format(s, e1, e2, ...)	Create a formatted string from the format and arguments provided. This is similar to the printf("format",...) function in C.
string.gsub(s, pattern, replace [, n])	Used simply it can replace all instances of the pattern provided with the replacement. A pair of values is returned, the modified string and the number of substitutions made. The optional fourth argument n can be used to limit the number of substitutions made
string.len(s)	Return the length of the string passed.
string.lower(s)	Make all the upper case characters lower case.
string.upper(s)	Make all the lower case characters upper case.
string.match (s, pattern [, index])	Extract substrings by matching patterns.
string.rep(s, n)	Generate a string which is n copies of the string passed concatenated together.
string.reverse(s)	Reverses a string.
string.sub(s, i [, j])	Return a substring of the string passed. The substring starts at i. If the third argument j is not given, the substring will end at the end of the string. If the third argument is given, the substring ends at and includes j.
All functions can be used directly in string by changing string. to s:, s being the string Example: string.reverse("Test") "Test":reverse()"

Tables

Tables are used with the table[key] syntax Example:

> t = {foo="bar"} -- Same as
t={["foo"]="bar"}
> t.foo
bar

They can also be used as arrays

a = {1, 2, 3}

But in this case, index starts at 1

a = {[0]=1, [1]=2}

Tables can be extended to index 0 or even negative numbers

Table size can be found with:

> a = {1, 2, 3}
> # a
3

Table Library

table.concat(table [, sep [, i [, j]]])	Concatenate the elements of a table to form a string. Each element must be able to be coerced into a string.
table.foreach(table, f)	Apply the function f to the elements of the table passed. On each iteration the function f is passed the key-value pair of that element in the table. Apply the function f to the elements of the table passed. On each iteration the function f is passed the key-value pair of that element in the table. Deprecated
table.foreachi(table, f)	Apply the function f to the elements of the table passed. On each iteration the function f is passed the index-value pair of that element in the table. This is similar to table.foreach() except that index-value pairs are passed, not key-value pairs. Deprecated
table.sort(table [, comp])	Sort the elements of a table in-place. A comparison function can be provided to customise the element sorting. The comparison function must return a boolean value specifying whether the first argument should be before the second argument in the sequence.
table.insert(table, [pos,] value)	Insert a given value into a table. If a position is given insert the value before the element currently at that position.
table.remove(table [, pos])	Remove an element from a table. If a position is specified the element at that the position is removed. The remaining elements are reindexed sequentially and the size of the table is updated to reflect the change. The element removed is returned by this function.

Functions and modules

Functions

value = function(args) body end
function functionName(args) body end

Functions can be used as arguments:

function f(f2, arg1) f2(arg1) end

Return skips other code below it

Modules
A common module declaration usually is:
local mymodule = {}
function mymodule.foo() print("bar") end
return mymodule

As tables can have functions assigned to a key.

To import it, just do:
> module = require("mymodule")
> module.foo()
bar

Also, you can make private functions by putting local in front of the function declaration.

Table Library

table.concat(table [, sep [, i [, j]]])	Concatenate the elements of a table to form a string. Each element must be able to be coerced into a string.
table.foreach(table, f)	Apply the function f to the elements of the table passed. On each iteration the function f is passed the key-value pair of that element in the table. Apply the function f to the elements of the table passed. On each iteration the function f is passed the key-value pair of that element in the table. Deprecated
table.foreachi(table, f)	Apply the function f to the elements of the table passed. On each iteration the function f is passed the index-value pair of that element in the table. This is similar to table.foreach() except that index-value pairs are passed, not key-value pairs. Deprecated
table.sort(table [, comp])	Sort the elements of a table in-place. A comparison function can be provided to customise the element sorting. The comparison function must return a boolean value specifying whether the first argument should be before the second argument in the sequence.
table.insert(table, [pos,] value)	Insert a given value into a table. If a position is given insert the value before the element currently at that position.
table.remove(table [, pos])	Remove an element from a table. If a position is specified the element at that the position is removed. The remaining elements are reindexed sequentially and the size of the table is updated to reflect the change. The element removed is returned by this function.
table.sort() example: > t = { 3,2,5,1,4 } > table.sort(t, function(a,b) return a<b end) > = table.concat(t, ", ") 1, 2, 3, 4, 5

Classes. Table based

local Person = {}
Person.__index = Person
function Person.new(name, surname)
    local self = setmetatable({}, Person)
    self.name = name
    self.surname = surname
    return self
end
function Person.setName(self, name)
    self.name = name
end
function Person.getName(self)
    return self.name
end
function Person.setSurname(self, surname)
    self.surname = surname
end
function Person.getSurname(self)
    return self.surname
end
return Person
-- Import with ClassName = require("classname")
-- Use with local i = ClassName.init(params)

Classes. Closure/Instance Based

local function MyClass(init)
    local self = {
        public_field = 0
      }

    local private_field = init

    function self.foo()
        return private_field
    end

    function self.bar()
    private_field = private_field + 1
    end
    return self
end

return MyClass