Lua入门

Fri, 17 Jul 2026 17:58:26 +0800

一、Lua 简介

Lua 是一门轻量、小巧、可嵌入的脚本语言，1993 年诞生于巴西里约热内卢天主教大学。它的设计目标是作为一种"胶水语言"，方便地嵌入到宿主程序（通常是 C/C++ 程序）中，为其提供灵活的扩展能力。

核心特点：

轻量：解释器极小（约 200KB），启动快，内存占用低
可嵌入：通过 C API 与宿主程序双向调用，极易集成
动态类型：变量无需声明类型，运行时确定
表（Table）为核心：数组、字典、对象、模块、命名空间都用表实现
函数是一等公民：函数可作为变量、参数、返回值，支持闭包
协程支持：语言内置非对称协程，适合异步/状态机
自动内存管理：基于标记清除的 GC

典型应用场景：

领域	案例
游戏开发	《魔兽世界》插件、ROBLOX、LÖVE 引擎、Unity 的 xLua / ToLua
Web 服务	OpenResty（Nginx + Lua）、Kong 网关
数据库	Redis 脚本、Tarantool
嵌入式	路由器、机顶盒、Wireshark 的脚本
编辑器/工具	Neovim、AwesomeWM、Pandoc 过滤器

对游戏开发者来说，Lua 最大的价值在于热更新：把易变的业务逻辑（技能、活动、数值）写成 Lua，可以在线替换脚本而无需重新打包发版。

二、环境搭建与运行

安装：从 lua.org 下载源码编译，或使用发行版包管理器（apt install lua5.4、brew install lua）。游戏项目常使用 LuaJIT（兼容 Lua 5.1，带 JIT 编译，性能更高）。

检查版本：

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


-- 单行注释

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

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

三、基础语法

3.1 变量与作用域

Lua 的变量分为全局变量和局部变量。默认声明的变量是全局的，用 local 显式声明的是局部变量。

强烈建议：凡是能用局部变量的地方就用 local。局部变量访问更快（走寄存器），且不会污染全局环境。

 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

命名规范：

变量、函数：小驼峰 local userName = "张三"
常量：全大写下划线 local MAX_LEVEL = 99
私有成员：下划线开头 local _internal = {}
避免用 _ 之外的下划线开头命名（如 _G、_ENV 是保留用途）

3.2 数据类型

Lua 有 8 种基本类型，用 type() 可以获取。

类型	说明	示例
`nil`	空值，表示"无"	`local a` → nil
`boolean`	布尔，只有 `true` / `false`	`local b = true`
`number`	数字（5.3+ 区分整数/浮点，5.1 只有 double）	`10`、`3.14`
`string`	字符串（不可变）	`"hello"`、`'hi'`
`table`	表，唯一的数据结构	`{1, 2, 3}`
`function`	函数	`function f() end`
`userdata`	C 侧数据（如 Unity 对象）	由 C 创建
`thread`	协程	`coroutine.create(...)`

 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

3.3 运算符

算术运算符：+ - * / % ^，以及 5.3+ 的整除 //。

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（幂运算）

关系运算符：== ~= < > <= >=（注意"不等于"是 ~= 而不是 !=）。

逻辑运算符：and or not，具有短路特性，且返回的是操作数本身而非 true/false。

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

3.4 流程控制

if / elseif / else：

1
2
3
4
5
6
7
8


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

while：

1
2
3
4
5


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

repeat…until（至少执行一次）：

1
2
3
4


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

数值 for：

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

泛型 for（遍历迭代器，后面 Table 章节详解）：

1
2
3


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

break 与 goto：break 跳出当前循环；goto label 跳转（Lua 5.2+，LuaJIT/5.1 不支持）。Lua 没有 continue，可用 goto 或反向 if 模拟。

1
2
3
4
5


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

四、函数

4.1 基本用法

函数用 function 定义，本质是一个值，可赋给变量、作为参数传递、作为返回值。

 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

4.2 多返回值

Lua 函数可以返回多个值，这是它非常有用的特性。

 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}

4.3 可变参数

用 ... 接收不定数量的参数。

 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

4.4 默认参数与命名参数

Lua 不支持默认参数和命名参数，但可用惯用法模拟。

 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 })

4.5 闭包

闭包是函数 + 其捕获的外部局部变量。即使外层函数返回，被捕获的变量依然存在。

 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

4.6 尾调用优化

