深入谈谈lua中神奇的table

最近为了折腾 awesome WM，顺手翻了翻 Lua 的语法。不翻不知道，一翻吓一跳——Lua 里的 table 简直是个万能工具，灵活得有点不讲道理。

table 在 Lua 中几乎无处不在：最基础的是当字典和数组用；进阶一点，可以用来设置闭包环境、组织模块；再往上，甚至连对象和类的模拟，也是靠它撑起来的。可以说，理解了 table，就理解了 Lua 的一半核心。

字典

table 最基本的使用场景，就是当作字典。它的 key 可以是任何类型的值——nil 除外。

t={}
t[{}] = "table"  -- key 可以是 table
t[1] = "int"  -- key 可以是整数
t[1.1] = "double" -- key 可以是小数
t[function () end] = "function" -- key 可以是函数
t[true] = "Boolean" -- key 可以是布尔值
t["abc"] = "String" -- key 可以是字符串
t[io.stdout] = "userdata" -- key 可以是userdata
t[coroutine.create(function () end)] = "Thread" -- key可以是thread

当 table 作为字典时，可以用 pairs 来遍历所有键值对。

for k,v in pairs(t) do
 print(k,"->",v)
end

运行结果是这样的：

1 -> int
1.1 -> double
thread: 0x220bb08 -> Thread
table: 0x220b670 -> table
abc -> String
file (0x7f34a81ef5c0) -> userdata
function: 0x220b340 -> function
true -> Boolean

从结果中能发现一个有趣的特性：pairs 遍历的次序并不是固定的，而是随机的。同样的代码多跑几次，输出顺序可能完全不一样。

在实际开发中，key 最常见的类型是整数和字符串。当 key 是字符串时，table 可以当成结构体来用，而且写法上有个糖：t["field"] 可以直接写成 t.field。

数组

当 key 变成整数时，table 就摇身一变，成了一个数组。而且这个数组的索引从1开始计数，没有固定长度，还能根据需要自动增长。

a = {}
for i=0,5 do  -- 注意，这里故意写成了i从0开始
 a[i] = 0
end

如果想取数组的长度，可以用 # 操作符。

