你大概率没写过一行 Lua，但你的电脑每天都在跑它：Redis 的原子脚本、Nginx 的 OpenResty 插件、Wireshark 的协议解析、Neovim 的配置、魔兽世界的 UI 框架……这些八竿子打不着的软件，不约而同地选择把 Lua 嵌进去当"内脏语言"。

一门 1993 年诞生、源码只有三万多行、解释器能裁剪到 300KB 以下的小语言，凭什么被嵌入到全世界最流行的软件里？

答案藏在一个反直觉的设计里：Lua 只有一种数据结构——table（表）。数组是它，字典是它，对象是它，模块是它，连"类"都是它。这篇文章就把它拆开讲透：这一张表，到底是怎么撑起一整门语言的。

一、从哪来：为"可嵌入"而生的小语言

Lua 诞生于 1993 年，作者是巴西里约热内卢天主教大学（PUC-Rio）的 Roberto Ierusalimschy、Waldemar Celes 和 Luiz Henrique de Figueiredo。"Lua"在葡萄牙语里是"月亮"的意思——这个名字本身就在致敬它的前身 SOL（葡萄牙语"太阳"），也暗含"小"的定位。

它出生的场景和你熟悉的通用语言完全不同：不是要造一门独立生态的语言，而是给巴西石油公司的数据录入应用做可嵌入脚本。这个出身决定了 Lua 的全部性格：

  • 小：整个解释器用 ANSI C 编写，编译后一两百 KB，任何 C/C++ 程序都能"包一层"把它吞进去。
  • 快：解释器内核极简，再加一个 LuaJIT，数值循环能跑到接近 C 的速度。
  • 嵌入友好：和宿主程序通过一个栈交互，宿主想暴露什么函数就压什么函数。

你可以把 Lua 想成一块"语言的乐高底板"——它自己不长成一栋楼，但它让任何 C/C++ 程序都能迅速在自己身上长出一层可热更新的脚本层。

一个常见误区是"Lua 就是给游戏写脚本的"。游戏只是它最出名的战场之一；它真正的定位是嵌入式脚本语言：宿主程序（Redis、Nginx、游戏引擎）是主角，Lua 是随时可以替换、不用重新编译宿主就能改逻辑的那层"软肉"。

二、table：数组和字典，原来是一回事

在 Python 里，list 和 dict 是两种类型；在 C++ 里，std::vector 和 std::map 是两种容器；在 Lua 里，它们全部是 table。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
-- 1) 当数组用（注意：索引从 1 开始！）
local arr = {"a", "b", "c"}
print(arr[1], arr[2], arr[3])   -- a b c
print(#arr)                     -- 3（# 取序列长度）

-- 2) 当字典用
local cfg = {name = "redis", port = 6379}
print(cfg.name, cfg["port"])    -- redis 6379

-- 3) 混着用也合法：前半截是数组，后半截挂字段
local mixed = {"GET", "SET"}
mixed.timeout = 100             -- 数组部分 + 字段部分并存
print(#mixed, mixed.timeout)    -- 2 100

-- 4) 甚至可以当"对象"：把函数放进表里
local obj = {}
function obj.say(n)
    return "hello, " .. n       -- .. 是字符串拼接
end
print(obj.say("lua"))           -- hello, lua

输出：

1
2
3
4
5
a	b	c
3
redis	6379
2	100
hello, lua

table 内部是怎么做到"一表两用"的？ 这恰恰是 Lua 最精妙的地方——它不是把数组和字典揉在一起，而是一个结构、两段存储：连续的整数键（1、2、3…）放进一段紧凑的数组区，其余键值对放进哈希区。访问 arr[2] 是 O(1) 的数组下标，访问 cfg.name 是 O(1) 的哈希查找，互不干扰，取长补短。

一个 table = 数组区 + 哈希区（Lua 内部结构示意） t = {"GET","SET"} 栈上引用 数组区（array part） [1]="GET" [2]="SET" 紧凑存储 · O(1) 下标 哈希区（hash part） ["timeout"]=100 键值散列 · O(1) 平均 整数键 → 数组区 其他键 → 哈希区

为什么 Lua 敢这么设计？ 因为脚本语言的核心诉求是"怎么方便怎么来"。C++ 程序员要自己权衡"这个数据该用 vector 还是 map"，Lua 程序员永远不用选——先塞进去用，跑慢了再说。这种"不做选择的自由"，正是嵌入式场景最需要的开发效率。

