lua学习之元表和元方法

Posted on | Edited on | In | Comments: | Views:

学习lua也有大概一年了，对lua的一些基本的语法很熟练了，也做了一些简单的业务，但是对于lua的高级特性还是不是很熟，最近有时间得以系统的学习学习。本文主要讲述的是lua高级特性之一的元表和元方法。

文字简述

  • metatable(元表) 本质上来讲元表也是一个表，不过这个表是用来定义对lua的值进行自定义运算行为的地方。

  • metamethod(元方法) 本质上来讲就是一个lua函数，不过这个函数是用来绑定lua中特定的值，这些特定的值可以称为事件。这个函数我们可以进行我们一些自定义的操作。

    元表之中的事件其实是一些定义的值，这些值后面会讲到；
    实际上我们只能对lua中table类型的值进行修改元表和元方法的操作，其它的一些例如number, string等都已经有自己内置的元表和元方法，且不可改变。

  • 通过元表和元方法，我们可以实现lua的面向对象编程。

代码讲解

api 介绍

简单的介绍一下会用到的api。

setmetatable(table, metatable) 设置table的元表为metatable并且返回这个table。不能为除table类型之外的值设置元表，如果metatable为nil，则将指定的元表移除 。如果存在__metatable，则会抛出一个错误。
getmetatable(obj) 返回一个类型的元表，如果没有元表返回nil。如果存在__metatable，则返回这个域的值。
rawget(table, index) 在不触发任何元方法的情况下获取table中的值。也就是跳过元表和元方法。
rawset(table, index, value) 在不触发任何元方法的情况下设置table[index]的值为value，index不能是nil和NaN

元方法介绍

我们都知道对于两个number型的值，我们可以进行加，减，乘，除等的元算，但是对于table我们是不能直接进行这些预定义的运算的。但是通过通过元表和元方法我们是可以实现的；首先介绍下有哪些特定的值被用于绑定元方法，也称为事件，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
__index -- 用于取操作
__newindex -- 用于赋值操作
__metatable -- 限定元表操作
__call -- 用于把一个函数当成函数调用的操作
__add -- '+' 加
__sub -- '-' 减
__mul -- '*' 乘
__div -- '/' 除
__mod -- '%' 取余
__pow -- '^' 次方
__unm -- '-' 取反
__concat -- '..' 连接
__tostring -- 字符串序列话
__len -- '#' 取长
__eq -- '==’ 相等
__lt -- '<' 小于
__le -- '<=' 小于等于

对于不同的lua版本可能这些事件还有区别，具体详细的可以看lua对应版本的介绍，这里只列出了一些常用的。
对于一些特定的事件进行一些简单的介绍

  • __index 当我们在取一个table中的不存在这个index的值的时候，如果有元表的话，会触发这个操作，会到元表中进行查询，并且返回这个值，元表中月不存在的时候返回nil。
  • __newindex 当我们对一个table中的一个不存在的index赋值的时候，如果有元表的话，会触发这个操作，如果元表中有定义这个行为，就按照这个进行。
  • __metatable 使用这个元方法的时候是保护元表，进值对元表中的成员进行获取或者修改
  • __call 使用这个的时候我们可以吧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
local t1 = {1, 2, 3}
local t2 = {5, 6, 7, 9}
local t = {
    __add = function(a, b)
        local tmp = {}
        for i = 1, #a do
            tmp[i] = a[i] + b[i]
        end
        for i = #tmp + 1, #b do
            tmp[i] = b[i]
        end
        return tmp
    end,
    __tostring = function(a)
        local str = ""
        local split = ""
        for i = 1, #a do
            str = str .. split .. a[i]
            split = "|"
        end
        return str
    end
}
setmetatable(t1, t)
print("t1 : ", t1)
print("t2 : ", t2)
local tmp = t1 + t2
print("tmp : ", tmp)
setmetatable(t2, t)
print(" - t2 : ", t2)
setmetatable(tmp, t)
print(" - tmp : ", tmp)

运行结果如下

1
2
3
4
5
t1 :    1|2|3
t2 :    table: 0x16984f0
tmp :   table: 0x16981c0
 - t2 :         5|6|7|9
 - tmp :        6|8|10|9

当对两个table进行加(+)的操作的时候，会查找元表中对应的元方法，然后按照元方法的行为去做。其它的一些算术运算都和这个例子大同小异，就不多做介绍了。

__index
1
2
3
4
5
local t1 = {}
local t2 = {}
t2.a = 10
setmetatable(t1, {__index = t2})
print(t1.a)

运行结果如下

1
10

当访问t1中的a的时候，t1中并没有这个值，但是t1有元表，则会到元表中查询a，并返回；
__index 也可以是一个函数，用于自定义的一些行为。

__newindex
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
local t1 = {}
t1.c = 30
local t2 = {}
t2.a = 10
t2.b = 20
setmetatable(t1, {__newindex = t2})
print(t1.a)
print(t2.a)
t1.a = "a10"
print(t1.a)
print(t2.a)
print(t1.c)
t1.c = "c10"
print(t1.c)
print(t2.c)

运行结果如下

1
2
3
4
5
6
7
nil
10
nil
a10
30
c10
nil

在对t1中的变量进行赋值的时候，如果存在则直接进行赋值，如果不存在则触发__newindex，设置元表中对应的值