print(#a)

猜猜结果多长？

5

没错，答案是 5。这说明 a[0] 这号索引根本不参与长度计算。我们再拿 ipairs 验证一下：

for i,v in ipairs(a) do
 print(i,v)
end

结果：

1 0
2 0
3 0
4 0
5 0

从 1 到 5，a[0] 确实被无视了。这个“从 1 开始”的习惯，刚接触时容易踩坑，习惯就好。

另外，当数组的索引不连贯时，# 的行为会变得相当诡异，需要额外小心。

a = {}
for i=1,5 do
 a[i] = 0
end
a[8] = 0   -- 虽然索引不连贯，但长度是以最大索引为准
print(#a)
a[100] = 0   -- 索引不连贯，而且长度不再以最大索引为准了
print(#a)

结果：

8
8

一旦索引空洞太大，# 就不一定等于最大索引。而 ipairs 则更保守，只会从 1 遍历到第一个中断处。

for i,v in ipairs(a) do
 print(i,v)
end

结果：

1 0
2 0
3 0
4 0
5 0

所以，如果不确定索引是否连续，遍历数组时最好用 pairs 或者自己维护一个索引列表，别盲目信 #。

环境(命名空间)

Lua 把所有全局变量和局部变量，都塞进一个常规的 table 里管理。这个 table 被称为“环境”。为了方便，Lua 在创建全局环境时，直接用全局变量 _G 来引用它。

换句话说，在没有手动设置环境的情况下，可以通过 _G[varname] 来存取任何全局变量的值。

for k,v in pairs(_G) do
 print(k,"->",v)
end

结果会列出所有全局可用的名字：

rawequal -> function: 0x41c2a0
require -> function: 0x1ea4e70
_VERSION -> Lua 5.3
debug -> table: 0x1ea8ad0
string -> table: 0x1ea74b0
xpcall -> function: 0x41c720
select -> function: 0x41bea0
package -> table: 0x1ea4820
assert -> function: 0x41cc50
pcall -> function: 0x41cd10
next -> function: 0x41c450
tostring -> function: 0x41be70
_G -> table: 0x1ea2b80
coroutine -> table: 0x1ea4ee0
unpack -> function: 0x424fa0
loadstring -> function: 0x41ca00
setmetatable -> function: 0x41c7e0
rawlen -> function: 0x41c250
bit32 -> table: 0x1ea8fc0
utf8 -> table: 0x1ea8650
math -> table: 0x1ea7770
collectgarbage -> function: 0x41c650
rawset -> function: 0x41c1b0
os -> table: 0x1ea6840
pairs -> function: 0x41c950
arg -> table: 0x1ea9450
table -> table: 0x1ea5130
tonumber -> function: 0x41bf40
io -> table: 0x1ea5430
loadfile -> function: 0x41cb10
error -> function: 0x41c5c0
load -> function: 0x41ca00
print -> function: 0x41c2e0
dofile -> function: 0x41cbd0
rawget -> function: 0x41c200
type -> function: 0x41be10
getmetatable -> function: 0x41cb80
module -> function: 0x1ea4e00
ipairs -> function: 0x41c970

从 Lua 5.2 开始，你可以通过修改 _ENV 来为某个函数设置独立的环境（5.1 中的 setfenv 已被废除）。这样，函数内部的变量查找就会在一个全新的 table 中进行。

a=1    -- 全局变量中a=1
local env={a=10,print=_G.print} -- 新环境中a=10,并且确保能访问到全局的print函数
function f1()
 local _ENV=env
 print("in f1:a=",a)
 a=a*10   -- 修改的是新环境中的a值
end

f1()
print("globally:a=",a)
print("env.a=",env.a)

输出结果：

in f1:a= 10
globally:a= 1
env.a= 100

此外，新创建的闭包会继承它创建时的那个函数的环境。这个机制在实现沙箱或隔离上下文时非常有用。

module

Lua 中的模块，本质上也是一个 table。这个 table 包含了模块导出的所有函数和常量。定义模块的基础模板是这样的：

module(模块名, package.seeall)

module(模块名) 做的事情，相当于帮你自动搭建了一套环境：

local modname = 模块名
local M = {} -- M即为存放模块所有函数及常数的table
_G[modname] = M
package.loaded[modname] = M
setmetatable(M,{__index=_G}) -- package.seeall可以使全局环境_G对当前环境可见
local _ENV = M -- 设置当前的运行环境为 M，这样后续所有代码都不需要限定模块名了，所定义的所有函数自动变成M的成员
<函数定义以及常量定义>

return M -- module函数会帮你返回module table，而无需手工返回

换句话说，你只管写函数和常量，模块的组织工作，Lua 已经帮你安排得明明白白。

对象

Lua 之所以能用 table 模拟对象，靠的是两个核心特性。

第一，函数是第一类值。这意味着你可以在 table 里直接存放函数，让这个 table 既有数据，又有行为。

Account = {balance = 0}
function Account.withdraw(v)
 Account.balance = Account.balance - v
end

第二，Lua 支持闭包，可以用它来模拟私有成员变量。

function new_account(b)
 local balance = b
 return {withdraw = function (v) balance = balance -v end,
  get_balance = function () return balance end
 }
end

a1 = new_account(1000)
a1.withdraw(10)
print(a1.get_balance())

结果：

990

不过，第一种定义对象的方式有个明显的坑——方法里写死了 Account 这个名字。一旦你改了变量名或者把 Account 置空了，方法就崩了。

a = Account
Account = nil
a.withdraw(10)     -- 会报错，因为Accout.balance不再存在

解决方案很简单：给方法加一个参数，指向对象自身。

Account = {balance=100}
function Account.withdraw(self,v)
 self.balance = self.balance - v
end
a = Account
Account = nil
a.withdraw(a,10)     -- 没问题，这个时候 self 指向的是a，因此会去寻找 a.balance
print(a.balance)

结果：

90

既然 self 几乎总是调用方法的对象本身，Lua 干脆提供了一个语法糖：用冒号代替点号。function object:method(v) end 等价于 function object.method(self, v) end，而 object:method(v) 等价于 object.method(object, v)。冒号让代码更简洁，也少写一个参数。

类

当涉及类和继承时，就要请出元表和元方法了。在 Lua 中，对象和类其实没有严格的界限。

当一个 table 被另一个 table 的 __index 元方法引用时，后者就可以访问前者中定义的方法。这时候，前一个 table 就相当于后一个的“类”。

定义一个类的基本模板有两种。第一种：

function 类名:new(o)
 o = o or {}
 setmetatable(o,{__index = self})
 return o
end

第二种更省事，少用一个 table：

function 类名:new(o)
 o = o or {}
 setmetatable(o,self)
 self.__index = self
 return o
end

有一点需要注意，也是和其他面向对象语言不太一样的地方：Lua 的元方法定义在元表上，而不是对象自身。想清楚这一点，很多设计上的疑惑就能迎刃而解。

总结

以上就是对 Lua 中 table 几个核心用法的梳理。从字典、数组，到环境、模块，再到对象和类的模拟，table 的灵活度确实让人印象深刻。如果你也在学习或使用 Lua，希望这些内容能帮你少走一些弯路。