Image source: Wikimedia Commons

Outline

• Basic characteristics of Lua
• Data types
• Operators
• Control flow
• Functions
• Data structures

Resources

• https://www.lua.org/
• Reference manual: https://www.lua.org/manual/5.3/
• Programming in Lua: https://www.lua.org/pil/contents.html
• Online Lua demo: https://www.lua.org/demo.html
• Online REPL: https://replit.com/languages/lua

Characteristics of the Lua language

• Used primarily as a scripting language
• Dynamically typed
• Procedural syntax
• Automatic memory management (garbage collector)

Syntax

• Free-form: no statement separators, no semantic whitespace��local lowest = math.huge�for index, value = ipairs(elements) do� if value < lowest then� lowest = value� end�end�return lowest��local lowest = math.huge for index, value = ipairs(elements) do if value < lowest then lowest = value end end return lowest

Syntax

• Comments: line and block��--[[�Finds lowest value among elements�]]�local lowest = math.huge�for index, value = ipairs(elements) do� if value < lowest then� lowest = value -- replace lowest found value� end�end�return lowest

Data types

• nil
• boolean: true, false
• numeric: -12, 3.14, 1e6, 0xdeadbeef
• strings: ”Hello world!”
• functions: function foo(args) --[[ body ]] end
• tables: { 1, 2, 3 }, { name = ”Bugatti Veyron”, speed = 400 }
• userdata
• coroutines/threads

Variables

• Assignment: =
• The value of an unassigned variable is nil
• print(a) -- nil�a = ”Hello”�print(a) -- “Hello”
• Multiple assignment
• a, b, c = 12, ”Hello World”�print(a, b, c) -- 12, “Hello World”, nil�a, b = b, a -- concise swap

Variables

• Locals
• All variables are global unless otherwise specified
• It’s possible to declare a variable as local, then it’s local to the current scope
• Each body of a condition, loop or function definition creates a new nested scope
• It is also possible to explicitly create a new scope using the do keyword
• A scope is usually terminated with the keyword end
• a = 12�do� a = a + 2 -- changes the global a� print(a) -- 14� local a = 42 -- creates a new variable also called a, which is local� print(a) -- 42�end -- local a goes out of scope�print(a) -- 14

Arithmetic and bitwise operators

