Lua Learning Notes

A block is the body of a control structure, the body of a function, or a chunk (the file or string where the variable is declared):

x = 10
local i = 1     -- local to the chunk
while i <= x do
    local x = i * 2 -- local to the while body
    print(x)    --> 2, 4, 6, 8, ...
    i = i + 1
end
if i > 20 then
    local x  -- local to the "then" body
    x = 20
    print(x + 2) -- (would print 22 if test succeeded)
else
    print(x) --> 10 (the global one)
end
print(x)     --> 10 (the global one)

In interactive mode, each line is a chunk by itself (unless it is not a complete command).

$ lua
Lua 5.4.4  Copyright (C) 1994-2022 Lua.org, PUC-Rio
> local x = 10
> print(x)
nil
> do
>> local x = 20
>> print(x)
>> end
20
>

The do-end blocks are useful to finer control over the scope of some local variables:

local x1, x2
do
    local a2 = 2 * a
    local d = (b ^ 2 - 4 * a * c) ^ (1 / 2)
    x1 = (-b + d) / a2
    x2 = (-b - d) / a2
end           -- scope of 'a2' and 'd' ends here
print(x1, x2) -- 'x1' and 'x2' still in scope

It is good programming style to use local variables whenever possible.

The Lua distribution comes with a module strict.lua for global-variable checks; it raises an error if we try to assign to a non-existent global inside a function or to use a non-existent global.

A common idiom in Lua is local foo = foo to create a local variable, foo, and initializes it with the value of the global variable foo.

All control structures have a syntax with an explicit terminator: end terminates if, for and while structures; until terminates repeat structures.

The condition expression of a control structure can result in any value.

Both nil and false make a condition false; they are collectively called false values. Any other value makes a condition true.

Despite its name, false is frequently used as an alternative to nil, with the key difference that false behaves like a regular value in a table, while a nil in a table represents an absent key.

The result of the and operator is its first operand if that operand is false; otherwise, the result is its second operand.

4 and 5      --> 5
nil and 13   --> nil
false and 13 --> false

The result of the or operator is its first operand if it is not false; otherwise, the result is its second operand:

0 or 5        --> 0
false or "hi" --> "hi"
nil or false  --> false

The not operator always gives a Boolean value.

not nil     --> true
not false   --> true
not 0       --> false
not not 1   --> true
not not nil --> false

Integers and floats with the same value compare as equal in Lua:

1 == 1.0     --> true
-3 == -3.0   --> true
0.2e3 == 200 --> true

To distinguish between floats and integers, use math.type:

math.type(3)   --> integer
math.type(3.0) --> float

If both operands are integers, the operation gives an integer result; otherwise, the operation results in a float. In case of mixed operands, Lua converts the integer one to a float before the operation:

13.0 + 25  --> 38.0
-(3 * 6.0) --> -18.0

To avoid different results between division of integers and divisions of floats, division always operates on floats and gives float results:

3.0 / 2.0 --> 1.5
3 / 2     --> 1.5
3 // 2    --> 1 -- floor division and denoted by //

Lua provides the following relational operators, and all these operators always produce a Boolean value:

<	>	<=	>=	==	~=

To force a number to be a float, simply add 0.0 to it.

-3 + 0.0                  --> -3.0
0x7fffffffffffffff + 0.0  --> 9.2233720368548e+18

To force a number to be an integer, OR it with zero:

2^53      --> 9.007199254741e+15 (float)
2^53 | 0  --> 9007199254740992

-- number has no integer representation
3.2 | 0   -- fractional part
2^64 | 0  -- out of range

Lua is 8-bit clean: strings can contain any 8-bit value, including embedded zeros ('\0').

Lua is also encoding-agnostic; it makes no assumptions about the contents of a string.

Get the length of a string using the length operator (denoted by #):

hi = 'Hello 世界'
print(#hi)  --> 12  -- always counts the length in bytes

Concatenate two strings with the concatenation operator .. (two dots):

"Hello " .. "World"  --> Hello World
"result is " .. 3    --> result is 3

Multiple line literal strings can be delimited also by matching double square brackets, as with long comments. Moreover, it ignores the first character of the string when this character is a newline.

page = [[
<html>
<head>
    <title>An HTML Page</title>
</head>
<body>
    <a href="http://www.lua.org">Lua</a>
</body>
</html>
]]

Lua provides automatic conversions between numbers and strings at run time.

To convert a string to a number explicitly, we can use the function tonumber, which returns nil if the string does not denote a proper number.

tonumber(" -3 ")      --> -3
tonumber(" 10e4 ")    --> 100000.0
tonumber("10e")       --> nil (not a valid number)
tonumber("0x1.3p-4")  --> 0.07421875

To convert a number to a string explicitly, call the function tostring:

print(tostring(10) == "10") --> true

Since version 5.3, Lua includes a small library (utf8) to support operations on Unicode strings encoded in UTF-8.

hi = 'Hello 世界'
print(string.len(hi))  -- 12
print(utf8.len(hi))  -- 8

Tables can be heterogeneous; that is, they can contain values of all types (except nil).

Any key associated to the value nil is not considered part of the table. Conversely, any key that is not part of a table has an associated value nil.

Lua uses tables to represent packages and objects as well. For Lua, the math.sin means “index the table math using the string "sin" as the key”.

Lua stores global variables in ordinary tables.

Tables are created by means of a constructor expression, which in its simplest form is written as {}:

a = {}  -- create a table and assign its reference
a['x'] = 10  -- new entry, with key="x" and value=10
print(a.x)  --> 10

A Lua program can use functions defined both in Lua and in C (or in any other language used by the host application).

A function definition in Lua has a conventional syntax, like here:

-- add the elements of sequence 'a'
function add(a)
    local sum = 0
    for i = 1, #a do
        sum = sum + a[i]
    end
    return sum
end

Lua adjusts the number of arguments to the number of parameters by throwing away extra arguments and supplying nils to extra parameters.

function f(a, b) print(a, b) end

f()        -- nil 	nil
f(3)       -- 3		nil
f(3, 4)    -- 3		4
f(3, 4, 5) -- 3		4	(5 is discarded)