表的定义与使用实践
我们可以通过构造器快速创建三种类型的表,对应不同的使用场景:
| 类型 | 定义语法示例 | 索引规则 | 使用场景 |
|---|---|---|---|
| 数组型表 | fruits = {"apple", "banana", "orange"} | 默认从1开始连续数值索引 | 存储有序列表、批量数据遍历 |
| 字典型表 | person = {name="Bob", age=30, city="Shanghai"} | 支持任意非nil类型作为键 | 存储结构化数据、配置项映射 |
| 混合型表 | mixed = {10, "hello", x = 1, y = 2} | 同时包含数值索引与自定义键 | 灵活存储多类型数据集合 |
你可以通过索引快速访问表元素,数组型表以数字索引访问,字典型表支持点语法调用键值对
当表对象没有其他引用指向时,Lua垃圾回收机制将自动释放其占用内存
表(Table)的核心机制与应用
1 ) 表的定义与使用
Lua 中的表是唯一的复合数据类型,可以当作数组、字典、对象等多种数据结构使用。
表的构造非常灵活,支持多种初始化方式:
--- 创建空表
local mytable = {}
--- 作为数组使用(索引从1开始)
local fruits = {"apple", "banana", "orange"}
--- 作为字典使用
local person = {name = "Alice", age = 25, city = "Shanghai"}
--- 混合使用
local mixed = {10, "hello", x = 1, y = 2}
print(table.concat(mixed, ", ")) -- 10, hello 其他不会输出
表不仅可以使用数值作为索引,还可以使用字符串或其他任意类型的值作为索引(除了nil)
这种灵活性使得Lua表可以实现复杂的数据结构和对象模型
2 ) 表的本质与数据结构
唯一数据结构:Lua 中表是唯一的数据结构,可模拟数组、字典、对象等
动态混合类型:支持数字索引(数组)和任意类型键值对(字典),索引默认从 1 开始
--- 混合表示例
local mixed = {
"apple",
color = "red",
[3] = true,
price = 2.5
}
print(mixed[1], mixed["color"], mixed[2], mixed[3]) -- apple red nil true
3 ) 表的遍历方式对比
在Lua中,遍历表有多种方式,最常用的是 pairs 和 ipairs,它们有显著区别:
| 遍历方式 | 遍历范围 | 遍历顺序 | 适用场景 |
|---|---|---|---|
pairs | 所有键值对 | 哈希表顺序(非定义顺序) | 遍历完整表(字典型数据) |
ipairs | 数组部分(从索引1开始连续) | 按数字索引顺序 | 遍历连续数组 |
--- 示例:不同遍历方式的差异
local tbtest = {a = "a", [1] = 1, b="b", [2]=2, [4] = 4}
--- pairs遍历:遍历所有键值对
for key, value in pairs(tbtest) do
print(key, value)
end
print('\n')
--- ipairs遍历:只遍历数组部分,遇到不连续索引中断
for key, value in ipairs(tbtest) do
print(key, value)
end
--[[
1 1
2 2
a a
4 4
b b
1 1
2 2
]]
pairs 会遍历表中的所有键值对,按照哈希表的内部顺序,而不是键值对的定义顺序
ipairs 只遍历从索引1开始的连续数组部分,一旦遇到索引不连续(如缺少索引3),就会停止遍历
4 ) 表操作的性能陷阱与优化
长度操作符 # 的局限:仅统计连续数字索引部分,中断则提前终止
local tbl = {1, 2, nil, 4}
print(#tbl) -- 输出 2(因索引 3 为 nil 中断) 或 4 因Lua版本不同
- Lua 5.1:严格依赖连续整数索引序列,遇到第一个 nil 即终止计数, 输出2
- Lua 5.2+:优化为二分查找最大有效索引,可能返回更大值,输出4
安全删除元素:避免 table.remove 导致索引重排,推荐置为 nil 并记录逻辑长度
遍历机制深度解析
1 )以下是三种高频遍历方法的核心差异:
| 遍历方式 | 适用场景 | 遍历逻辑 | 局限性 |
|---|---|---|---|
ipairs | 连续数值索引的数组型表 | 从索引1开始遍历,遇非连续索引直接终止 | 无法遍历自定义键、非连续数值索引值 |
pairs | 所有类型表(混合/字典/数组) | 按哈希值顺序遍历所有非nil键值对,无索引限制 | 遍历顺序与定义顺序无关 |
for i=1,#table | 连续数值索引的数组型表 | 按数值索引从1到表长度遍历,依赖#运算符获取长度 | 非连续索引会出现nil值、无法遍历自定义键 |
2 ) ipairs vs pairs 的底层差异
| 方法 | 遍历范围 | 顺序性 | 适用场景 |
|---|---|---|---|
ipairs | 连续数字索引(1→N) | 严格有序 | 数组类数据 |
pairs | 所有键值对 | 哈希无序 | 字典或非连续索引表 |
local tbl = {{a=1, b=2, [1]="x", [3]="z"}} -- 外层是数组,内层是混合表
-- 使用 ipairs 遍历外层数组(内层表视为数组部分)
print("ipairs 遍历输出:")
for i, v in ipairs(tbl) do
-- 此时 v 是内层表,但 ipairs 只遍历外层数组的连续数字索引(这里只有索引1)
print(i, v) -- 输出外层索引和对应的内层表
-- 若想遍历内层表的数组部分,需在内层再次使用 ipairs
print("内层表数组部分:")
for j, val in ipairs(v) do
print(j, val) -- 内层 ipairs 遍历:从索引1开始,遇到索引2缺失则停止
end
end
-- 使用 pairs 遍历外层数组(实际是遍历外层表的所有键值对)
print("\npairs 遍历输出:")
for k, v in pairs(tbl) do
-- 外层表是数组,但 pairs 会输出所有键(包括数字索引和可能的其他键,但此处外层只有数字索引)
print(k, v) -- 输出外层键值对(如 1: {内层表})
-- 遍历内层表的所有键值对
if type(v) == "table" then
print("内层表所有键值对:")
for key, value in pairs(v) do
print(key, value) -- 内层 pairs 输出:a=1, b=2, 1="x", 3="z"(顺序不定)
end
end
end
--[[
ipairs 遍历输出:
1 table: 0x6000032f0840
内层表数组部分:
1 x
pairs 遍历输出:
1 table: 0x6000032f0840
内层表所有键值对:
a 1
1 x
3 z
b 2
]]
3 ) lfs 库实现文件系统遍历
-- 需要安装依赖 sudo luarocks install luafilesystem
local lfs = require "lfs"
for file in lfs.dir(".") do
if lfs.attributes(file, "mode") == "file" then
print("文件: "..file)
end
end
完整示例
local lfs = require("lfs")
-- 获取系统路径分隔符
local sep = package.config:sub(1,1)
local function walk(path)
local ok, iter, dir_obj = pcall(lfs.dir, path)
if not ok then
print("× 目录访问失败: "..path.." | 错误: "..iter)
return
end
for file in iter, dir_obj do
if file ~= "." and file ~= ".." then
local full = path .. sep .. file
local mode, err = lfs.attributes(full, "mode")
if not mode then
print("! 属性获取失败: "..full.." | 错误: "..(err or "未知"))
elseif mode == "directory" then
print("↓ 进入目录: "..full)
walk(full)
print('↑当前目录遍历完成')
elseif mode == "file" then
-- 按扩展名分类显示
local ext = file:match("^.+(%..+)$") or "无扩展名"
print("■ 文件: "..full.." | 类型: "..ext)
end
end
end
end
walk(".")
元表与元方法
元表可以自定义表在特定操作下的行为
通过 __index 和 __newindex 元方法可以实现继承与属性拦截两大核心功能:
1 ) 继承实现
通过将父表设置为子表的 __index 元方法,可以让子表自动继承父表的属性与方法
--- 定义父表
local base = {
version = 1.0,
getVersion = function(self) -- 关键修复:添加self参数
return self.version -- 关键修复:通过self动态访问
end
}
--- 定义子表
local sub = { name = "subTable" }
--- 设置元表实现继承
setmetatable(sub, { __index = base })
--- 正确调用方式(两种可选):
print(sub.getVersion(sub)) -- 显式传递self
-- 或使用冒号语法(推荐)
print(sub:getVersion()) -- 自动传递self
--[[
1.0
1.0
]]
2 ) 属性拦截
通过__newindex元方法可以拦截对表未定义键的赋值操作,实现只读表
function newConst(const_table)
local mt = {
__index = function(t, k)
return const_table[k]
end,
__newindex = function(t, k, v)
print("无法修改常量:"..tostring(k))
end
}
local t = {}
setmetatable(t, mt)
return t
end
local const = newConst({a=1,b=2})
const.a = 3 -- 输出"无法修改常量:a"
元表(Metatable)的进阶应用
1 ) 实现面向对象继承
通过 __index 实现原型链查找:
local Animal = { sound = "Generic" }
function Animal:new(o)
o = o or {}
setmetatable(o, { __index = self })
return o
end
local Cat = Animal:new({ sound = "Meow" })
local kitty = Cat:new()
print(kitty.sound) -- 输出: Meow(继承自 Cat)
__index 元方法在访问表中不存在的字段时被调用,可用于实现继承或默认值:
--- 实现继承示例
local Animal = {name = "default", sound = "unknown"}
Animal.__index = Animal -- 设置自身为元表
local Dog = {breed = "Golden Retriever"}
setmetatable(Dog, Animal) -- Dog继承Animal
print(Dog.name) -- "default" (从Animal继承)
print(Dog.sound) -- "unknown" (从Animal继承)
print(Dog.breed) -- "Golden Retriever" (自身属性)
--[[
default
unknown
Golden Retriever
]]
2 ) 属性拦截与只读表
使用 __newindex 阻止写入:
local function createReadOnlyTable(t)
local proxy = {}
setmetatable(proxy, {
__index = t,
__newindex = function(_, k, v)
error("禁止修改只读表字段: "..k)
end
})
return proxy
end
local config = createReadOnlyTable({ version = 1.0 })
config.version = 2.0 -- 抛出错误
--[[
lua: 912.lua:6: 禁止修改只读表字段: version
stack traceback:
[C]: in function 'error'
912.lua:6: in metamethod 'newindex'
912.lua:13: in main chunk
[C]: in ?
]]
__newindex 元方法在给表中不存在的字段赋值时被调用,可用于实现属性拦截:
--- 实现只读表
local function newConst(const_table)
local mt = {
__index = function(t, k)
return const_table[k]
end,
__newindex = function(t, k, v)
error("Cannot modify constant table: " .. tostring(k) .. " = " .. tostring(v))
end
}
local t = {}
setmetatable(t, mt)
return t
end
local readonly = newConst({x = 10, y = 20})
readonly.z = 30 -- 这会触发错误
--[[
lua: 913.lua:8: Cannot modify constant table: z = 30
stack traceback:
[C]: in function 'error'
913.lua:8: in metamethod 'newindex'
913.lua:17: in main chunk
[C]: in ?
]]
算术元方法应用
元表还支持算术运算符的重载,如 __add、__sub、__mul 等:
--- 集合运算示例
Set = {}
local metatable = {}
function Set.new(l)
local set = {}
setmetatable(set, metatable)
for _, v in ipairs(l) do
set[v] = true
end
return set
end
function Set.union(a, b)
local res = Set.new{}
for k in pairs(a) do res[k] = true end
for k in pairs(b) do res[k] = true end
return res
end
function Set.intersection(a, b)
local res = Set.new{}
for k in pairs(a) do
res[k] = b[k]
end
return res
end
--- 设置元方法
metatable.__add = Set.union
metatable.__mul = Set.intersection
--- 使用
local s1 = Set.new{10, 20, 30}
local s2 = Set.new{30, 40, 50}
local s3 = s1 + s2 -- 等同于 Set.union(s1, s2)
local s4 = s1 * s2 -- 等同于 Set.intersection(s1, s2)
local function printSet(name, s)
print(name .. ":")
for k, v in pairs(s) do
print(" " .. tostring(k) .. " = " .. tostring(v))
end
end
printSet("s1", s1)
printSet("s2", s2)
printSet("s3", s3)
printSet("s4", s4)
--[[
s1:
30 = true
10 = true
20 = true
s2:
30 = true
40 = true
50 = true
s3:
50 = true
30 = true
10 = true
40 = true
20 = true
s4:
30 = true
]]
元方法的高阶实践
1 ) 运算符重载:集合运算
实现表元素的并集(__add)与交集(__mul):
-- 创建元表(先定义元表)
local mt = {}
-- 修复的集合实现
local Set = {}
function Set.new(t)
local set = {}
setmetatable(set, mt) -- 关键修复:绑定元表
for _, v in ipairs(t) do
set[v] = true
end
return set
end
-- 元方法定义
mt.__add = function(a, b) -- 并集
local res = Set.new({})
for k in pairs(a) do res[k] = true end
for k in pairs(b) do res[k] = true end
return res
end
mt.__mul = function(a, b) -- 交集
local res = Set.new({})
for k in pairs(a) do
if b[k] then res[k] = true end
end
return res
end
mt.__tostring = function(set) -- 自定义输出
local list = {}
for k in pairs(set) do
table.insert(list, tostring(k)) -- 确保元素可转换为字符串
end
table.sort(list) -- 排序保证输出一致性
return "{" .. table.concat(list, ", ") .. "}"
end
-- 使Set可调用(Set() 语法糖)
setmetatable(Set, {
__call = function(_, t)
return Set.new(t)
end
})
-- 测试案例
local s1 = Set({1, 2})
local s2 = Set({2, 3})
local s3 = s1 + s2 -- 并集
local s4 = s1 * s2 -- 交集
print("s1: " .. tostring(s1)) --> {1, 2}
print("s2: " .. tostring(s2)) --> {2, 3}
print("s3 (并集): " .. tostring(s3)) --> {1, 2, 3}
print("s4 (交集): " .. tostring(s4)) --> {2}
--[[
s1: {1, 2}
s2: {2, 3}
s3 (并集): {1, 2, 3}
s4 (交集): {2}
]]
2 ) 深度拷贝的环处理
递归拷贝并解决自引用问题:
function deepCopy(obj, seen)
seen = seen or {}
if seen[obj] then return seen[obj] end
if type(obj) ~= "table" then return obj end
local copy = {}
seen[obj] = copy
for k, v in pairs(obj) do
copy[deepCopy(k, seen)] = deepCopy(v, seen)
end
return setmetatable(copy, getmetatable(obj))
end
local tbl = {a=1}
tbl.self = tbl -- 自引用
local copy = deepCopy(tbl) -- 无栈溢出
-- 验证拷贝结果
print("原始表地址: ", tostring(tbl)) --> table: 0x7f8a6bc04080
print("拷贝表地址: ", tostring(copy)) --> table: 0x7f8a6bc04300 (新地址)
print("原始表.a = ", tbl.a) --> 1
print("拷贝表.a = ", copy.a) --> 1 (值相同)
print("原始表自引用: ", tbl.self == tbl) --> true
print("拷贝表自引用: ", copy.self == copy) --> true (自引用指向自身)
print("跨表引用对比: ", copy.self == tbl) --> false (隔离性验证)
--[[
原始表地址: table: 0x600003f2c680
拷贝表地址: table: 0x600003f2c800
原始表.a = 1
拷贝表.a = 1
原始表自引用: true
拷贝表自引用: true
跨表引用对比: false
]]
表的高级操作
除了基本遍历,Lua还提供了丰富的表操作函数:
table.insert(table, [pos,] value)- 在指定位置插入元素table.remove(table, [pos])- 删除指定位置元素table.sort(table, [comp])- 排序数组部分table.concat(table, [sep, [start, [end]]])- 连接数组元素
简单示例
local arr = {3, 1, 4, 1, 5}
table.sort(arr) -- 结果: {1, 1, 3, 4, 5}
local str = table.concat(arr, ", ")
print(str) -- 1, 1, 3, 4, 5
性能优化关键点
- 避免频繁创建临时表:复用表对象减少 GC 压力
- 弱引用表管理缓存:使用 mode = “v” 允许未引用值被回收
- 预分配数组空间:减少动态扩容开销(如 local arr = {}; for i=1,1000 do arr[i]=0 end)
实战案例:游戏配置系统
模拟《魔兽世界》插件配置
--- 1. 定义配置基类(修复元表和new方法)
local Config = {}
Config.__index = Config -- 设置元方法指向自身
function Config:new(data)
local instance = setmetatable({}, self)
instance.data = data or {}
return instance
end
function Config:get(key)
return self.data[key]
end
--- 2. 创建环境配置实例
local envConfig = Config:new({
apiUrl = "https://api.example.com"
})
--- 3. 创建只读玩家配置(修复元表链)
local playerConfig = setmetatable({}, {
__index = function(_, key) -- 正确继承envConfig
return envConfig:get(key)
end,
__newindex = function()
error("playerConfig is read-only")
end
})
--- 测试输出
print(playerConfig.apiUrl) -- 现在输出: https://api.example.com
实践案例:面向对象模拟
结合表和元表,可以模拟面向对象编程:
--- 简单的类实现
local Person = {}
Person.__index = Person
function Person:new(name, age)
local obj = {name = name, age = age}
setmetatable(obj, self)
return obj
end
function Person:greet()
print("Hello, I'm " .. self.name .. ", " .. self.age .. " years old.")
end
function Person:tostring()
return self.name .. " (" .. self.age .. " years)"
end
--- 使用
local alice = Person:new("Alice", 25)
alice:greet() -- "Hello, I'm Alice, 25 years old."
print(alice:tostring()) -- "Alice (25 years)"
--[[
Hello, I'm Alice, 25 years old.
Alice (25 years)
]]
或参考如下
--- 简单的类实现
local Person = {}
Person.__index = Person
-- 添加这个 __tostring 的元方法
Person.__tostring = function(self)
return self.name .. " (" .. self.age .. " years)"
end
function Person:new(name, age)
local obj = {name = name, age = age}
setmetatable(obj, self)
return obj
end
function Person:greet()
print("Hello, I'm " .. self.name .. ", " .. self.age .. " years old.")
end
--- 使用
local alice = Person:new("Alice", 25)
alice:greet() -- "Hello, I'm Alice, 25 years old."
print(alice) -- "Alice (25 years)"
--[[
Hello, I'm Alice, 25 years old.
Alice (25 years)
]]
延伸补充与最佳实践
- 表的深拷贝:当需要完全复制独立的表对象时,可以使用递归实现深拷贝,解决浅拷贝导致的引用同步修改问题
- 元表实现运算符重载:通过
__add、__mul等元方法可以为表自定义算术运算规则,比如用表实现集合的并集与交集运算 - RedisLua表应用:在Redis中使用Lua表可以批量执行原子性操作,避免多命令执行期间出现并发冲突
总结
元表事件全集:除 __index/__newindex 外,__call(表当函数用)、__tostring(自定义输出)等扩展性强
LuaJIT 优化:FFI 库直接操作 C 数据结构,提升表访问性能
最佳实践:
- 数组优先用
ipairs,字典用pairs - 元表控制在 2 层以内避免链式查找损耗
- 敏感数据用只读表防护
226



被折叠的 条评论
为什么被折叠?