当函数调用是函数的最后一个动作时，Lua 会进行尾调用优化，不增加栈深度（类似尾递归优化）。这对递归算法很重要。

 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

五、表（Table）

表是 Lua 中唯一的数据结构，既可以当数组，也可以当字典（哈希表），还能模拟对象、模块、队列、栈。理解表就理解了 Lua 的一半。

5.1 构造与访问

 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 开始连续，避免出现"空洞"，否则 # 长度不可预测。

5.2 增删改查

 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)

5.3 遍历：ipairs 与 pairs

迭代器	用途	顺序
`ipairs`	遍历数组部分（从 1 开始、连续整数键）	有序（1,2,3…）
`pairs`	遍历所有键值对	无序（哈希顺序）

 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

坑：遍历过程中不要新增键（未定义行为），删除当前键在 pairs 中允许但需谨慎。

5.4 table 库常用函数

 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

注意：t = {} 只是让 t 指向新表，若有其他变量引用同一张表，它们仍指向旧表。

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

六、元表与元方法（Metatable）

元表允许我们改变表的行为——定义表的加法、比较、索引、调用等操作。这是 Lua 面向对象和高级用法的基础。

6.1 setmetatable 与 getmetatable

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"

6.2 常用元方法

元方法	触发时机
`__index`	访问不存在的键时
`__newindex`	设置不存在的键时
`__add` / `__sub` / `__mul` / `__div`	算术运算
`__eq` / `__lt` / `__le`	比较运算
`__tostring`	`tostring()` 或 `print()` 时
`__call`	把表当函数调用时
`__len`	对表用 `#` 时（5.2+）
`__concat`	用 `..` 连接时

6.3 __index：实现继承与默认值

__index 是最重要的元方法，用于查找缺失的键。它可以是表（从该表继续查）或函数。

 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 -- 报错

6.4 运算符重载

 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)

注意：__eq 只有在两个操作数类型相同且元表相同时才会触发；__lt/__le 可混合类型，但需都定义了元方法。

七、模块与包

Lua 用表来实现模块，用 require 加载。

 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

包搜索路径：package.path 决定 require 去哪找 .lua 文件。

1
2
3


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

八、协程（Coroutine）

协程是一种比线程更轻量的协作式并发：同一时刻只有一个协程运行，由程序主动让出控制权。用它可以优雅地实现状态机、异步流程、迭代器。

函数	作用
`coroutine.create(f)`	创建协程
`coroutine.resume(co, ...)`	启动/恢复协程
`coroutine.yield(...)`	让出协程
`coroutine.status(co)`	查看状态（suspended/running/dead）
`coroutine.wrap(f)`	创建协程并返回直接可调用的函数

 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

coroutine.wrap 更简洁，调用即 resume，错误会直接抛出：

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

游戏开发典型用途：把一段需要"分帧执行"的逻辑写成协程，每帧 resume 一次，避免卡顿。

 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 步

九、错误处理

Lua 不强制捕获异常。错误可以显式抛出（error），也可以自动捕获并用 pcall / xpcall 处理。

 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) -- 捕获错误：...（含堆栈）

错误约定：抛出的错误对象通常是字符串；也可以用 error({ code = 500, msg = "..." }) 抛出 table，配合 pcall 结构化处理。

十、常用标准库

10.1 string 库

 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 标点
-- + 一次或多次 * 零次或多次 - 懒惰匹配 ? 可选
-- . 任意字符（除换行）

10.2 math 库

 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

10.3 os 库

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") -- 执行系统命令（注意安全）

10.4 io 库与文件读写

 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

游戏项目中文件 IO 常被沙盒限制，更多使用宿主提供的 IO 接口；读写配置文件时注意处理 io.open 返回 nil + 错误信息 的情况。

十一、面向对象

Lua 没有 class 关键字，但可以用表 + 元表实现类和对象。核心是 __index 实现方法和属性的继承。

11.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 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)

11.2 继承

 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() -- 旺财 发出了声音 / 品种：柴犬

11.3 封装（私有成员）

用闭包把变量藏在局部作用域中，实现真正的私有。

 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（外部访问不到）

十二、Lua 与 C / Unity

12.1 C 与 Lua 的交互

Lua 作为嵌入式语言，依赖 C API 与宿主通信，数据通过一个虚拟栈交换。

 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);

12.2 Unity 中的 Lua（xLua / ToLua）

