1

lua -v        # Lua 5.4.x

1
2
3

lua script.lua            # 运行脚本文件
lua -e "print('hello')"   # 直接执行一段代码
lua                        # 进入交互式 REPL（Ctrl+D 退出）

1
2

-- script.lua
print("Hello, Lua!")       -- 输出：Hello, Lua!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

-- 单行注释

--[[
   多行注释
   可以跨越多行
]]

--[==[
   当注释内容里含有 ]] 时，
   可以用更多等号作为长括号边界
]==]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

a = 10            -- 全局变量（不推荐）
local b = 20      -- 局部变量（推荐）

do
    local c = 30  -- 只在 do...end 块内可见
end
-- print(c)       -- 错误：c 在此处为 nil

local x, y = 1, 2 -- 同时声明多个
local z           -- 未赋值，默认 nil

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

print(type(nil))        -- nil
print(type(true))       -- boolean
print(type(10))         -- number
print(type("abc"))      -- string
print(type({}))         -- table
print(type(print))      -- function

-- 只有 nil 和 false 为假，0 和 "" 都是真！
if 0 then print("0 是真的") end
if "" then print("空串也是真的") end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

print(tonumber("123"))      -- 123
print(tonumber("3.14"))     -- 3.14
print(tonumber("abc"))      -- nil（转换失败）
print(tonumber("FF", 16))   -- 255（按十六进制解析）

print(tostring(123))        -- "123"
print(tostring(nil))        -- "nil"

-- 字符串与数字在算术中会自动转换
print("10" + 5)             -- 15
print("3" * "4")            -- 12
-- 但比较时不会自动转换
print("10" == 10)           -- false

1
2
3
4

