元编程
1. Lua 的元表机制
1.1 元表的概念
元表（Metatable）是 Lua 中一种特殊的表，用于定义表的自定义行为。通过元表，可以为表添加运算符重载、访问控制等功能。
1.2 设置元表
使用 setmetatable 函数为表设置元表。
local t = {}
local mt = {}
setmetatable(t, mt)
1.3 获取元表
使用 getmetatable 函数获取表的元表。
local mt = getmetatable(t)
1.4 元表的默认行为
元表可以定义表的默认行为，例如访问不存在的键时的处理方式。
local mt = {
__index = function(table, key)
return "Key not found: " .. key
end
}
setmetatable(t, mt)
print(t["name"]) -- 输出: Key not found: name
2. 使用元方法实现自定义行为
2.1 元方法的概念
元方法是元表中的特殊键，用于定义表的自定义行为。常见的元方法包括：
| 元方法 | 描述 |
|---|---|
__index | 定义表的索引访问行为。 |
__newindex | 定义表的新键赋值行为。 |
__add | 定义表的加法操作。 |
__sub | 定义表的减法操作。 |
__mul | 定义表的乘法操作。 |
__div | 定义表的除法操作。 |
__tostring | 定义表的字符串表示。 |
__call | 定义表的调用行为。 |
__len | 定义表的长度操作。 |
2.2 __index 元方法
__index 用于定义表的索引访问行为。当访问表中不存在的键时，会调用 __index 元方法。
local mt = {
__index = function(table, key)
return "Key not found: " .. key
end
}
setmetatable(t, mt)
print(t["name"]) -- 输出: Key not found: name
2.3 __newindex 元方法
__newindex 用于定义表的新键赋值行为。当向表中赋值一个不存在的键时，会调用 __newindex 元方法。
local mt = {
__newindex = function(table, key, value)
print("Assigning " .. key .. " = " .. value)
end
}
setmetatable(t, mt)
t["name"] = "Lua" -- 输出: Assigning name = Lua
2.4 __add 元方法
__add 用于定义表的加法操作。
local t1 = {value = 10}
local t2 = {value = 20}
local mt = {
__add = function(a, b)
return {value = a.value + b.value}
end
}
setmetatable(t1, mt)
setmetatable(t2, mt)
local t3 = t1 + t2
print(t3.value) -- 输出: 30
2.5 __tostring 元方法
__tostring 用于定义表的字符串表示。
local t = {name = "Lua", version = "5.4"}
local mt = {
__tostring = function(table)
return table.name .. " " .. table.version
end
}
setmetatable(t, mt)
print(t) -- 输出: Lua 5.4
2.6 __call 元方法
__call 用于定义表的调用行为。
local t = {}
local mt = {
__call = function(table, arg)
print("Called with:", arg)
end
}
setmetatable(t, mt)
t("Hello") -- 输出: Called with: Hello
2.7 __len 元方法
__len 用于定义表的长度操作。
local t = {1, 2, 3}
local mt = {
__len = function(table)
return #table + 1
end
}
setmetatable(t, mt)
print(#t) -- 输出: 4
3. 元表的实际应用
3.1 实现只读表
下面是对普通赋值设限的浅层代理，不是安全沙箱或不可变快照：rawset 可绕过，原表别名及嵌套表也仍可改。示例不透传 pairs 或 #；ipairs 的数字索引可以经过 __index。
local function readOnly(table)
local mt = {
__index = table,
__metatable = "read-only proxy",
__newindex = function(table, key, value)
error("Attempt to modify read-only table")
end
}
return setmetatable({}, mt)
end
local t = readOnly({name = "Lua"})
print(t.name) -- 输出: Lua
local ok, err = pcall(function() t.name = "Python" end)
assert(not ok and tostring(err):find("Attempt to modify read-only table", 1, true))
3.2 实现默认值表
通过 __index 元方法，可以实现默认值表。
local function defaultTable(default)
local mt = {
__index = function(table, key)
return default
end
}
return setmetatable({}, mt)
end
local t = defaultTable(0)
print(t["name"]) -- 输出: 0
3.3 实现面向对象编程
通过元表，可以实现简单的面向对象编程。
local Object = {}
function Object:new(o)
o = o or {}
setmetatable(o, self)
self.__index = self
return o
end
local Person = Object:new()
function Person:greet()
print("Hello, my name is " .. self.name)
end
local p = Person:new({name = "Alice"})
p:greet() -- 输出: Hello, my name is Alice
4. __gc 与弱引用表
PUC Lua 5.4/5.5 支持为表登记 __gc，但不可达不等于立刻执行；它不保证进程崩溃时清理外部资源。下面用计数器展示受控收集，不引用未定义的 file_handle：
local finalized = 0
local function makeTracked()
return setmetatable({}, { __gc = function() finalized = finalized + 1 end })
end
local tracked = makeTracked()
tracked = nil
collectgarbage("collect")
collectgarbage("collect")
assert(finalized == 1)
需要及时关闭文件时，Lua 5.4/5.5 可用显式 close 或作用域关闭。这个标准库例子真实创建临时文件，离开作用域后即关闭，和等待 GC 是不同契约：
local retained
local ok = pcall(function()
local handle <close> = assert(io.tmpfile())
retained = handle
handle:write("example")
error("simulated operation failure")
end)
assert(ok == false and io.type(retained) == "closed file")
弱引用表：让缓存等持有者不以强引用阻止对象回收。循环引用本身不是泄漏原因；不可达的环也能回收。弱引用不是自动解除所有外部资源或强引用的机制。
-- 弱引用键（key 是弱引用）
local weak_key = setmetatable({}, { __mode = "k" })
-- 弱引用值（value 是弱引用）
local weak_val = setmetatable({}, { __mode = "v" })
-- 两者皆弱
local weak_both = setmetatable({}, { __mode = "kv" })
-- 用途：弱值缓存不以值引用延长对象寿命；别处或键仍强引用它时仍会保留
local cache = setmetatable({}, { __mode = "v" })
function getObject(id)
if cache[id] then
return cache[id]
end
local obj = createExpensiveObject(id) -- 由调用方提供构造器，此处只展示缓存骨架
cache[id] = obj
return obj
end
5. 性能考量
| 操作 | 要核对的成本来源 | 使用边界 |
|---|---|---|
| 无元表访问 | 直接取值路径 | 先测真实热点再优化 |
__index 为函数 | 缺失键触发函数调用及其函数体 | 成本取决于实际逻辑 |
__index 为表 | 后备表及可能的后续元表查找 | 原型链也需要控制深度 |
__newindex | 当前键缺失时的赋值处理 | 不会拦截所有原表已有键的普通写入 |
| 运算符元方法 | 操作分派与用户函数 | 不在没有基准时承诺开销极小 |
6. 常见陷阱
陷阱 1：无限递归
local mt = {
__index = function(t, k)
return t[k] -- 错误！又会触发 __index
end
}
-- 正确写法：使用 rawget
local mt = {
__index = function(t, k)
return rawget(t, k) or "default"
end
}
陷阱 2：__pairs 与 ipairs 的混淆
-- Lua 5.4/5.5：ipairs 用连续数字索引取值，并可经过 __index
local t = setmetatable({}, {
__index = {10, 20, 30}
})
for i, v in ipairs(t) do
print(v) -- 通过 __index 输出 10, 20, 30，索引4得到nil才停止
end
若后备函数对任意数字键都返回非 nil，ipairs 就没有自然结束点；不能把这种默认值表直接当有限序列遍历。
陷阱 3：全局表意外触发元方法
-- 禁止在全局表上使用复杂的 __newindex
-- 可能导致标准库被意外拦截
7. 元表与 LuaJIT 优化
LuaJIT 对元表有专门的 JIT 编译优化，但以下模式会降低性能：
| 反模式 | 影响 |
|---|---|
| 频繁修改元表 | JIT 无法稳定跟踪类型 |
__index 返回不同类型的值 | 类型不稳定，退化为解释执行 |
__newindex 做复杂逻辑 | 写操作变重，影响所有赋值 |
| 深度嵌套元表链 | 每次访问多层级查找 |
最佳实践：在游戏热路径（每帧调用）中，尽量避免元方法调用，使用直接表访问。
4. 总结
元表是 Lua 中一种强大的元编程工具，通过元表和元方法，可以为表添加自定义行为，实现运算符重载、访问控制、面向对象编程等功能。掌握元表的使用方法，可以帮助开发者编写更加灵活和高效的 Lua 程序。
元表的使用层次：
- 基础：
__index默认值 /__newindex拦截 - 进阶：运算符重载 + 面向对象原型链
- 高级：弱引用表 + 自定义迭代器 + 垃圾回收钩子
- 性能：理解 LuaJIT 优化边界，热路径去元表化
弱缓存、循环与代理边界回归
local weak = setmetatable({}, { __mode = "v" })
local strong = {}
local function seed()
local cycle = {}
cycle.self = cycle
weak[1], strong[1] = cycle, cycle
end
seed()
collectgarbage("collect")
assert(weak[1] ~= nil) -- 还有强引用，不能因使用弱缓存就宣称已回收
strong[1] = nil
collectgarbage("collect")
collectgarbage("collect")
assert(weak[1] == nil) -- 已不可达的环能被回收
练习：将只读代理套在带嵌套表的数据上，检查普通赋值、setmetatable、rawset、原表别名和嵌套写入。验收：前两者被拒绝；后三者说明浅层代理并不是不可变/安全边界。GC例子仅在所列PUC解释器验证，不外推LuaJIT或游戏引擎宿主。参考：Lua元表与垃圾收集语义 。
继续阅读
探索更多技术文章
浏览归档，发现更多关于系统设计、工具链和工程实践的内容。