<p>思考并回答以下问题:<br>1.如何创建一个空表?</p>

在 Lua table 中可以访问对应的key来得到value值,但是却无法对两个 table 进行操作。要实现两个table的操作就要使用Lua提供的元表(Metatable),元表允许我们改变table的行为,每个行为关联了对应的元方法。

Lua中每一个值都有metatable。metatable是一个普通的table,定义了一个值在特定情况下的操作。你可以通过修改值的metatable来修改这些操作。

在Lua代码中,只能设置table的元表,若要设置其它类型值的元表,则必须通过C代码来完成。

table和userdata可以有各自独立的元表,而其它数据类型的值则共享其类型所属的单一元表。缺省情况下,table在创建时没有元表。

任何table都可以作为任何值的元表,而一组相关的table也可以共享一个通用的元表,此元表将描述了它们共同的行为。一个table甚至可以作为它自己的元表,用于描述其特有的行为。

例如,使用元表我们可以定义Lua如何计算两个table的相加操作a+b。

当Lua试图对两个表进行相加时,先检查两者之一是否有元表,之后检查是否有一个叫__add的字段,若找到,则调用对应的值。__add等字段其对应的值(往往是一个函数或是table)就是** 元方法 ** ,前面有两个下划线。

有两个很重要的函数来处理元表:

  • setmetatable(table,metatable): 对指定 table 设置元表(metatable),如果元表(metatable)中存在 __metatable 键值,setmetatable 会失败。
  • getmetatable(table): 返回对象的元表(metatable)。

以下实例演示了如何对指定的表设置元表:

1
2
3
mytable = {}                      
mymetatable = {}
setmetatable(mytable,mymetatable)

以上代码也可以直接写成一行:

1
mytable = setmetatable({},{})

以下为返回对象元表:

1
getmetatable(mytable) 

算术类的元方法

在下面的示例代码中,将用table来表示集合,并且有一些函数用来计算集合的并集和交集等。

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
Set = {}
local metatable = {} --元表

--根据参数列表中的值创建一个新的集合
function (l)
local set = {}
--将所有由该方法创建的集合的元表都指定到metatable
setmetatable(set, metatable)
for _, v in ipairs(l) do
set[v] = true
end
return set
end

--取两个集合并集的函数
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

--取两个集合交集的函数
function Set.intersection(a, b)
local res = Set.new {}
for k in pairs(a) do
res[k] = b[k]
end
return res
end

