Lua编程7之metatable

发表于 | 更新于 | 分类于
本文字数： 8.1k | 阅读时长 ≈ 7 分钟

思考并回答以下问题：

  • Lua中每一个值都有metatable。想到了C#的什么？只能设置table的元表吗？
  • Lua如何计算两个table的相加操作？
  • setmeta和getmeta是做什么用的？
  • __index元方法是干嘛用的？可以写函数吗？参数是什么？
  • __newindex元方法是干嘛用的？
  • 元表是如何做到简化代码功能的？

Lua元表

元表是在普通表的基础上扩展出来的表，元表本质上也是一个表，但是里面有很多的元方法，可以为表添加操作符。

没有元表的时候：

1
2
3
4
5
6
7
8
9
10
11
12
13
a = {}
b = {}
a+b -- 无法执行 stdin:1: attempt to perform arithmetic on a table value (global 'a')

print(a) -- table: 00000000003822F0 类型（表）：内存地址

a = {12, 34, 67, 24, 79, 242}
print(a) -- 现在想直接输出里面的数字

-- 一种方法是for循环
-- 第二种方法是使用元表，定义一些元方法，直接print(a)这样写就可以，通过元表改变输出模式，变成输出数字。

print(a[10]) --

有元表后：

1
a+b -- 可以计算

在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) -- 把mymetatable设为mytable的元表

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

1
mytable = setmetatable({},{})

以下为返回对象元表：

1
getmetatable(mytable) -- 这会返回mymetatable

算术类的元方法

在下面的示例代码中，将用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 Set.new(l)
    local set = {}
    --将所有由该方法创建的集合的元表都指定到metatable
    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

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元方法

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

当你给表的一个缺少的索引赋值，解释器就会查找__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函数来更新表：

rawset (table, index, value)

将table[index]的值直接设为value，不调用__newindex元方法。

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代码。

0%