Unity 游戏常用 xLua 或 ToLua 实现热更新：C# 侧提供接口，Lua 侧编写业务逻辑。

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();

为什么游戏用 Lua 热更新：

逻辑改动无需重新编译 IL2CPP/C++，替换 .lua 文本即可
分包体积小，适合在线更新
脚本语言开发迭代快

注意：Lua 与 C# 之间跨语言调用有开销，高频逻辑（如每帧 Update）应尽量写在 C# 侧，Lua 只处理易变的业务逻辑。

十三、常见陷阱与最佳实践

 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. 深拷贝要递归，简单赋值只拷贝引用

最佳实践汇总：

一律用 local，减少全局污染
用 pcall 隔离不可信代码（如玩家脚本、热更脚本）
大表复用，避免频繁创建造成 GC 压力
用 table.concat 拼接大量字符串
模块返回一个表，私有函数放在 local 中
性能敏感处避免元表 __index 的深层链式查找

十四、高频面试问答

14.1 Lua 的数据类型有哪些？

8 种：nil、boolean、number、string、table、function、userdata、thread。其中 table 是唯一的数据结构，userdata 用于表示 C 侧对象，thread 表示协程。

14.2 为什么 Lua 数组下标从 1 开始？

历史与设计选择：更贴近数学和人类习惯（第一个元素是"第 1 个"），也便于用 # 表示长度、用 1..#t 遍历。代价是从 C 系语言转过来需要适应。

14.3 `ipairs` 和 `pairs` 的区别？

	ipairs	pairs
遍历范围	数组部分（连续整数键）	所有键值对
顺序	从 1 开始递增，遇 nil 停止	无序
底层	`__index`（5.1）/ 专用迭代器	`next`
场景	遍历列表	遍历字典

14.4 `index` 和 `newindex` 的作用？

__index：访问不存在的键时触发，可用于默认值、继承、代理
__newindex：对不存在的键赋值时触发，可用于只读表、数据同步、拦截写入
二者都可以是表或函数，是 Lua 面向对象和元编程的核心

14.5 如何实现面向对象？

用表表示对象，用 __index 让实例查找到类的方法，用 setmetatable 建立类与父类的继承链。构造函数（new）中 setmetatable(self, Class)，方法用 : 定义以隐式接收 self。

14.6 闭包是什么？有什么用？

闭包是函数加上它捕获的外部局部变量。用途：状态保持（计数器）、数据私有化（封装）、回调、迭代器、函数工厂。闭包捕获的是变量的引用而非拷贝。

14.7 协程和线程的区别？

协程是协作式的用户态并发，切换由程序显式 yield 控制，无抢占、无系统调度开销；线程是抢占式的系统级并发，可并行但需处理锁与竞态。Lua 协程本质是单线程内的控制流切换，适合状态机和异步流程。

14.8 pcall 和 xpcall 的区别？

都用于保护性调用并捕获错误。pcall 只返回成功标志与结果/错误信息；xpcall 额外接收一个错误处理函数，可以在其中调用 debug.traceback 获取堆栈，便于调试。

14.9 如何判断表中是否有某个键？

注意 t[k] ~= nil 会把值为 false 的情况也漏掉。正确做法是 t[k] == nil 判断不存在，或 5.2+ 用 rawget(t, k) ~= nil（绕过元表）。若确实可能存在 false 值，需用 next 或额外记录键集合。

14.10 Lua 的 GC 机制？

Lua 使用**增量式标记清除（mark-and-sweep）**垃圾回收器（5.4 引入分代模式）。GC 从根（全局表、栈、注册表）出发标记可达对象，未被标记的回收。可通过 collectgarbage() 手动控制，collectgarbage("count") 查看内存占用。

14.11 `rawget` / `rawset` 有什么用？

绕过元表的 __index / __newindex 直接读写表。用于实现元表逻辑时避免递归调用自身，或访问"真实"数据。

14.12 深拷贝和浅拷贝的区别？

浅拷贝只复制第一层引用（表还指向同一张子表），深拷贝递归复制所有层级。Lua 赋值运算符 = 永远是引用赋值，需要拷贝时必须手写递归函数。

本文系统梳理了 Lua 从基础语法到元表、协程、面向对象及工程实践的核心内容，适合零基础入门与游戏开发方向快速查阅。示例以 Lua 5.4 为准，涉及 5.1/LuaJIT 差异处已单独标注。

Lua on 水元素长弓