Lua: 表机制深度解析之数组字典实现与迭代器应用

最新推荐文章于 2025-12-28 15:11:34 发布

原创最新推荐文章于 2025-12-28 15:11:34 发布 · 1.1k 阅读

35 ·

CC 4.0 BY-SA版权

文章标签：

#lua #开发语言

Lua 专栏收录该内容

12 篇文章

订阅专栏

深入 Lua 表：从数据结构到高性能实践

表（Table）是 Lua 唯一的数据结构，其巧妙设计实现了数组、字典、对象等复杂功能
本文将结合底层原理与实战案例，解析其高级用法

数组与字典的实现机制

1 ) 基础实现：混合存储结构

Lua 表采用双段存储：
数组段：连续整数索引（1~n）存储，时间复杂度 O(1)
哈希段：非整数索引（如字符串）通过哈希表存储，平均复杂度 O(1)

--- 混合初始化
local tbl = {
    [1] = "apple",  -- 存入数组段
    name = "fruit",  -- 存入哈希段
    [2] = "banana",
    color = "yellow"
}

2 ) 元表扩展：实现 OOP

通过元表模拟类与继承：

local Animal = {}
function Animal:new(name)
    local obj = { name = name }
    setmetatable(obj, { index = Animal })  -- 继承元表 
    return obj
end 
function Animal:sound() print("...") end
 
local Cat = Animal:new("Kitty")
Cat:sound()  -- 输出 "..."

关键点：index 元方法实现属性查找链（类似原型链）

3 ) 性能陷阱：稀疏数组处理

避免在数组段中间插入 nil：

local arr = {"a", "b", "c"}
arr[2] = nil  -- 破坏数组段连续性！
print(#arr)   -- 输出 1（实际应为 3）

解决方案：用 table.remove() 删除元素或使用迭代器跳过 nil

迭代器：pairs 与 ipairs 的区别与应用

在 Lua 中遍历表，主要使用 pairs 和 ipairs 两种内置迭代器，它们的行为有显著差异
pairs(t)：遍历表中所有键值对，顺序不固定（基于哈希表）。适用于字典或非连续整数索引的数组
ipairs(t)：按顺序遍历连续整数索引（从1开始递增）的表元素，一旦遇到 nil（空洞），遍历会立即停止

local mixed_table = {10, 20, nil, 40, key="value", [100]="hundred"}
 
print("使用 pairs 遍历:")
for k, v in pairs(mixed_table) do 
    print(k, v)
end 
--- 输出: 可能是 1 10, 2 20, 4 40, key value, 100 hundred (顺序不定)
 
print("\n使用 ipairs 遍历:")
for i, v in ipairs(mixed_table) do 
    print(i, v)
end 
--- 输出: 1 10, 2 20 (遇到 nil 停止，不会输出 4 40 或其他键值对)

迭代器深度解析：pairs vs ipairs

1 ) 底层原理对比

迭代器	适用场景	遍历范围	输出特性	实现机制
ipairs	纯整数连续索引的数组	从索引1开始到第一个nil终止	严格按整数索引升序输出	依赖 index 元方法
pairs	混合类型键的表（数组+字典）	遍历所有非nil键	输出顺序由哈希表内部结构决定，无固定规律	调用 next(tbl, key)

local tbl = { "a", [3]="c", [2]="b", key="value" }

--- ipairs 只遍历连续整数部分 
for i, v in ipairs(tbl) do  -- 仅输出 1:"a"
    print(i, v)
end

--- pairs 遍历所有键值 
for k, v in pairs(tbl) do   -- 输出 1:"a", 2:"b", 3:"c", key:"value"
    print(k, v)
end

再来看一个示例

--- ipairs遍历遇到nil时停止 
local arr = {10, 20, nil, 30} 
print("ipairs遍历结果:") 
for i, v in ipairs(arr) do 
    print(i, v) 
end 

--- pairs遍历所有非nil键 
local mixed_table = {id=100, "Lua", version="5.4"} 
print("\npairs遍历结果:") 
for k, v in pairs(mixed_table) do 
    print(k, v) 
end

2 ) 自定义迭代器：行列转换器

实现矩阵转置迭代器：

function matrix_iter(matrix)
    local row, col = 0, 0
    return function()
        col = col + 1
        if col > #matrix[row] then
            row, col = row + 1, 1
        end
        return row <= #matrix and {row, col, matrix[row][col]}
    end 
end
--- 使用示例
local grid = {{1,2}, {3,4}}
for pos in matrix_iter(grid) do 
    print(pos[1], pos[2], pos[3])  -- 输出 (1,1,1), (1,2,2), (2,1,3)...
end

数组与字典的实战实现

数组和字典是Lua表最常用的两种形态，核心差异在于索引类型和使用场景：

