Lua 5.1 / LuaJIT Quick Summary (part 1: types, control flow, and scope)

table

-- Two dashes create a comment that ends at the line break
print("hello world")
-- Note: there is no need for semicolons to terminate statements.

-- Unlike C, the type information is stored with the value, not the variable; 
-- this means that the type of a variable can change dynamically.
x = 1           -- x now refers to a number
x = "foo"       -- x now refers to a string

-- check types like this:
if type(x) == "number" then 
    -- do stuff
end

-- these lines are all equivalent
-- they assign the number value 1 to the variable name x:
x = 1
x = 1.0
x = 100e-2  -- e base10 format
x = 0x1 --hexadecimal format
-- Note: all numbers in Lua are 64-bit doubles

-- strings:
print("a simple string")
print('a simple string')

-- embedding special characters and multi-line strings:
x = 'escape the \' character, and write \n a new line'
x = [[
The double square brackets are a simple way to write strings
that span
over several
lines]]

-- Boolean values:
t = true
f = false
if t then print("t!") end -- prints t!
if f then print("f!") end -- prints nothing

-- nil indicates the absence of value. 
-- Assigning nil to a variable marks the variable for garbage collection.
n = nil
-- nil also evaluates to false for a predicate:
if n then print("n!") end -- prints nothing

-- creating an array-like table of strings, the quick way:
t = { "one", "two", "three" }

-- creating a dictionary-like table, the quick way:
t = { one = 1, two = 2, three = 3 }

-- creating a table with both array-like and dictionary-like parts:
t = { "one", "two", "three", one = 1, two = 2, three = 3 }

-- create an empty table:
t = {}

-- add or replace key-value pairs in the table:
t[1] = "one"    -- array-like
t["two"] = 2    -- dictionary-like
-- a simpler way of saying that:
t.two = 2

print(t.two, t["two"])    --> 2 2

-- special case of nil:
-- remove a key-value pair by assigning the value nil:
t.two = nil
print(t.two)          --> 

-- create a table with a sub-table:
t = {
    numbers = { 1, 2, 3 },
    letters = { "a", "b", "c" },
}

-- any Lua type (except nil) can be used as key or value
-- (including functions, other tables, the table itself, ...)
t[x] = t
t[function() end] = false
t[t] = print
-- and other madness...

-- these two lines are equivalent
local mylist = { [1]="foo", [2]="bar", [3]="baz" }:
local mylist = { "foo", "bar", "baz" }

print(mylist[2])          --> bar
        
print(unpack(mylist))      --> foo bar baz 

for i = 1, #mytable do
    local v = mytable[i]
    -- do things with the index (i) and value (v)
    print(i, v)
end

for i, v in ipairs(mytable) do
    -- do things with the index (i) and value (v)
    print(i, v)
end

for k, v in pairs(mytable) do
    -- do things with the key (k) and value (v)
    print(k, v)
end

-- these are equivalent:
sayhello = function(message)
  print("hello", message)
end

function sayhello(message)
  print("hello", message)
end

-- using the function:
sayhello("me")  -- prints: hello me
sayhello("you") -- prints: hello you

-- replacing the function
sayhello = function(message)
  print("hi", message)
end

sayhello("me")  -- prints: hi me

function minmax(a, b)
  return math.min(a, b), math.max(a, b)
end
print(minmax(42, 13)) -- prints: 13 42

-- create a table
local t = { 
    -- with one value being a number:
    num = 10, 
    -- and another value being a function:
    -- (note the use of the keyword "self")
    printvalue = function(self)
        print(self.num)
    end,
}

-- or declare/modify it like this:
function t:printvalue()
    print(self.num)
end

-- use the method:
t.printvalue(t) -- prints: 10

-- if blocks:
if x == 1 then
  print("one")
  -- as many elseifs as desired can be chained
elseif x == 2 then
  print("two")
elseif x == 3 then
  print("three")
else
  print("many")
end

-- while loops:
x = 10
while x > 0 do
  print(x)
  x = x - 1
end

repeat
  print(x)
  x = x + 1
until x == 10

-- numeric for loop:
-- count from 1 to 10
for i = 1, 10 do 
    print(i) 
end        
-- count 1, 3, 5, 7, 9:
for i = 1, 10, 2 do 
    print(i) 
end
-- count down from 10 to 1:
for i = 10, 1, -1 do 
    print(i) 
end

-- logical operators:
if x == y then print("equal") end
if x ~= y then print("not equal") end

-- combinators are "and", "or" and "not":
if x > 12 and not x >= 20 then print("teen") end

function foo(test)
    -- a function body is a new block
    local y = "mylocal"
    if test then
        -- this is a sub-block of the function
        -- so "y" is still visible here
        print(y)  -- prints: mylocal
    end
end

-- this is outside the block in which "local y" occurred,
-- so "y" is not visible here:
print(y)    -- prints: nil

-- an outer variable:
local x = "outside"
print(x) -- prints: outside

-- sub-block uses "local", which does not affect the variable "x" outside:
function safe()
    local x = "inside"
end
safe()
print(x) -- prints: outside

-- sub-block does not use "local", so this updates the variable "x" outside:
function unsafe()
    x = "inside"
end
unsafe()
print(x) -- prints: inside

function make_counter()
    local count = 0
    -- notice that one function returns another
    -- each call to "make_counter()" will allocate and return a newly defined function:
    return function()
        count = count + 1
        print(count)
    end
end

-- call to make_counter() returns a function;
-- and 'captures' the local count as an 'upvalue' specific to it
local c1 = make_counter()
c1()  -- prints: 1
c1()  -- prints: 2
c1()  -- prints: 3

-- another call to make_counter() creates a new function,
-- with a new count upvalue
local c2 = make_counter()
c2()  -- prints: 1
c2()  -- prints: 2

-- the two function's upvalues are independent of each other:
c1()  -- prints: 4

Lua 5.1 / LuaJIT Quick Summary (part 1: types, control flow, and scope)

Syntax

Simple types

Numbers

Strings

Booleans and nil

Tables (structured data)

Iterating a table

Functions

Method-call syntax

Logic and control flow

Lexical scoping

Closures

Garbage collection