Lua Standard Libraries

table.concat(tbl, sep?, i?, j?)

local arr = {"a", "b", "c"}
print(table.concat(arr))        -- "abc"
print(table.concat(arr, ", "))  -- "a, b, c"
print(table.concat(arr, "-", 1, 2))  -- "a-b"

table.insert(tbl, pos?, value)

local arr = {1, 2, 3}
table.insert(arr, 4)       -- {1, 2, 3, 4}
table.insert(arr, 2, 1.5)  -- {1, 1.5, 2, 3, 4}

table.remove(tbl, pos?)

local arr = {1, 2, 3, 4}
local last = table.remove(arr)     -- returns 4, arr = {1, 2, 3}
local second = table.remove(arr, 2) -- returns 2, arr = {1, 3}

table.sort(tbl, comp?)

local arr = {3, 1, 4, 1, 5}
table.sort(arr)  -- {1, 1, 3, 4, 5}
 
-- Custom sort (descending)
table.sort(arr, function(a, b) return a > b end)  -- {5, 4, 3, 1, 1}
 
-- Sort by property
local players = {{name="Bob", score=10}, {name="Alice", score=20}}
table.sort(players, function(a, b) return a.score > b.score end)

table.maxn(tbl)

local t = {}
t[1] = "a"
t[100] = "b"
print(table.maxn(t))  -- 100

table.unpack(tbl, i?, j?)

local arr = {10, 20, 30}
local a, b, c = table.unpack(arr)  -- a=10, b=20, c=30
print(a, b, c)
 
-- Partial unpack
local x, y = table.unpack(arr, 2, 3)  -- x=20, y=30

math.abs(x)      -- Absolute value
math.floor(x)    -- Round down
math.ceil(x)     -- Round up
math.min(...)    -- Minimum of arguments
math.max(...)    -- Maximum of arguments
math.sqrt(x)     -- Square root
math.pow(x, y)   -- x raised to power y
math.fmod(x, y)  -- Remainder of x/y

print(math.abs(-5))      -- 5
print(math.floor(3.7))   -- 3
print(math.ceil(3.2))    -- 4
print(math.min(1, 5, 3)) -- 1
print(math.max(1, 5, 3)) -- 5
print(math.sqrt(16))     -- 4
print(math.pow(2, 8))    -- 256

math.sin(x)   -- Sine (x in radians)
math.cos(x)   -- Cosine
math.tan(x)   -- Tangent
math.asin(x)  -- Arc sine
math.acos(x)  -- Arc cosine
math.atan(x)  -- Arc tangent
math.atan2(y, x)  -- Arc tangent of y/x
math.sinh(x)  -- Hyperbolic sine
math.cosh(x)  -- Hyperbolic cosine
math.tanh(x)  -- Hyperbolic tangent

math.deg(radians)  -- Convert radians to degrees
math.rad(degrees)  -- Convert degrees to radians

print(math.deg(math.pi))   -- 180
print(math.rad(180))       -- 3.14159...

math.log(x)      -- Natural logarithm
math.log10(x)    -- Base-10 logarithm
math.exp(x)      -- e^x

math.random()        -- Random float in [0, 1)
math.random(m)       -- Random integer in [1, m]
math.random(m, n)    -- Random integer in [m, n]
math.randomseed(x)   -- Seed the random generator (no effect in browser)

print(math.random())        -- 0.7234... (random float)
print(math.random(6))       -- 1-6 (dice roll)
print(math.random(10, 20))  -- 10-20 (random in range)

math.frexp(x)     -- Returns mantissa and exponent: m, e where x = m * 2^e
math.ldexp(m, e)  -- Returns m * 2^e
math.modf(x)      -- Returns integer and fractional parts

string.len(s)
-- or
#s

