Files
reference/source/_posts/lua.md
T
2025-09-01 13:19:28 +01:00

462 lines
7.2 KiB
Markdown

---
title: Lua
date: 2025-09-01 10:07:20
background: bg-[##00007f]
tags:
- script
- interpret
categories:
- Programming
intro: |
The [Lua](https://www.lua.org/) cheat sheet is a one-page reference sheet for the Lua 5.4 programming language.
plugins:
- copyCode
- runCode
---
## Getting Started
### Introduction
- [Lua](https://www.lua.org/) _(lua.org)_
- [Lua Document](https://www.lua.org/docs.html) _(lua.org/docs.html)_
- [Learn X in Y minutes](https://learnxinyminutes.com/docs/lua/) _(learnxinyminutes.com)_
### Hello World
```lua
print("Hello, World!") -- Hello, World!
-- You can omit parentheses if the argument is one string or table literal
print "Hello, World!" -- Hello, World!
print [[multi-line
Hello
World]]
```
The famous "Hello World" program in Lua
### Variables
```lua
local age = 18 -- local variable
boys, girls = 2, 3 -- global variables
-- Now x = 1, y = 2, z = 3, and 4 is thrown away.
x, y, z = 1, 2, 3, 4
-- Undefined variables return nil.
-- This is not an error:
foo = anUnknownVariable -- Now foo = nil.
-- Variables are global by default unless declared with local.
```
Lua is a dynamically typed language and hence only the values will have types not the variables.
### Data Types {.col-span-2 .row-span-2}
| Value Type | Description |
| ---------- | ---------------------------------------------- |
| `number` | Represent (double-precision) numbers |
| `string` | Represents text |
| `nil` | Differentiates between values with data or not |
| `boolean` | true or false value |
| `function` | Represents a sub routine |
| `userdata` | Represents arbitrary C data |
| `thread` | Represents independent threads of execution |
| `table` | key-value pair, or array. |
See: [Data Types](#data-types)
### IO
```lua
-- Writes data to the standard output or a file.
io.write("Enter your name: ")
-- Reads input from the user or a file. You can specify formats like "*l" (line), "*n" (number), or "*a" (all).
name = io.read()
io.write("Enter your age: ")
age = io.read()
```
### Comments
```lua
-- This is a single line comments
```
```lua
--[[
Comments (multi-line) could also be written like this
--]]
```
## Operators
### Arithmetic
```lua
-- add
result = 10 + 30 -- => 40
-- subtract
result = 40 - 10 -- => 30
-- multiply
result = 50 * 5 -- => 250
-- divide (float division)
result = 16 / 4 -- => 4.0
-- divide (integer division, Lua 5.3+)
result = 16 // 4 -- => 4
-- modulo
result = 25 % 2 -- => 1
-- power
result = 5 ^ 3 -- => 125
-- unary minus
a = 12
result = -a -- => -12
```
### Relational
```lua
a = 10
b = 20
-- equals
print(a == b) -- false
-- not equals
print(a ~= b) -- true
-- greater than
print(a > b) -- false
-- less than
print(a < b) -- true
-- greater than or equals
print(a >= b) -- false
-- less than or equals
print(a <= b) -- true
```
### Logical
```lua
-- and
false and nil --> false
0 and 20 --> 20
10 and 20 --> 20
-- or
true or false --> true
10 or 0 --> 10
12 or 4 --> 12
-- not
not true --> false
```
Only nil and false are falsy; 0 and '' are true!
## Conditionals
### if-else {.col-span-3 .row-span-2}
```lua
num = 15
if num > 10 then
print("num is greater than 10")
elseif num < 10 then
print("num is smaller than 10")
else
print("num is 10")
end
-- making a ternary operator
-- This is similar to the a?b:c operator in C/js:
ans = aBoolValue and 'yes' or 'no' --> 'no'
```
## Loops
### While loop
```lua
i = 1
while i <= 5 do
print(i)
i = i + 1
end
```
### For loop
```lua
-- Numeric for loop (start, end, step)
for i = 1, 5, 1 do
print(i)
end
-- Generic for loop for tables
t = {10, 20, 30}
for k, v in ipairs(t) do
print(k, v) -- prints 1 10, 2 20, 3 30
end
```
### Repeat-until loop
```lua
i = 1
repeat
print(i)
i = i + 1
until i > 5
```
### Breaking out
```lua
while x do
if condition then
break
end
end
```
### Continue
```lua
-- prints even numbers in [|1,10|]
for i=1,10 do
if i % 2 == 1 then
goto continue
end
print(i)
::continue::
end
```
## Functions
### Creating fns
```lua
function myFunction()
return 1
end
function myFunctionWithArgs(a, b)
-- ...
end
-- function as arg
function operate(a, b, func)
return func(a, b)
end
-- anonymous function
function (parameters)
-- body of the function
end
local greet = function(name)
return "Hello, " .. name
end
-- Not exported in the module
local function myPrivateFunction()
end
-- Splats
function doAction(action, ...)
print("Doing '"..action.."' to", ...)
end
```
### Invoking fns {.col-span-2}
```lua
myFunction()
print(greet("Lua")) -- Output: Hello, Lua
-- function as arg
local result = operate(5, 3, function(x, y)
return x + y
end)
print(result) -- Output: 8
doAction('write', "Shirley", "Abed")
--> Doing 'write' to Shirley Abed
```
You can omit parentheses if the argument is one string or table literal
```lua
print "Hello World" --> print("Hello World")
dofile 'a.lua' --> dofile ('a.lua')
print [[a multi-line --> print([[a multi-line
message]] message]])
f{x=10, y=20} --> f({x=10, y=20})
type{} --> type({})
```
## Data Type APIs
### Strings
```lua
s = "Hello"
-- concatenation
s .. " there" -- => Hello there
s:upper() -- => HELLO
s:lower() -- => hello
s:len() -- => 5
s:find("o") -- => 5
s:reverse() -- => olleH
-- others
s:match()
s:gmatch()
s:sub()
s:gsub()
s:rep()
s:char()
s:dump()
s:byte()
s:format()
```
## Misc
### Meta-tables
A metatable is simply a table with functions in it.
```lua
mt = {}
mt.__tostring = function() return "lol" end
mt.__add = function(b) ... end -- a + b
mt.__mul = function(b) ... end -- a * b
mt.__index = function(k) ... end -- Lookups (a[k] or a.k)
mt.__newindex = function(k, v) ... end -- Setters (a[k] = v)
```
Metatables allow you to override behavior of another table.
```lua
mytable = {}
setmetatable(mytable, mt)
print(myobject)
```
### Classes {.col-span-2 .row-span-2}
Classes aren't built in; there are different ways to make them using tables and metatables.
```lua
```
Short explanation; what we are trying to do is basically making a table that can hold data and functions
```lua
Dog = {}
function Dog:new()
newObj = {sound = 'woof'}
self.__index = self
return setmetatable(newObj, self)
end
function Dog:makeSound()
print('I say ' .. self.sound)
end
mrDog = Dog:new()
mrDog:makeSound() -- 'I say woof'
```
Inheritance
```lua
LoudDog = Dog:new()
function LoudDog:makeSound()
s = self.sound .. ' '
print(s .. s .. s)
end
seymour = LoudDog:new()
seymour:makeSound() -- 'woof woof woof'
```
Another example
```lua
Account = {}
function Account:new(balance)
local t = setmetatable({}, { __index = Account })
-- Your constructor stuff
t.balance = (balance or 0)
return t
end
function Account:withdraw(amount)
print("Withdrawing " .. amount .. "...")
self.balance = self.balance - amount
self:report()
end
function Account:report()
print("Your current balance is: "..self.balance)
end
a = Account:new(9000)
a:withdraw(200) -- method call
```