对照记忆：C++ 的 std::vector 和 std::map 是类型层面的二分；Lua 的 table 是存储层面的合一，语法上根本不区分。

三、metatable：给"裸表"装上行为

到这里，table 还只是"数据的容器"。真正让 Lua 从"好用的数据结构"升级成"完整的语言"的，是 metatable（元表）——它是 Lua 最核心、也最容易被误解的机制。

一句话本质：元表是一张"行为表"，它规定了"当别人对这张表做某件事时，该怎么办"。

每张表都可以挂一张元表。访问一个表的字段时，如果表自己找不到，Lua 就会去问它的元表——通过 __index 这个特殊字段。

1
2
3
4
5
6
7
8
-- 元表初体验：让"查不到"的字段有个默认值
local defaults = {unknown = "???"}

local t = {name = "lua"}
setmetatable(t, {__index = defaults})  -- t 挂上元表：查不到就去 defaults 找

print(t.name)       -- lua（自己有的，直接用）
print(t.unknown)    -- ???（自己没有，通过 __index 去 defaults 找）

输出：

1
2
lua
???

__index 有两种形态：表（查不到就去这张表里找）或函数（查不到就调用这个函数）。而 Lua 里著名的"面向对象"，就是靠 __index = 类表 这条链式查找搭出来的——继承本质上就是"查不到就往上找"：

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
-- 用元表模拟"类"：Lua 没有 class 关键字，但不需要
local Animal = {}
Animal.__index = Animal            -- 实例查不到字段时，回 Animal 找

function Animal.new(name)
    local self = setmetatable({}, Animal)  -- 空表 + 元表 = 新实例
    self.name = name
    return self
end

function Animal:speak()            -- 冒号 = 自动注入 self
    return self.name .. " 发出声音"
end

local dog = Animal.new("旺财")
print(dog:speak())                 -- 实例没有 speak，沿 __index 找到 Animal.speak

-- "继承"：子类的元表 __index 指向父类
local Dog = setmetatable({}, {__index = Animal})  -- Dog 查不到 → Animal
Dog.__index = Dog
function Dog:speak()               -- 覆盖父类方法
    return self.name .. " 汪汪叫"
end
local d2 = setmetatable({name = "大黄"}, Dog)
print(d2:speak())                  -- 大黄 汪汪叫（子类方法优先）
print(d2.new)                      -- 子类没有 new → 沿链找到 Animal.new（方法"继承"）

输出：

1
2
3
旺财 发出声音
大黄 汪汪叫
function: 0x...

除了 __index，元表还能挂运算符重载和生命周期钩子：__add（+）、__tostring（print 时自动调用）、__call（让表能像函数一样被调用）、__gc（垃圾回收时触发）……

1
2
3
4
5
6
-- __tostring：让 print 输出"人类可读"的内容
local pt = {x = 3, y = 4}
setmetatable(pt, {
    __tostring = function(p) return "(" .. p.x .. ", " .. p.y .. ")" end
})
print(pt)   -- (3, 4)

输出：

1
(3, 4)

这跟 C++ 的运算符重载、Python 的 __getattr__/__str__ 本质是同一个东西——Lua 只是把所有"魔法方法"统一收进了一张普通的表里。你甚至可以现场给任意表"加魔法"而不需要改类型定义，这在编译型语言里是不可想象的灵活。

四、从一张表里长出的语言特性

table + metatable 只是地基。Lua 那些让新手惊叹的"高级特性"，几乎都是在这两块地基上"长"出来的：

1. 多返回值——不需要包装

1
2
3
4
5
local function divmod(a, b)
    return math.floor(a / b), a % b   -- 一次返回两个值
end
local q, r = divmod(17, 5)
print(q, r)     -- 3 2

输出：

1
3	2

2. 协程——"可暂停的函数"

Lua 的协程是非抢占式的：函数执行到 coroutine.yield() 主动让出，外部用 coroutine.resume() 唤醒。它不需要多线程，不需要锁——因为同一时刻只有一条执行流。

1
2
3
4
5
6
7
8
9
local co = coroutine.create(function()
    for i = 1, 3 do
        print("协程内: ", i)
        coroutine.yield(i)          -- 让出，把 i 传给 resume
    end
end)

print("外部: 第一次 resume 返回", coroutine.resume(co))  -- 协程跑到第一个 yield 停住
print("外部: 第二次 resume 返回", coroutine.resume(co))

