Lua是一个简洁、轻量、可扩展的脚本语言。Lua有着相对简单的C语言API而很容易嵌入应用中。很多应用程序使用Lua作为自己的嵌入式脚本语言，以此来实现可配置性、可扩展性。

注释

-- 单行注释

--[[
 多行注释
]]

变量

赋值

赋值

a = "hello, world"

给多个变量赋值

c, d = 10, 30

交换变量

x, y = 1, 3
x, y = y, x
print(x, y)

赋值个数不足时，多的变量会用nil补足

a, b, c  = 1, 3
print(a, b, c) ---> 1 3 nil

赋值个数多余时，多出的值会被忽略

a, b = 1, 2, 3
print(a, b) ---> 1, 2

变量

变量默认值均为nil

print(undefined_value)

lua默认只有一种Number类型 即double双精度类型

print(10)
print(0.3)
print(2e+10)

字符串使用’’ 或者 “”包裹均可

str1 = "str1"
str2 = 'str2'

[[ ]] 跨行表示多个字符串 内容均原样输出 即raw string

html = [[
<html>
<head></head>
<body>
  <a href="https://www.twle.cn/">
    lua
  </a>
</body>
</html>
]]
print(html)

字符串连接

print("a" .. "b")
print(157 .. 428)  -- 157428

字符串长度

