A glossary of some essential Lua terms

28 April 2017, revised 12 May 2017 · This Glossary may put preconceptions in your mind that are not applicable elsewhere.

x = fct (1,3,'pqr')  -- 1, 3 and 'pqr' are arguments
A          -- refers to the whole array
A[1]       -- refers to a single element with key 1
A['name']  -- refers to a single item with key 'name'
A.name     -- a synonym for A['name']
a = fct      -- the function is not called, but assigned as a value
a = fct()    -- the function is called
a = fct{1}   -- when there is ony one arguent, and that argument itself 
a = fct"abc" --   is already delimited, parentheses are not needed 
'number' .. 3       -- the number will be coerced to a string
'3' + 10            -- the string will be coerced to a number
3.1415 * 10         -- the integer will be coerced to float
tbl = {[3.0]=true}  -- the float will be coerced to integer
abc ~= nil    -- True if the value of abc (of whatever type) is not nil.
0<x and x<=10 -- True if x is in the range 1 to 10.
local x, y = 1  -- x gets the value 1, y gets the value nil.
function fct(x,y)
  if x<y then
    return y-x
  else
    return x-y
  end   -- definition does not stop here, this 'end' matches 'if'
end     -- definition stops here 
"this is a string"
'This too'
[===[ And this ]===]               -- the same number (>0) of equal signs
function (x,y) return 'foo' end    -- `function`, `end` are delimiters
1 == 1.0         --> true (integer vs float does not matter)
{} == {}         --> false (two new empty tables)
'abc' == 'abc'   --> true (strings are not reference types)
0/0 == 0/0       --> false (NaN is not equal to itself) 
"\x9a"            -- Hexadecimal encoding of a byte
"\u{20AC}         -- The Unicode character '€' in hexadecimal encoding
"%%"              -- The way to represent a percent sign in a pattern.
(2+2)^5                         -- arithmetic expression
age <= 65                       -- boolean expression
'--' .. " this is"              -- string expression
(gsub('Number # wins",'#','7')) -- function call expression (only the
      -- first value is used, and you need the parentheses for that)
string          -- these two notations are 
_ENV.string     -- equivalent
Catch_22  -- But not 'Catch-22': hyphens not allowed
_ENV      -- Global names used by the system look like this.
_VERSION  -- Users should avoid the underscore-capitals pattern.
Inf = 1/0
0-Inf             -- -inf
Inf + 1           -- inf
Inf-Inf           -- -nan
1/Inf             -- 0.0  
1/(-Inf)          -- -0.0
Inf < Inf         -- false
math.type(Inf)    -- float
1.3475e4                          -- floating-point literal
12346                             -- integer literal
"the quick brown fox"             -- string literal
{'Jock','Bill',name='Friends'}    -- table literal
fct = load "return 'Hello, World'"   -- load a string
fct = loadfile "myfunc.lua"          -- load a file
fct = require "mylib"                -- load a library
a and b   -- if a is false, then a (and don't evaluate b); else b
a or b    -- if a is true, then a (and don't evaluate b); else b
v = a.k          -- an error if a is nil
v = a and a.k    -- nil if a is nil
do
  local cache = {}
  function myfunc(arg)
    local result = cache[arg]
    if result == nil then
      -- calculate 'result', read it from a database on your
      -- computer, query the Internet, whatever.
    end
    return result
  end
end
   
class.fct(obj,x,y)   -- normal call to class.fct
obj:fct(x,y)         -- object-oriented call to the function 'fct'
                     -- of the class to which 'obj' belongs
function class:fct(x,y)
  -- code comes here
end

class.fct = function(self,x,y)
  -- code comes here
end
x = 1.23    -- 'x' is a name, 1.23 is a constant number value
NaN = 0/0
NaN + 1        -- NaN. All arithmetic operations involving NaN have
               -- result NaN.
NaN <= NaN     -- false. All comparison operations involving NaN have
               -- result false except the following.
NaN ~= NaN     -- true. The only Lua value with this property.
tbl = {1,4,nil,nil,10}         -- tbl[5] is 10
fct = load(code,nil,nil,data)  -- the data table must be the 4th argument
n = 1        -- integer
x = 1.0      -- floating-point
n = #tbl           -- '#' is the length operator
s = name .. id     -- '..' is the concatenation operator
for k,v in pairs(tbl) do   -- start of a loop that iterates over all
                           -- key-value pairs k,v in 'tbl'
    function fct (a,b,c)   -- a,b,c are parameters
    fct(1,2,3)             -- 1,2,3 are arguments
math    --> table: 0x22a8aa0
               -- the usual Lua prompt
              -- the prompt when wat you typed was not enough
a = {name="Jack"}   -- the variable 'a' has a reference
a                   --> table: 0x22c8810
b = a               -- 'b' now also has that reference
b                   --> table: 0x22c8810
c = {name="Jack"}   -- 'c' has a reference to a different table
c                   --> table: 0x22c9ba0
local a,b    -- a and b are now visible
begin
  local a    -- the previous variable called `a` is now shadowed
  c = a + b  -- the scope of the most recent `a` ends here
end          -- this `end` is matched by the previous begin
             -- for the most recent `a`, it is unmatched.
d = a+b      -- the original `a` is visible again

repeat
  local i
until i>10   -- the scope of i ends here 
{1,2,3,4}    -- a sequence: border at index 4
{1,2,nil,4}  -- not a sequence: borders at index 2 and 4
a = b; func(1,2,4)    -- two statements, separated by a semicolon
a = b func(1,2,4)     -- still two statements
data = "Laurie, Dirk"
pattern = "([^,]+),%s*(.*)"
surname, name = string.match(data, pattern)  -- these two calls
surname, name = data:match(pattern)          -- are equivalent
type(1)         --> number
type(1.0)       --> number
math.type(1)    --> integer
math.type(1.0)  --> float
    a.r = nil    -- delete the entry with key "r"
{1,2,nil,4}   -- an array
1,2,nil,4     -- a tuple
do    -- start a block
  local settings = {}    -- visible only to functions in the block
  set_width = function(w)
    settings.width = w   -- implicitly defines an upvalue `settings`
  end
end   -- end the block
          
function fct(z,...)          -- typical vararg parameter list
  local x,y = ...            -- assign first two elements of the vararg
  local p,q = select(4,...)  -- assign elements 4 and 5 of the vararg
  local t = table.pack(...)  -- create an array containing the vararg
  local u = {...}            -- the same, but u.n is not set
  local s = 10+...           -- add 10 to first element of vararg
  print(...)                 -- print everything in the vararg
  print((...))               -- print only the first element
  return z,20,...            -- returns a new vararg
end
0          -- integer zero
0.         -- floating-point zero
-0.        -- negative zero
c = {[-0.]=true}
next(c)    --> 0   true

A glossary of some essential Lua terms

Dirk Laurie

28 April 2017, revised 12 May 2017

Access

Allocate

API

Application

Argument

Array

Binary

Block

Boolean

Border

Bug

Byte

Bytecode

Call

Chunk

Class

Closure

Code

Coercion

Compare

Compile

Constant

Constructor

Coroutine

Data structure

Debug

Declaration

Definition

Delimit

Distinct

Dummy

Element

_ENV

Equal

Escape

Execute

Expression

File

First-class value

Floating-point

Free

Function

_G

Garbage

Global

Identifier

Implementation

Index

Inf

Initialize

Integer

Internalize

Interpret

Invoke

Key

Language

Library

Literal

Load

Local

Logical

Lua-L

Memoize

Memory

Metamethod

Method

Module

Mutable

Name

NaN

Nil

None

Number

Object

Operation

Pair

Parameter