1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
-- Single line comment
--[[
Multi-line comment
supports multiple lines
]]

-- Print statement
print("Hello, World!")

-- Basic variable declaration
local x = 10
global_var = 20  -- Global variable (avoid when possible)

-- Local constant (Lua 5.4+)
local PI <const> = 3.14159

-- Function definition
local function greet(name)
    return "Hello, " .. name .. "!"
end

-- Calling a function
print(greet("Lua Developer"))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
-- Primitive Types
local nil_var = nil         -- Represents absence of a value
local bool_true = true      -- Boolean true
local bool_false = false    -- Boolean false
local num_int = 42          -- Integer subtype (since 5.3)
local num_float = 3.14      -- Float subtype
local str_simple = "Lua"    -- String (8-bit clean, immutable)

-- Inspect number subtype (5.3+)
print(math.type(42))    -- "integer"
print(math.type(3.14))  -- "float"

-- Complex Types
local table_array = {1, 2, 3}                       -- Array-like table
local table_dict = {name = "Lua", version = 5.4}    -- Dictionary-like table
local function_var = function() end                 -- Function as first-class value
local thread_var = coroutine.create(function() end) -- Coroutine thread
local userdata_var                                  -- Userdata (from C)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
-- Local variables (recommended)
local x = 10
local y = 20

-- Global variables (use sparingly)
global_value = 30

-- Multiple variable assignment
local a, b, c = 1, 2, 3

-- True constants with <const> attribute (Lua 5.4+)
local PI <const> = 3.14159
local MAX_CONNECTIONS <const> = 100
-- PI = 4  -- Compile-time error: attempt to assign to const variable

-- To-be-closed variables (Lua 5.4+): __close is called when scope ends
local file <close> = io.open("data.txt", "r")
-- file:close() runs automatically at end of block, even on error

-- Scope demonstration
local function scope_demo()
    local local_var = "I'm local"  -- Function-level local
    internal_var = "I'm global"    -- Becomes global (avoid)
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
-- Arithmetic
local sum = 5 + 3       -- Addition
local diff = 10 - 4     -- Subtraction
local prod = 3 * 6      -- Multiplication
local div = 15 / 3      -- Float division (always returns float)
local idiv = 15 // 4    -- Floor (integer) division -> 3   (5.3+)
local mod = 10 % 3      -- Modulo
local pow = 2 ^ 3       -- Exponentiation (always returns float)

-- Bitwise operators (5.3+, operate on integers)
local band = 0xF0 & 0x0F   -- AND
local bor  = 0xF0 | 0x0F   -- OR
local bxor = 0xFF ~ 0x0F   -- XOR
local bnot = ~0            -- NOT
local shl  = 1 << 4        -- Left shift
local shr  = 256 >> 2      -- Right shift

-- Comparison
local is_equal = (5 == 5)       -- Equality
local is_not_equal = (5 ~= 6)   -- Inequality
local greater = (10 > 5)        -- Greater than
local less_or_equal = (3 <= 4)  -- Less than or equal

-- Logical
local and_op = true and false   -- Logical AND
local or_op = true or false     -- Logical OR
local not_op = not true         -- Logical NOT

-- Length operator
local n = #"Lua"        -- 3
local t = #{10, 20, 30} -- 3

-- String Concatenation
local full_name = "Lua" .. " " .. "Programming"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
-- If-Else
local age = 20
if age < 18 then
    print("Minor")
elseif age >= 18 and age < 65 then
    print("Adult")
else
    print("Senior")
end

-- For Loops
-- Numeric loop
for i = 1, 5 do
    print(i)  -- Prints 1, 2, 3, 4, 5
end

-- Reverse loop
for i = 5, 1, -1 do
    print(i)  -- Prints 5, 4, 3, 2, 1
end

-- Generic loop (iterate over tables)
local fruits = {"apple", "banana", "cherry"}
for index, fruit in ipairs(fruits) do
    print(index, fruit)
end

-- While Loop
local count = 0
while count < 5 do
    print(count)
    count = count + 1
end

-- Repeat-Until Loop
local x = 0
repeat
    x = x + 1
    print(x)
until x >= 5

-- Break (Lua has no `continue`; use `goto continue` since 5.2)
for i = 1, 10 do
    if i == 3 then
        break  -- Exit loop
    end
    print(i)
end

-- goto / labels (5.2+) - common idiom for "continue"
for i = 1, 5 do
    if i % 2 == 0 then goto continue end
    print(i)  -- prints odd numbers
    ::continue::
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
-- Simple function (prefer local)
local function add(a, b)
    return a + b
end

-- Function with multiple return values
local function get_person_details()
    return "John", 30, "Engineer"