print(#"string")

全局变量和局部变量。默认声明的变量均为全局变量，如果在前面加上local关键字则仅在作用域内生效

function main()
  local b = 12
  a = 23
end

main()
print(a) --23
print(b) --nil

类型转换

a, b, c = "str", "1", "2"
-- 进行算术运算时，string类型会尝试自动转换为number
-- print(a + b) 类型不匹配会报错
print(b+c)

-- 使用 .. 字符串拼接，number会自动转为string
a, b = 1, 2
print(type(a .. b))

-- 显式转换，如
print(type(tostring(12))) -- string
print(type(tonumber("12"))) -- number

运算

运算符

local c,d = 4,3
print(c+d)
print(c-d)
print(c/d)
print(c*d)
print(c%d) -- 取余
print(c^d) -- 幂运算

关系运算

a, b = 4, 3
print(a < b)
print(a <= b)
print(a == b)
print(a ~= b) -- 不等于
print(a > b)
print(a >= b)

逻辑运算

a, b = true, false
print(a and b) -- 与
print(a or b) -- 或
print(not a) -- 非
print(a and not b) -- 即其他语言中的 a && !b

条件判断 循环

while循环

local num = 1
while (num < 5) do
  print("num value is:", num)
  num = num + 1
end

for循环

-- i从10变为1，每次变动量为-1
-- 第三个参数为可选默认为1，参数二只会在一开始求值，之后不会再进行运算
for i = 10, 1, -1 do
  print(i)
end

f = function(x)
  print("in f(x)")
  return x * 2
end

for i = 1, f(5) do
  print(i)
end

repeat…until 循环

local num = 11
repeat
  print("num value is:", num)
  num = num + 1
until num > 15

if 条件判断

在lua中 0为true，nil可以当做false

if (0) then
  print("0 is true")
end

if elseif else

local age = 27
if age < 18 then
  print("age less than 18")
elseif age < 25 then
  print("age less than 25")
elseif age < 30 then
  print("age less than 30")
else
  print("age more than 30")
end

break

local num = 11
repeat
  print("num value is:", num)
  num = num + 1
  if num > 15 then
    break  -- break跳出循环
  end
until num > 20

函数

普通函数

local function main()
  print("this is a local function")
end

函数赋值给变量

local main = function()
  print("this is a local function")
end

函数带返回值

local function min(a, b)
  if a < b then
    return a
  else
    return b
  end
end

函数作为参数

local p = function(res)
  print("print self style", res)
end

local function main(a, b, p)
  p(a + b)
end

main(1, 2, p)

返回多个值

local function min(a)
  local sum = 0
  local factorial = 1
  for i, v in pairs(a) do
    sum = sum + v
    factorial = factorial * v
  end
  return sum, factorial
end

local a, b = min({1, 2, 3, 4})
print(a, b)

可变参数

local function average(...)
  local result = 0
  local arg = { ... }
  for i, v in pairs(arg) do
    result = result + v
  end
  return result / #arg
end

print("average is:", average(1, 3, 5, 7, 9, 11))

字符串

转大写/转小写

upperStr = string.upper("str")
print(upperStr)

lowerStr = string.lower("STR")
print(lowerStr)

替换字符串，返回替换后的字符串，若未匹配到返回nil，第三个参数可选为替换次数，默认全部替换，匹配字符串可以使用正则

newStr = string.gsub("aaaaa", "a", "b", 3)
print(newStr)

newStr = string.gsub("Today is 2025/04/18", "%d%d%d%d/%d%d/%d%d", "a good day.")
print(newStr)

查找字符串返回找到的索引，若未查找到返回nil，第三个参数可选，为开始查找位置的索引，默认为1

result = string.find("reference", "fer")
print(result)

result = string.find("Today is 2025/04/18", "%d%d%d%d/%d%d/%d%d")
print(result)

字符串反转

newStr = string.reverse("fw")
print(newStr)

格式化字符串

newStr = string.format("value:%d", 20)
print(newStr)

将数字转为对应的字符，并拼接

newStr = string.char(97,98,99,100)
print(newStr)

获取字符串中某个位置字符的编码，第二个参数index可以不传，默认为1

string.byte("ABCD",4) -- 68

计算字符串长度

str = "abcd"
len = string.len(str)
print(len)

-- 也可以使用#加字符串来获取长度
len = #str
print(len)

获取字符串的n份拷贝

re = string.rep("fw", 2)
print(re)

切割字符串，传入开始位置和结束位置，结束位置可选，默认为字符串长度

result = string.sub("reference", 5, 6)
print(result)

模式正则匹配

-- 在字符串中查找对应匹配项，如果匹配pattern有多项，如下面这个，那么返回值也是多项
-- 在第一次匹配到后，就会立即返回对应的匹配结果，如果全部不匹配，那么返回nil
num, word = string.match("I have 2 questions for you.", "(%d+) (%a+) ")
print(num, word)

全量模式正则匹配

-- gmatch会将所以匹配到的结果存储到table中
for world in string.gmatch("I have 2 questions for you.", "%a+") do
  print(world)
end

正则匹配项

  • %a 与任何字母匹配
  • %c 与任何控制符匹配，如\n
  • %d 与任何数字匹配
  • %l 与任何小写字母匹配
  • %p 与任何标点匹配
  • %s 与空白字符匹配
  • %u 与任何大写字母匹配
  • %w 与任何字母/数字匹配
  • %x 与任何十六进制数匹配
  • %z 与任何代表0的字符匹配

Math数学函数

最大浮点数和最小整数

print(math.huge)
print(math.mininteger)

绝对值

local a = math.abs(-1)
print(a)

向上取整，向下取整，求余

local b = math.ceil(1.2) -- 向上取整
local c = math.floor(1.2) -- 向下取整
local d = math.fmod(9.9, 9) -- 求余
print(b, c, d)

最大值，最小值

local g = math.max(1, 2, 3)
local h = math.min(1, 2, 3)
print(g, h)

平方根

local r = math.sqrt(9)
print(r)

获取数字的类型

local l = math.type(1.2)
local m = math.type(3)
local n = math.type("")
print(l, m, n)

返回指定底的值的对数

local e = math.log(4, 2) -- 即log以2为底4的对数
print(e)  -- 即 2 ^ 2 = 4

自然对数的底数的次方

local f = math.exp(2)
print(f) -- 7.3890560989307  即 e ^ 2

伪随机数

print(math.random())          -- [0, 1)之间的浮点伪随机数
print(math.random(10))        -- [1, n]区间内的整数伪随机数
print(math.random(10, 100))   -- [n, m]区间内的整数伪随机数

无符号数比较大小

local o = math.ult(1, 10)  -- a < b 返回true 否则false
print(o)

转整数

local p = math.tointeger("3")  -- 可以转为整数返回3
local q = math.tointeger(0.32) -- 不能转为整数返回nil
print(p, q)

整数小数部分拆分

local i, j = math.modf(3.14)
print(i, j)  -- 3  0.14

圆周率

print(math.pi)

正弦、余弦、正切、反正弦、反余弦、反正切

print(math.sin(math.pi / 2))
print(math.cos(math.pi))
print(math.tan(math.pi / 4))
print(math.asin(1.0))
print(math.acos(1.0))
print(math.atan(1.0))

角度转弧度

print(math.rad(90))

弧度转角度

print(math.deg(math.pi))

table

lua中的table是一种兼具数组和Map的存在

当做数组使用

local table = {} -- 初始化一个空的数组

local table = {"a", "b", "c", "d"}  -- 初始化一个有值的数组
table[5] = "e"  -- 给指定位置的元素赋值

for i = 1, 5 do   -- 遍历数组
  print(table[i])
end

多维数组

local table = {
  {"a", "b", "c"},
  {"d", "e", "f"}
}

-- #table获取长度的形式只能在数组中使用，#table只会统计连续数字索引的长度，如果都是字符串的key，那么不会长度为0
for i = 1, #table do  
  for j = 1, #table[i] do
    print(table[i][j])
  end
end

用作map使用

local table = {}

table.name = "fw"
table.age = "18"
table["sex"] = "boy"

print(#table)  -- 此处因为是map所以长度为0

删除table

table = nil  -- 赋值为nil 即删除table
print(table)

table函数

将table中指定区间的元素使用给定的字符串拼接

local a = {"apple", "orange", "peach"}
-- table.concat(table, [sep], [start], [end])
-- 不传 sep 的话，默认使用空字符串连接
print(table.concat(a, "---", 1, 3)) -- apple---orange---peach

table插入

local a = {"apple", "orange", "peach"}
-- 不传入位置的话，默认在数组尾部插入
table.insert(a, 1, "pear")
print(a[1])

table拷贝元素到另一个table，合成一个新table返回

local array = { "a", "b", "c" }
-- 把array从1到3的元素数组，拷贝到另一个table的2位置开始
-- 如果没有传另一个table，默认使用原数组
for i,v in pairs(table.move(array, 1, 3, 2)) do
  print(v)  -- 输出 a a b c
end


local src = {10, 20, 30, 40}
local dest = {'a', 'b', 'c', 'd'}

for i, v in pairs(table.move(src, 1, 2, 1, dest)) do
  print(v) -- 输出 10, 20 , 'c', 'd'
end

table排序

local array = { "d", "c", "a", "b"}

local f = function(a, b) -- 创建排序函数
  return string.byte(a) - string.byte(b) < 0
end

table.sort(array, f) -- 进行排序

for i = 1, #array do
  print(array[i])
end

for循环

-- 数组 index 和 pairs 的形式均可
array = {'a', 'b', 'c', 'd'}

for i = 1, #array do
  print(array[i])
end

for i, v in pairs(array) do
  print(i, v)
end


-- map 使用pairs的形式获取key value
table = {}
table['a'] = 'a'
table['b'] = 'b'
table['c'] = 'c'

for key, value in pairs(table) do
  print(key, value)
end

无状态的迭代器

function square(d,n)
  if n < d then
    n = n + 1
    return n, n*n
  end
end

-- 把5,0作为参数传入迭代器square中
-- 在迭代器中5是不可变状态，0是初始控制变量，会在迭代器中进行更改
for i,n in square,5,0 do
  print(i,n)
end

-- square(5, 0) 返回 1, 1
-- square(5, 1) 返回 2, 4
-- square(5, 2) 返回 3, 9
-- ...
-- n = 5 不成立返回nil 循环终止