• The usual: +, -, *, /, unary -
• % - modulo
• ^ - exponentiation (even with non-integral exponents)
• // - floor division (Lua 5.3+)
• a / b == (a // b) + (a % b)
• Bitwise operations: (Lua 5.3+)
• Bitwise AND, OR, XOR: &, |, ~
• Bitwise NOT: unary ~
• Arithmetic shift: >>, << (vacant bits are zeroed)

Relational operators

• Equality: ==
• Inequality: ~=
• Variables of different types are not equal
• Variables of reference types (tables, functions, userdata, threads) are equal iff they refer to the same object
• Comparison: >, >=, <, <=
• Numbers are ordered by their value
• Strings are ordered lexicographically according to the current locale
• Other types are unordered, and comparison will result in a runtime error

Logical operators

• and, or, not
• The return value of and and or is one of its operands
• nil counts as false, all other values of non-boolean types count as true
• If a is false or nil, then a and b returns a, otherwise it returns b
• If a is true, then a or b returns a, otherwise it returns b
• This can be used for optional/default arguments:�local upperBound = userSpecifiedUpperBound or defaultUpperBound�If userSpecifiedUpperBound is defined, its value is assigned to upperBound; otherwise defaultUpperBound is used instead
• This can be used in place of a ternary conditional operator:�local max = (x > y) and x or y�This is equivalent to: if x is greater than y, use x, otherwise use y

Logical operators

• Short-circuit evaluation
• false and error() -- never calls error
• This can be useful in conjunction with the shorthand described in the previous slide:�local targetHealth = target and target.health
• target may be nil, in which case accessing target.health would result in a runtime error
• By putting the target.health on the right side of an and, we make sure it is accessed only when target is not nil
• As a side effect, when target is nil, targetHealth is also set to nil, which is a sensible default

Other operators

• String concatenation: ..
• Converts both operands to string, if possible, and joins them together in a new string
• print(”I caught ” .. count .. ” fish today”)
• Length operator: #
• If the operand is an array, returns the number of its elements
• friends = { ”Bajza”, ”Bejval”, ”Jirsák”, ”Kemlink”, ”Zilvar” }�print(”Bylo nás ” .. #friends)

Conditions

Expressed using the familiar if, then, else and elseif keywords

if range < minRange then� -- ...�elseif range > maxRange then� -- ...�else� -- ...�end

Conditions

As with logical operators:

• nil counts as false, all other values of non-boolean types count as true
• This can be useful to determine if a variable has been defined:�if target then� -- use target�else� -- there is no target�end

Loops - for (numeric)

for var = start, end[, step] do� -- body�end

var is the variable to be used as the loop index, initially set to start�The loop body is run�If var ~= end, step is added to var, and the process repeats (until var == end)

start, end and step must be numbers

step may be omitted, in which case it’s assumed to be equal to 1

Loops - for (numeric)

Go over each element of an array, one by one, and print it:�for i = 1, #elements do� print(elements[i])�end

Go over every odd-numbered element of an array (step = 2):�for i = 1, #elements, 2 do … end

Go over every element of an array in reverse order:�for i = #elements, 1, -1 do … end

Loops - for (iterator)

for index, value in ipairs(array) do� -- body�end

for key, value in pairs(table) do� -- body�end

Looping over ipairs(array) will run the loop for each element of array in order, setting index to the index of the element and value to the element itself.

Looping over pairs(table) will run the loop for each element of table, setting key to key the element is stored under and value to the element itself. The order of iteration is unspecified.

Loops - while, repeat

while #elements > 0 do� print(elements[#elements])� elements[#elements] = nil�end

repeat� print(elements[#elements])� elements[#elements] = nil�until #elements == 0

Loops - break

The break statement can be used to terminate any for, while or repeat loop early

for key, value in pairs(table) do� if key == searchedKey then� print(value)� break� end�end

Functions

A function is created using the keyword function, followed by a list of arguments, and the function definition. The resulting function is then assigned into a variable:�printArray = function(elements)� for _, element in ipairs(elements) do print(element) end�end

There is alternate syntax for this, that more resembles function declarations in C-like languages:�function printArray(elements)� for _, element in ipairs(elements) do print(element) end�end

Functions can be local variables as well:�local function printArray(elements)� -- ...�end

Functions - return value

function findIf(elements, predicate)� for _, element in ipairs(elements)� if predicate(element) then return element end� end�end

firstRoundSquare = findIf(� {1, 4, 9, 16, 25, 36, 49},� function(x)� return x % 5 == 0� end�)

Functions - multiple return values

function findIf(elements, predicate)� for index, element in ipairs(elements)� if predicate(element) then return index, element end� end�end

firstRoundSquareIndex, firstRoundSquare = findIf(� {1, 4, 9, 16, 25, 36, 49},� function(x)� return x % 5 == 0� end�)

Functions - optional parameters

As with unassigned variables, parameters not passed in are equal to nil�This can be used to emulate optional function parameters

function takeFiltered(elements, predicate, count)� local result = {}� for _, element in ipairs(elements) do� if predicate(element) then result[#result] = element end� if count ~= nil and #result == count then break end� end� return result�end��odds = takeFiltered({1, 2, 3, 4, 5, 6, 7, 8, 9}, isOdd)�firstTwoOdds = takeFiltered({1, 2, 3, 4, 5, 6, 7, 8, 9}, isOdd, 2)

Functions - variadic arguments

function concatenate(...)� local result = ””� for _, arg in ipairs({...}) do result = result .. arg end� return result�end

print(concatenate(”I caught ”, count, “ fish”))

Functions - closures

function counter(start, step)� return function() -- captures the variables start and step inside� local previousValue = start� start = start + step� return previousValue� end�end

oneCounter = counter(1, 1)�twoCounter = counter(10, 2)�print(oneCounter()) -- 1�print(twoCounter()) -- 10�print(oneCounter()) -- 2�print(twoCounter()) -- 12

Lua standard library

• basic
• pairs
• ipairs
• print
• tostring
• type
• table
• table.insert
• table.concat
• table.sort
• table.pack
• table.unpack

​

• math
• math.huge
• math.max
• math.min
• math.floor
• math.random
• math.pi
• string
• string.reverse
• string.lower
• string.upper
• string.sub
• string.match

​

The host application that Lua is running in may choose to not include these libraries, therefore these functions may not always be available

Coroutines

• A coroutine is a resumable function
• Normally, when a function is called, it runs all the way to completion and returns a value
• A coroutine can suspend (pause) its execution at any point; this is called yielding
• A suspended coroutine can be resumed later, with all of its local variables intact

Coroutines

coro = coroutine.create(function(v)� print(v) -- print the passed-in value� coroutine.yield(v + 4) -- yield v + 4 and wait for resume� return v * 5�end)��running, x = coroutine.resume(coro, 10) -- coro prints 10�-- running is true, because coro hasn’t finished yet�-- x is the value yielded from coro�print(running, x) -- true, 14�running, x = coroutine.resume(coro) -- coro finishes running�print(running, x) -- false, 50

Coroutines

counter = coroutine.create(function()� local x, continue = 0, true� while continue do� x = x + 1� continue = coroutine.yield(x)� end� return x�end)�print(coroutine.resume(counter)) -- true, 1�print(coroutine.resume(counter, true)) -- true, 2�print(coroutine.resume(counter, false)) -- false, 2�print(coroutine.resume(counter, false)) -- false, <error message>

Tables

• Tables in Lua serve as an array type and a dictionary / hash map type
• Enclosing a list of values in curly braces ({}) creates the table as an array�a = { 1, 4, 9 }
• Array elements can be accessed with the subscript operator ([])
• Indices start at 1
• Accessing indices not stored in the array results in nil, as with unassigned variables�print(a[1], a[2], a[3], a[4]) -- 1, 4, 9, nil
• The length operator (#) can be used to determine the number of elements stored in an array�print(#a) -- 3

Tables

• When creating a table, values can be paired with string keys�car = { name = ”Bugatti Veyron”, speed = 400 }
• Table elements can be accessed with the index operator (.)�print(car.name, car.speed) -- ”Bugatti Veyron”, 400
• Accessing keys not stored in the table results in nil�print(car.legs) -- nil
• The length operator (#) does not give useful results with tables that are not arrays�print(#car) -- usually 0, but not always

Tables

• When creating a table, if the key is an expression enclosed in square brackets, then the result of that expression is used�a = { [1] = 1, [2] = 4, [3] = 9 }�-- same as a = { 1, 4, 9 }�car = { [”name”] = ”Bugatti Veyron”, [”speed”] = 400 }�-- same as car = { name = ”Bugatti Veyron”, speed = 400 }
• When accessing table elements, any expression can be used in the square brackets; the result of the expression is used as the key�print(car[”name”], car[”speed”]) -- ”Bugatti Veyron”, 400

Tables

• Each set of curly braces creates a new table
• These tables are distinct from each other, and will never compare equal, even if their contents match�a, b = {}, {}�print(tostring(a == b)) -- false

Tables

• Tables can be used as arrays�a = { 1, 4, 9, 16, 25, 36, 49 }�for i = 1, #a do print(a[i]) end�for _, e in ipairs(a) do print(e) end
• Tables can be used as associative arrays / dictionaries�speeds = {� [”Bugatti Veyron”] = 400,� [”Lamborghini Countach”] = 300�}�print(speeds[myCar])

Tables

• Tables can be used as a stand-in for records / structs�bugatti = { name = ”Bugatti Veyron”, speed = 400 }�lambo = { name = ”Lamborghini Countach”, speed = 300 }�if bugatti.speed > lambo.speed then� -- ...�end

Tables

• Tables can be used as more complicated data structures�cz = { name = ”Czechia” }�pl = { name = ”Poland” }�de = { name = ”Germany” }�at = { name = ”Austria” }�cz.neighbors = { pl, de, at }�pl.neighbors = { cz, de }�de.neighbors = { pl, cz, at }�at.neighbors = { cz, de }

Tables

• Tables can be used as objects
• You can store both data and behavior in a table

bugatti = {� name = ”Bugatti Veyron”,� speed = 400,� drive = function(self, destination) --[[ … ]] end,� refuel = function(self) --[[ … ]] end�}�bugatti.drive(bugatti, prague)�bugatti:drive(prague) -- syntax sugar for the above line

Tables

Alternate syntax for defining functions in tables:�bugatti = {� name = ”Bugatti Veyron”,� speed = 400�}�function bugatti.drive(self, destination)� -- ...�end�-- or equivalently:�function bugatti:drive(destination)� -- parameter “self” is added implicitly�end

Metatables

• Any table can set its own metatable with the setmetatable function
• A metatable defines functions (metamethods) that can be called in place of normal behavior when an operator is invoked

Metatables

deepComparableArray = {� __eq = function(lhs, rhs)� -- compare arrays element by element� end�}�numbers = { 1, 3, 5 }�-- normally, two distinct arrays are never equal�print(tostring(numbers == { 1, 3, 5 })) -- false�setmetatable(numbers, deepComparableArray)�-- now deepComparableArray.__eq is used for this comparison instead�print(tostring(numbers == { 1, 3, 5 })) -- true

Metatables - __index

• When a table element is accessed with [], . or : operators, and the key is not present, the __index metamethod is called to determine the result of the access
• This is often used as follows to emulate classes:�car = {}�car.prototype = { drive = function() --[[ … ]] end }�car.__index = function(index) return car.prototype[index] end�bugatti = {}�setmetatable(bugatti, car) -- bugatti “is a” car�bugatti:drive() -- bugatti.drive is nil, car.__index is consulted instead, fetching car.prototype.drive
• This is a common enough pattern that the car.prototype table may be used as the __index directly

Metatables - __index

car = {}�function car:drive(destination) --[[ … ]] end�function car:refuel() --[[ … ]] end��bugatti = {� name = ”Bugatti Veyron”,� speed = 400�}�bugatti:drive(prague) -- error, cannot find bugatti.drive�setmetatable(bugatti, { __index = car })�bugatti:drive(prague) -- calls car:drive with self = bugatti

Metatables - __index

vehicle = {}�function vehicle:position() --[[ … ]] end

car = {}�function car:drive(destination) --[[ … ]] end�function car:refuel() --[[ … ]] end�setmetatable(car, { __index = vehicle })

bugatti = {� name = ”Bugatti Veyron”,� speed = 400�}�setmetatable(bugatti, { __index = car })�print(tostring(bugatti:position())) -- falls back to car:position, which falls back to vehicle:position

Userdata

• Data types provided by the hosting environment
• Can also have a metatable set
• And so usually provide their own functions or operator overloads
• For example, a 3D vector type may be provided by the hosting environment that supports adding or subtracting two vectors with the + and - operators, or multiplying a vector by a number with the * operator

Questions?