__metatable
1
2
3
4
5
6
7
local t1 = {}
local t = {}
setmetatable(t1, t)
print(getmetatable(t1))
t.__metatable = "lock"
print(" metatable : ", getmetatable(t1))
setmetatable(t1, t)

运行结果如下

1
2
3
table: 0xe7f4f0
 metatable :    lock
lua: test.lua:11: cannot change a protected metatable

在设置完__metatable域的时候，就不能再对元表进行操作了，会报错。

__call
1
2
3
4
5
6
7
8
local t1 = {}
setmetatable(t1, {
    __call = function(t, a, b, c, ...)
        local num = a + b + c
        print("__call str : ", num)
    end
})
t1(1, 2, 3)

运行结果如下

1
__call str :    6

t1作为table，但是可以直接当成函数来进行调用，会查找__call元方法

rawget
1
2
3
4
5
6
local t1 = {}
local t2 = {}
t2.a = 20
setmetatable(t1, {__index = t2})
print("t1 a : ", t1.a)
print("rawget t1 a : ", rawget(t1,a))

运行结果如下

1
2
t1 a :  20
rawget t1 a :   nil

设置完元表后可以取到t1中的a，从元表t2中，但是用rawget的时候会会忽略元表的存在

rawset
1
2
3
4
5
6
7
8
local t1 = {}
local t2 = {}
t2.a = 20
setmetatable(t1, {__newindex = t2})
t1.b = "bbb"
print("t1 b : ", t1.b)
print("t2 b : ", t2.b)
rawset(t1, b, "ccc")

运行结果如下

1
2
3
t1 b :  nil
t2 b :  bbb
lua: table index is nil

正常的设置完元表并且设置__newindex域之后，对t1中的不存在的b赋值的时候会触发__newindex操作，但是如果用rawset的话就会报错，rawset(t1, b, “ccc”)，会对t1中的b进行赋值，并不会触发__newindex，而t1中也没有b这个值，所以报错了。

系统代码

以一个之前写的例子结束这篇介绍

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
--[[
    lua 5.1.5
    socket 2.0.2
]]--
local socket = require("socket")
local sub = string.sub
local byte = string.byte
local concat = table.concat
local tonumber = tonumber
local tostring = tostring
local _M = {
    _VERSION = "0.1",
}
local mt = { __index = _M }
function _M.new(self)
    local sock, err = socket.tcp()
    if not sock then
        return nil, err
    end
    return setmetatable({_sock = sock, _subscribed = false }, mt)
end
function _M.connect(self, ...)
    local args = {...}
    local sock = rawget(self, "_sock")
    if not sock then
        return nil, "not initialized"
    end
    self._subscribed = false
    return sock:connect(...)
end
function _M.close(self)
    local sock = rawget(self, "_sock")
    if not sock then
        return nil, "not initialized"
    end
    return sock:close()
end
local function _gen_req(args)
    local nargs = #args
    local req = ""
    req = req .. "*" .. nargs .. "\r\n"
    for i = 1, nargs do
        local arg = args[i]
        if type(arg) ~= "string" then arg = tostring(arg) end
        req = req .. "$"
        req = req .. #arg
        req = req .. "\r\n"
        req = req .. arg
        req = req .. "\r\n"
    end
-- print("req : ", req)
    return req
end
local function _read_reply(self, sock)
    local line, err = sock:receive()
    if not line then
        if err == "timeout" then
            sock:close()
        end
        return nil, err
    end
    local prefix = byte(line)
    if prefix == 42 then -- char "*"
        local n = tonumber(sub(line, 2))
        if n < 0 then return nil end
        local vals = {}
        local ind = 1
        for i = 1, n do
            local res, err = _read_reply(self, sock)
            if res then
                vals[ind] = res
                ind = ind + 1
            elseif not res then
                return nil, err
            end
        end
        return vals
    elseif prefix == 36 then -- char "$"
        local size = tonumber(sub(line, 2))
        if size < 0 then return nil, sub(line, 2) end
        local data, err = sock:receive(size)
        if not data then
            if err == "timeout" then
                sock:close()
            end
            return nil, err
        end
        local crlf, err = sock:receive(2)
        if not crlf then return nil, err end
        return data
    elseif prefix == 45 then -- char "-"
        return nil, sub(line, 2)
    elseif prefix == 43 then -- char "+"
        return sub(line, 2)
    elseif prefix == 58 then -- char ":"
        return tonumber(sub(line, 2))
    else
        return nil, "unknow prefix : \"" .. tostring(prefix) .. "\""
    end
end
local function _do_cmd(self, ...)
    local args = {...}
    local sock = rawget(self, "_sock")
    if not sock then
        return nil, "not initialized"
    end
    local req = _gen_req(args)
    local bytes, err = sock:send(req)
    if not bytes then
        return nil, err
    end
    return _read_reply(self, sock)
end
setmetatable( _M, { __index = function(self, cmd)
    local method = function (self, ...)
        return _do_cmd(self, cmd, ...)
    end
    _M[cmd] = method
    return method
end})
return _M

这是仿照lua-resty-redis，用luasocket实现的一个简单的lua redis客户端。
每次用的时候需要 require这个文件，并且调用new，设置相应元表，之后就可以进行简单的redis操作了。

后记

  • 本文代码部分比较多，尽可能的用代码来解释lua中元表和元方法的一些用法，如果理解起来还是不清楚可以查看lua官方文档，也可以联系我。

* 如有疑问欢迎批评指正，谢谢！ *