输出（注意两条执行流交替打印，这就是"协作"）：

1
2
3
4
协程内: 	1
外部: 第一次 resume 返回	true	1
协程内: 	2
外部: 第二次 resume 返回	true	2

3. 模块——一张被 return 的表

1
2
3
4
5
6
7
8
9
-- mymath.lua（模块文件）
local M = {}          -- 模块就是一张表
function M.add(a, b) return a + b end
function M.mul(a, b) return a * b end
return M              -- require 拿到这张表

-- 使用处
local mymath = require("mymath")
print(mymath.add(2, 3))   -- 5

输出：

1
5

看到规律了吗？数组、字典、对象、类、模块、协程调度……Lua 几乎不发明新概念，而是反复复用"表"这一个概念。这种"用极少的机制表达极多的语义"的克制，是 Lua 源码短小、易于嵌入、行为可预测的根本原因。

五、坑与边界：table 不是银弹

table 的灵活是有代价的。写 Lua 时这几个坑几乎人人踩过：

坑 1：数组从 1 开始。 for i = 0, #arr 会漏掉最后一个元素、多访问一个 nil。这是 Lua 最反直觉的地方，也是从其他语言转过来的第一道坎。语言作者的理由是"和数学下标、和 string.sub 的区间表示保持一致"——但习惯 0-based 的人就是会难受。

坑 2：nil 是"删除"而非"空值"。 给表的字段赋 nil 等于删掉这个键。这带来一个隐蔽的大坑：数组中间不能存 nil——一旦出现"空洞"，# 运算符的结果就变得不确定（它只对"从 1 开始、无空洞"的序列可靠）：

1
2
3
local a = {"x", "y", "z"}
a[2] = nil            -- 删掉中间元素 → 数组出现空洞
print(#a)             -- 可能输出 1 或 3，行为未定义！

输出：

1
3

注意：这里打印 3 只是当前实现恰好如此——规范上 # 对带空洞的数组没有保证。想保留"空洞"必须用占位符（如 false 或自定义的 null 标记），这正是很多 Lua 序列化库要专门处理 null 的原因。

坑 3：变量默认是全局的。 Lua 里不写 local 的变量直接进全局表 _G。文件里忘写一个 local，就可能悄悄污染全局、被其他文件读到——模块化靠的是约定（每个文件最外层 local/return）而非语法强制。Lua 5.2+ 提供了 _ENV 缓解，但默认仍是"宽松"的。

坑 4：表是引用语义。 local b = a 只是复制引用，改 b 就是改 a。想深拷贝得自己写递归（还要处理环和元表），标准库不提供。

边界：table 万能，但不是为"大"而生。 静态类型检查、编译期优化、大规模工程的组织能力都不是 Lua 的强项；一旦脚本复杂到一定程度，Lua 的"自由"会变成"失控"。所以工业界的主流用法是：宿主用 C++/Rust 管性能和结构，Lua 只负责薄薄一层易变逻辑——Redis 的 Lua 脚本限制在几 KB、OpenResty 的 Lua 代码按模块严格分层，都是这个思路。

六、对比表 + 🐾 小结

维度 Lua table Python list/dict C++ vector/map
数组与字典 同一种类型 list / dict 分家 vector / map 分家
索引起点 1 0 0
删元素 赋 nil（有空洞陷阱） del / pop erase（迭代器失效要小心）
"魔法方法" 元表 __index/__add/... __getattr__/__add__/... 运算符重载（编译期绑定）
继承 元表链模拟 class 继承 class 继承（编译期）
模块 一张 return 的表 import 语句 头文件/命名空间
定位 可嵌入脚本 通用语言 系统语言
设计取向 Lua Python / C++
机制数量 极少（一个 table 打天下） 丰富（list/dict/class/...）
学习曲线 语法半天上手，元表要悟 概念多，但各有明确用途
适用规模 小、薄、嵌入宿主 大到中型独立项目

🐾 小结：Lua 的全部秘密，就是"一张表 + 一张元表"。数组、字典、对象、类、模块全是 table 的不同用法，运算符重载、属性拦截、继承全是 metatable 的不同钩子。它用最少的机制换来了最大的灵活，也因此成了全世界嵌入场景的首选。理解"为什么只需要一种数据结构"，你就理解了 Lua 为什么小、为什么快、为什么被嵌进 Redis、Nginx 和游戏引擎——它不是功能少，而是把功能都长在了一张表上。