end

-- Anonymous/Lambda functions
local multiply = function(a, b) return a * b end

-- Closures
local function counter()
    local count = 0
    return function()
        count = count + 1
        return count
    end
end
local increment = counter()
print(increment())  -- 1
print(increment())  -- 2

-- Variadic functions
local function sum(...)
    local total = 0
    for _, v in ipairs({...}) do
        total = total + v
    end
    return total
end
print(sum(1, 2, 3, 4))  -- 10

-- select() and table.pack handle varargs with nils safely
local function count_args(...)
    return select("#", ...)  -- exact arg count, including nils
end

-- Tail calls are properly optimized (no stack growth)
local function loop(n)
    if n == 0 then return "done" end
    return loop(n - 1)  -- proper tail call
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
-- Tables as Arrays
local fruits = {"apple", "banana", "cherry"}
print(fruits[1])  -- "apple" (1-based indexing)
table.insert(fruits, "date")
table.remove(fruits, 2)

-- Move a range of elements (5.3+)
local copy = {}
table.move(fruits, 1, #fruits, 1, copy)

-- Tables as Dictionaries
local person = {
    name = "John",
    age = 30,
    city = "New York"
}
print(person.name)
person.job = "Developer"

-- Mixed Tables
local mixed = {
    42,
    name = "Mixed Table",
    [true] = "Boolean key"
}

-- Pack / unpack varargs (5.2+)
local packed = table.pack("a", "b", "c")  -- {n=3, "a", "b", "c"}
print(table.unpack(packed, 1, packed.n))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
-- Metatable-based OOP
local Person = {}
Person.__index = Person

function Person.new(name, age)
    local self = setmetatable({}, Person)
    self.name = name
    self.age = age
    return self
end

function Person:introduce()
    print("Hi, I'm " .. self.name)
end

local john = Person.new("John", 30)
john:introduce()

-- Inheritance
local Student = setmetatable({}, {__index = Person})
Student.__index = Student

function Student.new(name, age, grade)
    local self = Person.new(name, age)
    setmetatable(self, Student)
    self.grade = grade
    return self
end

function Student:study()
    print(self.name .. " is studying")
end

local jane = Student.new("Jane", 25, 12)
jane:introduce()  -- Inherited method
jane:study()      -- Student's method

-- Useful metamethods:
-- __index, __newindex, __call, __tostring, __len,
-- __add/__sub/__mul/__div/__mod/__pow/__unm/__idiv,
-- __band/__bor/__bxor/__bnot/__shl/__shr (5.3+),
-- __eq/__lt/__le, __concat, __gc, __close (5.4+), __name

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
-- Protected Call
local function divide(a, b)
    if b == 0 then
        error("Cannot divide by zero", 2)  -- level 2 = caller
    end
    return a / b
end

local ok, result = pcall(divide, 10, 2)
print(ok, result)  -- true, 5

local ok, err = pcall(divide, 10, 0)
print(ok, err)     -- false, error message

-- xpcall with message handler and forwarded args (5.2+)
local function handler(err)
    return debug.traceback("Custom: " .. tostring(err), 2)
end

xpcall(divide, handler, 10, 0)

-- assert raises an error with a message when its first arg is falsy
local f = assert(io.open("config.lua", "r"), "config not found")

-- To-be-closed locals make cleanup automatic on error (5.4+)
do
    local f <close> = assert(io.open("data.txt", "r"))
    -- file auto-closed even if the next line errors
    local data = f:read("a")
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
-- Writing to a file
local file = assert(io.open("example.txt", "w"))
file:write("Hello, Lua!")
file:close()

-- Reading entire file (use "a" in 5.3+, "*a" still works for back-compat)
local file = assert(io.open("example.txt", "r"))
local content = file:read("a")
print(content)
file:close()

-- Iterating through file lines
for line in io.lines("example.txt") do
    print(line)
end

-- Binary data: pack/unpack (5.3+)
local bytes = string.pack(">I4 I2", 65536, 42)
local a, b = string.unpack(">I4 I2", bytes)

-- Recommended: pair file handles with <close> (5.4+)
do
    local f <close> = assert(io.open("example.txt", "r"))
    print(f:read("a"))
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
-- Using LuaUnit
local lu = require("luaunit")

function test_addition()
    lu.assertEquals(1 + 1, 2)
end

function test_string_concat()
    lu.assertEquals("Hello" .. " World", "Hello World")
end

os.exit(lu.LuaUnit.run())

-- Or with busted (BDD style)
--   describe("math", function()
--     it("adds numbers", function()
--       assert.are.equal(4, 2 + 2)
--     end)
--   end)