function Set.tostring(set)
local l = {}
for e in pairs(set) do
l[#l + 1] = e
end
return "{" .. table.concat(l, ", ") .. "}"
end

function Set.print(s)
print(Set.tostring(s))
end

--最后将元方法加入到元表中,这样当两个由Set.new方法创建出来的集合进行
--加运算时,将被重定向到Set.union方法,乘法运算将被重定向到Set.intersection
metatable.__add = Set.union
metatable.__mul = Set.intersection

--下面为测试代码
s1 = Set.new {10, 20, 30, 50}
s2 = Set.new {30, 1}
s3 = s1 + s2
Set.print(s3)
Set.print(s3 * s1)

--输出结果为:
--{1, 30, 10, 50, 20}
--{30, 10, 50, 20}

在元表中,每种算术操作符都有对应的字段名,对应的操作列表如下:(注意:__是两个下划线)

** 模式 **
** 描述 **
__add 对应的运算符 ‘+’.
__sub 对应的运算符 ‘-‘.
__mul 对应的运算符 ‘*’.
__div 对应的运算符 ‘/‘.
__mod 对应的运算符 ‘%’.
__unm 对应的运算符 ‘-‘.
__concat 对应的运算符 ‘..’.
__eq 对应的运算符 ‘==’.
__lt 对应的运算符 ‘<’.
__le 对应的运算符 ‘<=’.

对于上面的示例代码,我们在算术运算符的两侧均使用了table类型的操作数。那么如果为s1 = s1 + 8,Lua是否还能正常工作呢?答案是肯定的,因为Lua定位表的步骤为,如果第一个值有元表,且存在__add字段,那么Lua将以这个字段为元方法,否则会再去查看第二个值否是有元表且包含__add字段,如果有则以此字段为元方法。最后,如果两个值均不存在元方法,Lua就引发一个错误。然而对于上例中的Set.union函数,如果执行s1 = s1 + 8将会引发一个错误,因为8不是table对象,不能基于它执行pairs方法调用。为了得到更准确的错误信息,我们需要给Set.union函数做如下的修改,如:

1
2
3
4
5
6
7
function Set.union(a,b)
if getmetatable(a) ~= metatable or getmetatable(b) ~= metatable then
error("attempt to 'add' a set with a non-set value")
end
--后面的代码与上例相同。
... ...
end

关系类的元方法

元表还可以指定关系操作符的含义,元方法分别为__eq(等于)、__lt(小于)和__le(小于等于),至于另外3个关系操作符,Lua没有提供相关的元方法,可以通过前面3个关系运算符的取反获得。

** 模式 **
** 描述 **
__eq 对应的运算符 ‘==’.
__lt 对应的运算符 ‘<’.
__le 对应的运算符 ‘<=’.

与算术类的元方法不同,关系类的元方法不能应用于混合的类型。

示例如下:

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
27
28
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

metatable.__le = function(a,b)
for k in pairs(a) do
if not b[k] then return false end
end
return true
end
metatable.__lt = function(a,b) return a <= b and not (b <= a) end
metatable.__eq = function(a,b) return a <= b and b <= a end

--下面是测试代码:
s1 = Set.new{2,4}
s2 = Set.new{4,10,2}
print(s1 <= s2) --true
print(s1 < s2) --true
print(s1 >= s1) --true
print(s1 > s1) --false

库定义的元方法

除了上述基于操作符的元方法外,Lua还提供了一些针对框架的元方法,如print函数总是调用tostring来格式化其输出。如果当前对象存在__tostring元方法时,tostring将用该元方法的返回值作为自己的返回值,如:

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
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.tostring(set)
local l = {}
for e in pairs(set) do
l[#l + 1] = e
end
return "{" .. table.concat(l,", ") .. "}";
end

metatable.__tostring = Set.tostring


--下面是测试代码:
s1 = Set.new{4,5,10}
print(s1) --{5,10,4}

函数setmetatable和getmetatable也会用到元表中的一个字段(__metatable),用于保护元表,如:

1
2
3
4
mt.__metatable = "not your business"
s1 = Set.new{}
print(getmetatable(s1)) --此时将打印"not your business"
setmetatable(s1,{}) --此时将输出错误信息:"cannot change protected metatable"

从上述代码的输出结果即可看出,一旦设置了__metatable字段,getmetatable就会返回这个字段的值,而setmetatable将引发一个错误。

table访问的元方法

算术类和关系类运算符的元方法都为各种错误情况定义了行为,它们不会改变语言的常规行为。但是Lua还提供了一种可以改变table行为的方法。有两种可以改变的table行为:查询table及修改table中不存在的字段。

** __index 元方法 **

这是 metatable 最常用的键(key)。

当你通过键来访问 table 的时候,如果这个键没有值,那么Lua就会寻找该table的metatable(假定有metatable)中的__index键。如果__index包含一个表,Lua会在表中查找相应的键。

例如:

1
2
3
4
other = { foo = 3 } 
t = setmetatable({}, { __index = other })
print(t.foo) -- 3
print(t.bar) -- nil

如果__index包含一个函数的话,Lua就会调用那个函数,table和键会作为参数传递给函数。

__index 元方法查看表中元素是否存在,如果不存在,返回结果为 nil;如果存在则由 __index 返回结果。

1
2
3
4
5
6
7
8
9
10
11
mytable = setmetatable({key1 = "value1"}, {
__index = function(mytable, key)
if key == "key2" then
return "metatablevalue"
else
return nil
end
end
})

print(mytable.key1,mytable.key2)

实例输出结果为:

1
value1    metatablevalue

实例解析:

  • mytable 表赋值为 {key1 = “value1”}。
  • mytable 设置了元表,元方法为 __index。
  • 在mytable表中查找 key1,如果找到,返回该元素,找不到则继续。
  • 在mytable表中查找 key2,如果找到,返回 metatablevalue,找不到则继续。
  • 判断元表有没有__index方法,如果__index方法是一个函数,则调用该函数。
  • 元方法中查看是否传入 “key2” 键的参数(mytable.key2已设置),如果传入 “key2” 参数返回 “metatablevalue”,否则返回 mytable 对应的键值。

我们还可以将以上代码简单写成:

1
2
mytable = setmetatable({key1 = "value1"}, { __index = { key2 = "metatablevalue" } })
print(mytable.key1,mytable.key2)

如果想在访问table时禁用__index元方法,可以通过函数rawget(table,key)完成。通过该方法并不会加速table的访问效率。

** 总结 **

Lua查找一个表元素时的规则,其实就是如下3个步骤:

  • 在表中查找,如果找到,返回该元素,找不到则下一步
  • 判断该表是否有元表,如果没有元表,返回nil,有元表则下一步
  • 判断元表有没有__index方法,如果__index方法为nil,则返回nil;如果__index方法是一个表,则重复1、2、3;如果__index方法是一个函数,则返回该函数的返回值。

** __newindex 元方法 **
__newindex 元方法用来对表更新,__index则用来对表访问 。

当你给表的一个缺少的索引赋值,解释器就会查找__newindex元方法:如果存在则调用这个函数而不进行赋值操作。

以下实例演示了 __newindex 元方法的应用:

1
2
3
4
5
6
7
8
9
10
mymetatable = {}
mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })

print(mytable.key1)

mytable.newkey = "新值2"
print(mytable.newkey,mymetatable.newkey)

mytable.key1 = "新值1"
print(mytable.key1,mymetatable.key1)

以上实例执行输出结果为:

1
2
3
value1
nil 新值2
新值1 nil

以上实例中表设置了元方法__newindex,在对新索引键(newkey)赋值时(mytable.newkey = “新值2”),会调用元方法,而不进行赋值。而如果对已存在的索引键(key1),则会进行赋值,而不调用元方法 __newindex。

以下实例使用了 rawset 函数来更新表:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
mytable =
setmetatable(
{key1 = "value1"},
{
__newindex = function(mytable, key, value)
rawset(mytable, key, '"' .. value .. '"')
end
}
)

mytable.key1 = "new value"
mytable.key2 = 4

print(mytable.key1, mytable.key2)

以上实例执行输出结果为:

1
new value    "4"

总结

从本文中可以知道元表可以很好的简化我们的代码功能,所以了解 Lua 的元表,可以让我们写出更加简单优秀的 Lua 代码。