print(7 / 2)      -- 3.5（Lua 的 / 总是浮点除法）
print(7 // 2)     -- 3（整除，5.3+）
print(7 % 2)      -- 1
print(2 ^ 10)     -- 1024.0（幂运算）

1
2
3
4
5
6
7
8
9

-- and / or 返回操作数，可用于默认值
local name = nil
local display = name or "默认名"   -- "默认名"
local ok = true and "成功"         -- "成功"

-- 模拟三目运算符：条件 and 真值 or 假值
local age = 20
local tag = (age >= 18) and "成年" or "未成年"   -- "成年"
-- 注意：当真值为 false/nil 时会失效，需用表或函数替代

1
2
3
4

print("a" .. "b")        -- ab
print("n=" .. 10)        -- n=10
print(1 .. 2 .. 3)       -- 123
-- 效率提示：循环内大量拼接会产生很多临时字符串，建议用 table.concat

1
2

print(#"hello")          -- 5
print(#{1, 2, 3})        -- 3

1
2
3
4
5
6
7
8

^
not  #  -（一元负号）
*  /  //  %
+  -
..（右结合）
<  >  <=  >=  ~=  ==
and
or

1
2
3
4
5
6
7
8

local score = 85
if score >= 90 then
    print("优秀")
elseif score >= 60 then
    print("及格")
else
    print("不及格")
end

1
2
3
4
5

local i = 0
while i < 3 do
    print(i)
    i = i + 1          -- Lua 没有 i++ / i += 1
end

1
2
3
4

local n = 0
repeat
    n = n + 1
until n >= 3           -- 条件为真时退出

1
2
3
4
5
6
7

for i = 1, 5 do        -- 1 到 5，步长默认 1
    print(i)
end

for i = 10, 1, -2 do   -- 起始、结束、步长
    print(i)           -- 10, 8, 6, 4, 2
end

1
2
3

for index, value in ipairs({ "a", "b", "c" }) do
    print(index, value)
end

1
2
3
4
5

for i = 1, 5 do
    if i == 3 then goto continue end
    print(i)
    ::continue::
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

-- 标准定义
local function add(a, b)
    return a + b
end

-- 等价写法（语法糖）
local add2 = function(a, b) return a + b end

print(add(1, 2))       -- 3

-- 函数作为参数（高阶函数）
local function apply(f, a, b)
    return f(a, b)
end
print(apply(add, 3, 4))  -- 7

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

local function minMax(list)
    local min, max = list[1], list[1]
    for _, v in ipairs(list) do
        if v < min then min = v end
        if v > max then max = v end
    end
    return min, max
end

local lo, hi = minMax({3, 1, 4, 1, 5})   -- lo=1, hi=5
print(lo, hi)

local x, y, z = minMax({3, 1, 4})         -- z 为 nil

1
2
3
4
5
6
7

local function f() return 1, 2, 3 end

print(f())          -- 1  2  3
print((f()))        -- 1（加括号只取第一个）
print(f(), 9)       -- 1  9（不是最后一个位置只取第一个）
local t = { f() }   -- {1, 2, 3}（列表构造时全部展开）
local t2 = { f(), 9 } -- {1, 9}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

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 处理可变参数
local function count(...)
    return select("#", ...)   -- 参数个数
end

local function second(...)
    return select(2, ...)     -- 从第 2 个开始的全部参数
end

print(count(1, nil, 3))   -- 3（# 也能统计 nil）
print(second("a", "b", "c"))  -- b  c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

-- 默认参数：用 or 提供默认值
local function greet(name, greeting)
    name = name or "世界"
    greeting = greeting or "你好"
    print(greeting .. "，" .. name)
end
greet()               -- 你好，世界

-- 命名参数：传入一个 table
local function createWindow(opts)
    local title  = opts.title  or "无标题"
    local width  = opts.width  or 800
    local height = opts.height or 600
    print(title, width, height)
end
createWindow({ title = "主窗口", width = 1024 })

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

local function counter()
    local count = 0
    return function()
        count = count + 1
        return count
    end
end

local c1 = counter()
print(c1())   -- 1
print(c1())   -- 2
local c2 = counter()
print(c2())   -- 1（独立的新闭包）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

-- 闭包在游戏中的典型用法：状态机、防抖、迭代器
local function makeIterator(t)
    local i = 0
    return function()
        i = i + 1
        return t[i]
    end
end

local it = makeIterator({ "a", "b", "c" })
print(it())   -- a
print(it())   -- b

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

-- 尾调用：返回的是函数调用，可优化
local function loop(n)
    if n == 0 then return end
    return loop(n - 1)   -- 尾调用，不会栈溢出
end

-- 非尾调用：n * f(n-1) 中调用后还要做乘法
local function fact(n)
    if n <= 1 then return 1 end
    return n * fact(n - 1)   -- 普通递归，n 大时会栈溢出
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

-- 数组式（下标从 1 开始！）
local arr = { 10, 20, 30 }
print(arr[1])        -- 10
print(arr[3])        -- 30
print(arr[0])        -- nil（Lua 没有 0 下标）

-- 字典式
local person = { name = "张三", age = 25 }
print(person.name)       -- 张三
print(person["age"])     -- 25（等价写法）

-- 混合
local mixed = {
    1, 2, 3,             -- 1,2,3 为数组部分
    name = "test",       -- 键值部分
    [100] = "hundred",   -- 显式键
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

local t = {}

t.name = "Lua"           -- 新增/修改
t["version"] = 5.4
print(t.name)            -- Lua

t.name = nil             -- 删除：置为 nil
print(t.name)            -- nil

-- 数组操作
local list = { "a", "b", "c" }
list[#list + 1] = "d"    -- 尾部追加（惯用写法）
table.insert(list, "e")  -- 用 table 库追加
table.insert(list, 1, "z")  -- 在索引 1 处插入
table.remove(list, 1)    -- 删除索引 1 处元素
print(#list)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

local arr = { "a", "b", "c" }

-- ipairs：遇到第一个 nil 就停止
for i, v in ipairs(arr) do
    print(i, v)          -- 1 a / 2 b / 3 c
end

-- pairs：遍历全部键（含非整数键）
local person = { name = "张三", age = 25, city = "北京" }
for k, v in pairs(person) do
    print(k, v)          -- 顺序不保证
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

local t = { 3, 1, 4, 1, 5 }

table.insert(t, 9)              -- 尾部插入 → {3,1,4,1,5,9}
table.remove(t)                 -- 删除并返回末尾 → 9
table.sort(t, function(a, b) return a < b end)  -- 排序
print(table.concat({ "a", "b", "c" }, "-"))     -- a-b-c
print(table.unpack({ 1, 2, 3 }))                -- 1  2  3（5.2+，5.1 用 unpack）

-- 深拷贝（浅拷贝直接赋值即可，table 是引用类型）
local function deepCopy(orig)
    if type(orig) ~= "table" then return orig end
    local copy = {}
    for k, v in pairs(orig) do
        copy[k] = deepCopy(v)
    end
    return copy
end

-- 经典：数组洗牌
math.randomseed(os.time())
for i = #t, 2, -1 do
    local j = math.random(i)
    t[i], t[j] = t[j], t[i]   -- 平行赋值实现交换
end

1
2
3
4
5
6
7
8
9

local a = { 1, 2, 3 }
local b = a          -- b 和 a 是同一张表（引用）
b[1] = 100
print(a[1])          -- 100

local c = { 1, 2, 3 }
local d = c
c = {}               -- c 指向新表，d 仍指向旧表
print(d[1])          -- 1

1
2
3
4
5
6
7
8

local t = {}
local mt = {}                       -- 元表也是一个普通表
setmetatable(t, mt)                 -- 设置元表
print(getmetatable(t) == mt)        -- true

-- 保护元表：外部不可修改
-- setmetatable(t, { __metatable = "locked" })
-- print(getmetatable(t))           -- "locked"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

-- 用法一：默认值
local defaults = { color = "red", size = 10 }
local config = setmetatable({}, { __index = defaults })
print(config.color)     -- red（自身没有，去 defaults 找）

-- 用法二：函数形式
local t = setmetatable({}, {
    __index = function(tbl, key)
        return "未定义的键：" .. tostring(key)
    end
})
print(t.foo)            -- 未定义的键：foo

1
2
3
4
5
6
7

-- 用法三：只读表
local protected = setmetatable({}, {
    __newindex = function()
        error("不允许修改只读表", 2)
    end,
})
-- protected.x = 1      -- 报错

 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

local Vector = {}
Vector.__index = Vector

function Vector.new(x, y)
    return setmetatable({ x = x, y = y }, Vector)
end

function Vector.__add(a, b)
    return Vector.new(a.x + b.x, a.y + b.y)
end

function Vector.__eq(a, b)
    return a.x == b.x and a.y == b.y
end

function Vector.__tostring(v)
    return "(" .. v.x .. ", " .. v.y .. ")"
end

function Vector.__call(v, scale)
    return Vector.new(v.x * scale, v.y * scale)
end

local v1 = Vector.new(1, 2)
local v2 = Vector.new(3, 4)
print(v1 + v2)          -- (4, 6)
print(v1 == Vector.new(1, 2))  -- true
print(v1(2))            -- (2, 4)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

-- mymod.lua
local M = {}                 -- 模块表

function M.add(a, b)
    return a + b
end

function M.greet(name)
    return "Hello, " .. name
end

-- 私有函数（外部不可访问）
local function helper() end

return M                     -- 返回模块表

1
2
3
4
5
6
7
8

-- main.lua
local mymod = require("mymod")   -- 首次加载后会被缓存
print(mymod.add(1, 2))           -- 3
print(mymod.greet("Lua"))        -- Hello, Lua

-- 再次 require 返回同一份缓存，不会重新执行
local same = require("mymod")
print(same == mymod)             -- true

1
2
3

print(package.path)
-- 可通过环境变量 LUA_PATH 或代码追加
package.path = package.path .. ";./?/init.lua"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

local co = coroutine.create(function(a, b)
    print("开始", a, b)
    local c = coroutine.yield(a + b)   -- 让出，返回值给 resume
    print("恢复，收到", c)
    return "结束"
end)

print(coroutine.resume(co, 1, 2))  -- true  3
print(coroutine.resume(co, 10))    -- 恢复，收到 10 / true  结束
print(coroutine.resume(co))        -- false  cannot resume dead coroutine

1
2
3
4
5
6
7
8
9

local gen = coroutine.wrap(function()
    for i = 1, 3 do
        coroutine.yield(i)
    end
end)

print(gen())   -- 1
print(gen())   -- 2
print(gen())   -- 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

local task = coroutine.wrap(function()
    for i = 1, 3 do
        print("执行第 " .. i .. " 步")
        coroutine.yield()
    end
end)

-- 每帧调用一次 task()，即可分帧完成
task()   -- 执行第 1 步
task()   -- 执行第 2 步
task()   -- 执行第 3 步

 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

-- 主动抛错
local function divide(a, b)
    if b == 0 then
        error("除数不能为零", 2)   -- 2 表示错误定位到调用者
    end
    return a / b
end

-- assert：条件为假时抛错，常用于参数校验
local function setAge(age)
    assert(type(age) == "number", "age 必须是数字")
    assert(age >= 0, "age 不能为负")
end

-- pcall：保护性调用，返回 (成功, 结果或错误信息)
local ok, result = pcall(divide, 10, 0)
print(ok, result)     -- false  除数不能为零

local ok2, result2 = pcall(divide, 10, 2)
print(ok2, result2)   -- true   5.0

-- xpcall：可传入错误处理函数，能获取堆栈信息
local function onError(err)
    return "捕获错误：" .. debug.traceback(err, 2)
end

local ok3, msg = xpcall(function()
    error("出错了")
end, onError)
print(ok3)            -- false
print(msg)            -- 捕获错误：...（含堆栈）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

local s = "Hello, Lua"

print(s:upper())                       -- HELLO, LUA（用冒号调用方法）
print(s:lower())                       -- hello, lua
print(s:len())                         -- 10
print(string.sub(s, 1, 5))             -- Hello
print(string.rep("ab", 3))             -- ababab
print(string.reverse("abc"))           -- cba
print(string.format("%d-%s-%.2f", 1, "x", 3.14159))  -- 1-x-3.14

-- 模式匹配（Lua 的"正则"，功能较弱但够用）
print(string.find("hello world", "world"))     -- 7  11
print(string.match("2026-09-19", "(%d+)-(%d+)-(%d+)"))  -- 2026 9 19
print(string.gsub("a-b-c", "-", "+"))          -- a+b+c  2
print(string.match("key=value", "(%w+)=(%w+)")) -- key  value

-- 模式中的魔法字符
-- %d 数字  %a 字母  %w 字母数字  %s 空白  %p 标点
-- + 一次或多次  * 零次或多次  - 懒惰匹配  ? 可选
-- . 任意字符（除换行）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

print(math.floor(3.7))     -- 3
print(math.ceil(3.2))      -- 4
print(math.abs(-5))        -- 5
print(math.max(1, 5, 3))   -- 5
print(math.min(1, 5, 3))   -- 1
print(math.sqrt(16))       -- 4.0
print(math.random(1, 100)) -- 随机整数

math.randomseed(os.time())  -- 播种，避免每次随机序列相同
print(math.huge, -math.huge, 0/0)  -- 正无穷 负无穷 nan

1
2
3
4
5

print(os.time())                    -- Unix 时间戳
print(os.date("%Y-%m-%d %H:%M:%S")) -- 格式化时间
print(os.clock())                   -- CPU 时间（用于性能测试）
os.exit(0)                          -- 退出程序
-- os.execute("dir")                -- 执行系统命令（注意安全）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

-- 读文件
local file = io.open("data.txt", "r")
if file then
    local content = file:read("*a")   -- *a 读全部，*l 读一行
    file:close()
    print(content)
end

-- 写文件
local out = io.open("out.txt", "w")
out:write("Hello\n")
out:write("World\n")
out:close()

-- 按行遍历
for line in io.lines("data.txt") do
    print(line)
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

-- 定义"类"
local Animal = {}
Animal.__index = Animal            -- 实例找不到的键，去 Animal 里找

-- 构造函数
function Animal.new(name, age)
    local self = setmetatable({}, Animal)  -- 新对象，元表是 Animal
    self.name = name
    self.age = age
    return self
end

-- 实例方法（用冒号，隐式传入 self）
function Animal:speak()
    print(self.name .. " 发出了声音")
end

function Animal:getName()
    return self.name
end

-- 使用
local cat = Animal.new("咪咪", 2)
cat:speak()                        -- 咪咪 发出了声音
print(cat:getName())               -- 咪咪

-- 点号与冒号的等价关系
-- cat:speak()  等价于  cat.speak(cat)

 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

local Dog = {}
Dog.__index = Dog
setmetatable(Dog, { __index = Animal })   -- Dog 继承 Animal

function Dog.new(name, age, breed)
    local self = Animal.new(name, age)    -- 调用父类构造
    setmetatable(self, Dog)               -- 换成 Dog 的元表
    self.breed = breed
    return self
end

-- 重写父类方法
function Dog:speak()
    print(self.name .. " 汪汪叫")
end

-- 调用父类方法
function Dog:describe()
    Animal.speak(self)                    -- 显式调用父类实现
    print("品种：" .. self.breed)
end

local dog = Dog.new("旺财", 3, "柴犬")
dog:speak()          -- 旺财 汪汪叫（多态）
dog:getName()        -- 继承自 Animal
print(dog:describe and "ok" or "no")
dog:describe()       -- 旺财 发出了声音 / 品种：柴犬

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

local function newCounter()
    local count = 0                    -- 私有，外部无法直接访问
    local obj = {}
    function obj.inc()
        count = count + 1
        return count
    end
    function obj.get()
        return count
    end
    return obj
end

local c = newCounter()
c.inc()
c.inc()
print(c.get())   -- 2
print(c.count)   -- nil（外部访问不到）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>

lua_State* L = luaL_newstate();
luaL_openlibs(L);                       /* 打开标准库 */

/* 执行 Lua 代码 */
luaL_dostring(L, "print('来自 C 的调用')");

/* 把一个 C 函数注册给 Lua */
lua_register(L, "c_add", c_add);

lua_close(L);

1
2
3
4
5
6
7
8

-- xLua 中调用 C# 示例
local GameObject = CS.UnityEngine.GameObject
local go = GameObject("MyObject")
go:AddComponent(typeof(CS.UnityEngine.Rigidbody))

-- 访问 C# 静态字段/方法
CS.UnityEngine.Time.deltaTime
CS.UnityEngine.Debug.Log("Hello from Lua")

1
2
3
4
5

// C# 侧加载并调用 Lua
LuaEnv env = new LuaEnv();
env.DoString("print('来自 C# 的 Lua 代码')");
env.DoString("require('game_logic')");
env.Dispose();

 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

-- 1. 数组下标从 1 开始，不是 0
local t = { 10, 20, 30 }
-- t[0] 是 nil，不是 10

-- 2. 全局变量要避免，始终用 local
local function bad() x = 1 end      -- 意外创建全局
local function good() local x = 1 end

-- 3. 0 和 "" 在条件判断中为真
if 0 then print("会执行") end
-- 判断空串要显式写：if s == "" then

-- 4. 表是引用类型，赋值不是拷贝
local a = { 1 }
local b = a
b[1] = 2
print(a[1])          -- 2

-- 5. 循环中拼接字符串性能差，用 table.concat
-- 差：
-- local s = ""
-- for i = 1, 10000 do s = s .. i end
-- 好：
local buf = {}
for i = 1, 10000 do buf[#buf + 1] = i end
local s = table.concat(buf)

-- 6. 用 == nil 判断存在，不要用 not
-- not 会把 false 也当成不存在
local flag = false
-- if not flag then ... end   -- 误判
if flag == nil then end        -- 正确

-- 7. pairs 遍历顺序不确定，不要依赖顺序
-- 需要顺序时先收集键再 table.sort

-- 8. # 的长度只在序列（从 1 连续）时可靠
local hole = { 1, 2, nil, 4 }
-- #hole 结果不确定（可能是 4，也可能是 2）

-- 9. 函数调用缺少 self 时用点号即可，有 self 用冒号
local obj = {}
function obj:method() end   -- 定义用冒号
obj:method()                -- 调用用冒号

-- 10. 深拷贝要递归，简单赋值只拷贝引用