类型	核心特点	代码示例
数组	默认以连续整数为索引（起始值1）、动态扩容	fruits = {“apple”, “banana”, “cherry”} print(fruits1]) 运行输出：apple
字典（哈希表）	支持任意非nil类型作为键、键值对无固定顺序	user = {name = “Alice”, age = 25} print(user.age) 运行输出：25

数组允许自定义起始索引，但推荐遵循Lua默认规范从1开始，可减少遍历和长度计算问题；字典使用字符串作为键时可以通过.语法快速访问，等价于table[“key”]的写法。

表操作库 (table library) 实践案例

Lua 提供了 table 库，包含一系列用于操作表的函数，如

table.insert, table.remove, table.concat, table.sort 等

1 ) 实践案例 1: 数组操作

local arr = {1, 2, 3}
--- 在末尾插入
table.insert(arr, 4) -- arr 变为 {1, 2, 3, 4}
--- 在指定位置插入
table.insert(arr, 2, "new") -- arr 变为 {1, "new", 2, 3, 4}
--- 删除末尾元素 
local removed = table.remove(arr) -- removed = 4, arr = {1, "new", 2, 3}
--- 删除指定位置元素
table.remove(arr, 2) -- arr 变为 {1, 2, 3}

2 ) 实践案例 2: 字符串连接

local parts = {"Hello", " ", "Lua", "!"}
local sentence = table.concat(parts) -- "Hello Lua!"
local with_sep = table.concat(parts, "-") -- "Hello- -Lua-!"

3 ) 实践案例 3: 排序

local nums = {5, 2, 8, 1}
table.sort(nums) -- nums 变为 {1, 2, 5, 8}
--- 自定义比较函数
local words = {"banana", "apple", "Pear"}
table.sort(words, function(a, b) return a:lower() < b:lower() end) -- 按小写排序: Pear, apple, banana

表操作库实战：性能优化案例

1 ) 数据清洗：高效过滤空值

local data = {"a", nil, "b", nil, "c"}
--- 传统方式：多次移动元素 
table.remove(data, 2)  -- 低效！
--- 高效方案：单次遍历+concat
local clean = {}
for _, v in ipairs(data) do
    if v ~= nil then
        clean[#clean+1] = v
    end
end 
--- 或使用 table.concat 快速拼接

2 ) 多级排序：灵活比较器

local users = {
    {name="Bob", age=25},
    {name="Alice", age=30},
    {name="Alice", age=25}
}

table.sort(users, function(a, b)
    if a.name == b.name then
        return a.age < b.age  -- 同名按年龄升序
    end
    return a.name < b.name    -- 按名字字典序
end)

3 ) LRU 缓存：哈希表+双向链表

local LRU = {}
function LRU:new(capacity)
    local obj = {
        map = {},          -- 快速查找
        list = {},         -- 维护顺序
        cap = capacity 
    }
    setmetatable(obj, { index = LRU })
    return obj
end 
 
function LRU:get(key)
    if not self.map[key] then return nil end
--- 移动节点到链表头部
    table.remove(self.list, self.map[key].pos)
    table.insert(self.list, 1, key)
    return self.map[key].val
end

性能关键：哈希段扩容时触发 rehash（阈值 50%），预分配大小可优化

常用表操作库实践

Lua提供内置table库处理常见表操作，以下是高频函数的实战案例：

1 ) table.concat：拼接表内字符串，可自定义分隔符

local words = {"Hello", "Lua", "World"} 
print(table.concat(words, " ")) --输出: Hello Lua World

2 ) table.insert/remove：动态增删表元素

table.insert(words, 2, "Beautiful") --在索引2插入新元素 
print(table.concat(words, " ")) --输出: Hello Beautiful Lua World

3 ) table.sort：对表元素进行排序，支持自定义比较规则

local names = {"Charlie", "Alice", "Bob"} 
table.sort(names) 
print(table.concat(names, ", ")) --输出: Alice, Bob, Charlie

综合案例：游戏配置加载器

--- 1. 加载 JSON 配置（模拟）
local config_json = [[ 
{
    "weapons": {
        "sword": { "damage": 100 },
        "bow": { "damage": 80 }
    }
}]]

--- 2. 解析为 Lua 表 + 元表保护 
local config = json.decode(config_json)
setmetatable(config.weapons, {
    index = function(t, k)
        error("Invalid weapon: "..k)  -- 防非法访问
    end 
})
--- 3. 安全读取 + 默认值
local function get_weapon(name)
    return config.weapons[name] or { damage = 50 }
end
--- 4. 热更新配置 
function reloadconfig(newcfg)
    for k, v in pairs(new_cfg.weapons) do
        config.weapons[k] = v  -- 直接覆盖旧配置 
    end 
end

高级技巧

1 ) 稀疏数组优化：

--- 使用哈希段存储非连续索引
local sparse = setmetatable({}, {
    len = function(t)  -- 自定义 # 操作符行为 
        local max = 0 
        for k in pairs(t) do
            if type(k)=="number" and k>max then max=k end
        end
        return max
    end 
})