print(string.len("hello"))  -- 5
print(#"hello")             -- 5

string.sub(s, i, j?)

local s = "Hello, World!"
print(string.sub(s, 1, 5))   -- "Hello"
print(string.sub(s, 8))      -- "World!"
print(string.sub(s, -6))     -- "World!"
print(string.sub(s, -6, -2)) -- "World"

string.upper(s)
string.lower(s)

print(string.upper("hello"))  -- "HELLO"
print(string.lower("HELLO"))  -- "hello"

string.rep(s, n, sep?)

print(string.rep("ab", 3))       -- "ababab"
print(string.rep("x", 5, "-"))   -- "x-x-x-x-x"

string.reverse(s)

print(string.reverse("hello"))  -- "olleh"

string.byte(s, i?, j?)

print(string.byte("ABC"))       -- 65
print(string.byte("ABC", 2))    -- 66
print(string.byte("ABC", 1, 3)) -- 65, 66, 67

string.char(...)

print(string.char(65, 66, 67))  -- "ABC"
print(string.char(72, 105))     -- "Hi"

string.find(s, pattern, init?, plain?)

local s = "Hello, World!"
local start, finish = string.find(s, "World")
print(start, finish)  -- 8, 12
 
-- Plain text search
local i, j = string.find("a.b.c", ".", 1, true)
print(i, j)  -- 2, 2

string.match(s, pattern, init?)

local s = "name: John, age: 30"
print(string.match(s, "name: (%w+)"))  -- "John"
print(string.match(s, "age: (%d+)"))   -- "30"

string.gsub(s, pattern, repl, n?)

local s = "hello world"
print(string.gsub(s, "l", "L"))     -- "heLLo worLd", 3
print(string.gsub(s, "l", "L", 2))  -- "heLLo world", 2
 
-- Function replacement
local result = string.gsub("abc", ".", function(c)
  return string.upper(c)
end)
print(result)  -- "ABC"

string.format(formatstring, ...)

print(string.format("Hello, %s!", "World"))     -- "Hello, World!"
print(string.format("HP: %d/%d", 50, 100))      -- "HP: 50/100"
print(string.format("Pi: %.2f", 3.14159))       -- "Pi: 3.14"
print(string.format("Hex: %x", 255))            -- "Hex: ff"

os.clock()

local start = os.clock()
-- ... do work ...
local elapsed = os.clock() - start
print("Took " .. elapsed .. " seconds")

os.time(table?)

print(os.time())  -- Current timestamp
 
-- Create timestamp from date
local t = os.time({year=2024, month=6, day=15})

os.date(format?, time?)

print(os.date())                    -- "Sat Jun 15 14:30:45 2024"
print(os.date("%Y-%m-%d"))          -- "2024-06-15"
print(os.date("%H:%M:%S"))          -- "14:30:45"
 
-- Get date table
local t = os.date("*t")
print(t.year, t.month, t.day)       -- 2024, 6, 15
print(t.hour, t.min, t.sec)         -- 14, 30, 45
print(t.wday)                       -- 7 (Saturday, 1=Sunday)

os.difftime(t2, t1)

local start = os.time()
-- ... later ...
local elapsed = os.difftime(os.time(), start)
print("Elapsed: " .. elapsed .. " seconds")

for key, value in pairs(tbl) do
  -- process
end

local player = {name = "Hero", level = 50, class = "Warrior"}
for k, v in pairs(player) do
  print(k .. " = " .. tostring(v))
end
-- Output (order may vary):
-- name = Hero
-- level = 50
-- class = Warrior

for index, value in ipairs(arr) do
  -- process
end

local items = {"sword", "shield", "potion"}
for i, item in ipairs(items) do
  print(i .. ": " .. item)
end
-- Output:
-- 1: sword
-- 2: shield
-- 3: potion

-- Use ipairs for arrays (faster, ordered)
local arr = {1, 2, 3, 4, 5}
for i, v in ipairs(arr) do
  print(v)
end
 
-- Use pairs for dictionaries
local dict = {a = 1, b = 2, c = 3}
for k, v in pairs(dict) do
  print(k, v)
end
 
-- Check for nil before accessing properties
local myTable = { key = "hello" }  -- Define the table first
local value = myTable.key
if value then
  print(value)
end
 
-- Safe access pattern for potentially nil tables
local data = someTable and someTable.key or "default"
 
-- Use table.concat for string building (more efficient than ..)
local parts = {"Hello", " ", "World"}
local result = table.concat(parts)  -- "Hello World"