元表

元表操作：

    setmetatable(table, metatable)

    getmetatable(table)

元方法操作：

    metatable.元方法 = function (可接受参数)

        (函数体)

    end

元方法：

    算数运算符：__add(加法)[+]、__mul(乘法)[*]、__sub(减法)[-]、__div(除法)[/]、__unm(相反数)[-]、__mod(取模)[%]、__pow(乘幂)[^]。

    逻辑运算符：__eq(等于)[=]、__lt(小于)[<]、__le(小于等于)[<=]。

    其他运算符：__concat(连接)[..]、__len(取长度)[#]。

    其他元方法：

    __tostring：返回值(可接受参数：table)

    __call：函数调用(可接受参数：table, key)

    __metatable：保护元方法(字符串)

    __index：查找表索引(可接受参数：table, key)

    __newindex：添加新索引(可接受参数：table, key, value) 

 Metatable和Metamethod

　　Metatable和Metamethod是用来干啥的？它们可以使得表a和b的表达式“a + b”变得有意义，其中metatable使两个不相关的表a和b之间可以进行操作，而操作的具体行为比如说"+"由metamethod来具体定义。

　　Metatable和Metamethod大多数地方都翻译成“元表”和“元函数”，这是一种直译，相当不直观。根据Metatable的用法，我倾向于将Metatable翻译成关联表，Metamethod翻译成关联函数。通过给两个table设置Metatable可以使两个table产生联系，然后对两个table进行一些操作，具体的操作行为由Metamethod来定义。下面的例子中，在对表t1和t2设置关联表mt，并在mt中定义关联函数__add后，就可以对这两个表进行"+"相加操作了。

t1 = {1, 2, 3}

t2 = {4,5,6,7,8}

mt = {}

mt.__add = function(a, b)

    local ret = 0

    for _, v in pairs(a) do

        ret = ret + v

    end

    for _, v in pairs(b) do

        ret = ret + v

    end

    return ret

end

setmetatable(t1, mt)

setmetatable(t2, mt)

print(t1 + t2)

从上面的代码中可以看到关联表就是一个表，而关联函数就是一个函数。当碰到表达式"t1+t2"时，Lua首先查找他们的关联表，找到关联表mt后，会在mt中找与相加操作对应的关联函数__add，找到__add后就将t1和t2作为参数来执行该函数，最后返回结果。

下面是一个使用关联表来对集合（用table实现的集合）进行操作的示例，实例中定义了集合的并集、交集、比较等运行：

Set = {}

--专门用来作为metatable，定义在Set里面以免影响外部的命名空间

Set.mt = {}   

--转化为string

Set.tostring = function (set)

    local s = "{"

    local sep = " "

    for e in pairs(set) do

        s = s .. sep .. e

        sep = ", "

    end

    return s.."}"

end

--打印

Set.print = function(s)

    print(Set.tostring(s))

end

Set.mt.__tostring = Set.tostring

--新建一个集合

Set.new = function (t)

    local set = {}

    setmetatable(set, Set.mt)        --指定所创建集合的metatable

    for _, l in ipairs(t) do set[l] = true end

    return set

end

--并集

Set.union = 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

--给metatable增加__add函数(metamethod)，当Lua试图对两个集合相加时，将调用这个函数，以两个相加的表作为参数

Set.mt.__add = Set.union

--交集

Set.intersection = function (a,b)

    local res = Set.new{}

    for k in pairs(a) do

        res[k] = b[k]

    end

    return res

end

--定义集合相乘操作为求交集

Set.mt.__mul = Set.intersection

--先定义"<="操作，然后基于此定义"<"和"="

Set.mt.__le = function (a, b)

    for k in pairs(a) do

        if not b[k] then return false end

    end

    return true

end

--小于

Set.mt.__lt = function(a, b)

    return a<=b and not (b <= a)

end

--等于

Set.mt.__eq = function(a, b)

    return a <= b and b <= a

end

--测试

s1 = Set.new{1, 2, 3}

s2 = Set.new{10, 20, 30, 40, 50}

print(getmetatable(s1))

print(getmetatable(s2))

s3 = s1 + s2    --等同于Set.union(s1, s2)

print(s3)

print(s3 * s2)

print(s1 <= s3)

print(s1 == s3)

print(s1 < s3)

print(s1 >= s3)

print(s1 > s3)

--起保护作用，getmetatable将返回这个域的值，而setmettable将会出错

Set.mt.__metatable = "not your business"

print(getmetatable(s1))

setmetatable(s1, {})

　　当Lua试图对两个表进行相加时，他会检查两个表是否有一个表有Metatable，并且检查Metatable是否有__add域。如果找到则调用这个__add函数（所谓的Metamethod）去计算结果。当两个表有不同的Metatable时，以谁的为准呢？Lua选择metamethod的原则：

　　（1）如果第一个参数存在带有__add域的metatable，Lua使用它作为metamethod，和第二个参数无关；

　　（2）否则，第二个参数存在带有__add域的metatable，Lua使用它作为metamethod；

　　（3）否则，报错。

　　Lua中定义的常用的Metamethod如下所示：

　　算术运算符的Metamethod：__add（加运算）、__mul（乘）、__sub(减)、__div(除)、__unm(负)、__pow(幂)，__concat（定义连接行为）。

　　关系运算符的Metamethod：__eq（等于）、__lt（小于）、__le（小于等于），其他的关系运算自动转换为这三个基本的运算。

　　库定义的Metamethod：__tostring（tostring函数的行为）、__metatable（对表getmetatable和setmetatable的行为）。

　　注意：__metatable不是函数，而是一个变量。假定你想保护你的集合使其使用者既看不到也不能修改metatables。如果你对metatable设置了__metatable的值，getmetatable将返回这个域的值，而调用用setmetatable将会出错：

　　注意：相等比较从来不会抛出错误，如果两个对象有不同的metamethod，比较的结果为false，甚至可能不会调用metamethod。这也是模仿了Lua的公共的行为，因为Lua总是认为字符串和数字是不等的，而不去判断它们的值。仅当两个有共同的metamethod的对象进行相等比较的时候，Lua才会调用对应的metamethod。

　　print总是调用tostring来格式化它的输出，tostring会首先检查对象是否存在一个带有__tostring域的metatable。

 　　表相关的Metamethod:

　　(1)__index metamethod：在继承中使用较多。当访问表不存在的一个域时，会触发Lua解释器去查找__index metamethod，如果不存在，则返回nil，否则由__index metamethod返回结果。

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}

mt.__index = function(table, key)

    return Window[key]

end

w = {x = 10, y = 20}

setmetatable(w, mt)

print(w.width)

　　可以看到w没有width域，但有关联表mt，且关联表有__index，因此w.width会触发mt.__index的调用（Lua会将w作为第一个参数、width作为第二个参数来调用该函数）。

　　__index除了作为一个函数，还可以直接作为一个表来使用当__index是一个表时，Lua会直接在这个表中查找width域。因此代码也可以像这样来写：

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}

mt.__index = Window

w = {x = 10, y = 20}

setmetatable(w, mt)

print(w.width)

 　　rawget(table, index)函数获取表中指定域的值，该函数可以绕过metamethod，直接返回表的域信息，看下面这个例子：

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}

mt.__index = function(table, key) return Window[key] end

w = {x = 10, y = 20}

setmetatable(w, mt)

print(w.width)                    --100

print(rawget(w, "width"))        --nil

print(rawget(w, "x"))            --10

　　看上面倒数第二行，rawget(w, "width")访问不存在的域不会触发查找__index。

　　(2)__newindex metamethod：__newindex metamethod用来对表更新，__index则用来对表访问。

　　当给表的一个不存在的域赋值时(比如w.add = 1)，会触发Lua查找__newindex，如果不存在__newindex，则像一般的赋值行为一样导致表添加了一个域。

　　(1)不存在__newindex，则像一般的赋值行为一样导致表添加了一个域(w多了一个域add，值为1)

　　(2)存在__newindex，则不进行赋值操作，而是由__newindex拦截了赋值操作，并且将(table、域名、值)作为参数调用__newindex。

　　也就是说，__newindex可以使得任何对表的添加元素的行为都要经过__newindex，这确实是一个很好的把关。

　　rawset(t, k, v)函数也是一个等同于赋值的操作（w.add = 1相当于rawset(w, "add", 1)），但调用该函数可以绕过metamethod，即不会导致__newindex的调用：

mt = {}

mt.__newindex = function(table, key, value)

    rawset(table, key, value)　　　　　　　　--这里不能写成table.key = value；因为这个给不存在域的赋值操作又会导致__newindex的调用，因而陷入死循环

end

w = {x = 10, y = 20}

setmetatable(w, mt)

w.add = 1

print(w.add)            -- 1

 　　和__index一样，__newindex也可以是一个表，如果__newindex是一个表，会导致对指定的那个表而不是原始的表进行赋值操作。

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}

mt.__newindex = Window

w = {x = 10, y = 20}

setmetatable(w, mt)

w.add = 1

print(w.add)                --nil

print(Window.add)            --1

　　赋值操作导致Windows添加了一个元素add，而w不影响。

　　当__index和__newindex混合使用时，一定要注意区分每个行为都干了什么事情：

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}

mt.__index = Window

mt.__newindex = Window

w = {x = 10, y = 20}

setmetatable(w, mt)

w.add = 1

print(w.add)                --1

print(Window.add)            --1

　　__newindex为表时，w.add=1表示给Window添加了add，但通过__index，w也能访问到Window的add。

　　再看下面这个例子：

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}

mt.__index = function(table, key)

    return Window[key]

end

mt.__newindex = function(table, key, value)

    rawset(table, key, value)

end

w = {x = 10, y = 20}

setmetatable(w, mt)

w.add = 1

print(w.add)            -- 1

print(Window.add)        -- nil

　　__newindex为函数时，w.add直接给w添加了add域，但Window并不存在add。所以结论是：当__newindex是函数时，给目标表w添加域；当__newindex是表时，给指向表添加域。

 　　关于__index和__newindex一定要注意区分，什么时候进入__index，什么时候进入__newindex：

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}

mt.__index = function(table, key)

    print("going here __index")

    return Window[key]

end

w = {x = 10, y = 20}

setmetatable(w, mt)

s = w.width                         　　 -- going here __index 访问语句会进入__index

w.width = 1                              -- 赋值语句不会进入__index，这里会导致w表添加width域

print(w.width)                        　　-- 1

print(rawget(w, "width"))            　　 -- 1

print(Window.width)                　　　 -- 100

　　访问语句进入__index，赋值语句不进入__index。

mt = {}

mt.__newindex = function(table, key, value)

    print("going here __newindex")

    rawset(table, key, value)

end

w = {x = 10, y = 20}

setmetatable(w, mt)

s = w.add                             -- 访问语句不会进入__newindex

w.add = 1                            -- going here __newindex 赋值语句进入__newindex

print(w.add)                        -- 1

print(rawget(w, "add"))            -- 1

　　赋值语句进入_newindex，访问语句不进入__newindex。

 　　结合上面这两句话就很容易理解下面这个例子了： 

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}

mt.__index = function(table, key)

    print("going here __index")

    return Window[key]

end

mt.__newindex = function(table, key, value)

    print("going here __newindex")

    rawset(table, key, value)

end

w = {x = 10, y = 20}

setmetatable(w, mt)

s = w.width                            -- going here __index

w.width = 1                            -- going here __newindex

print(w.width)                        -- 1

print(rawget(w, "width"))            -- 1

　　倒数第三条语句w.width = 1不会进入__index，所以会导致给w表添加新的域width。也就是说__index逻辑不会影响__newindex的判断，虽然__index可以访问到域width，但__newindex依然仍未w没有width域。

　　这些概念非常的绕，而且Lua是一种弱类型化语言，所以对于很多概念的具体行为一定要自己多加测试，不能够想当然。

Lua 元表(Metatable)

在 Lua table 中我们可以访问对应的key来得到value值，但是却无法对两个 table 进行操作。

因此 Lua 提供了元表(Metatable)，允许我们改变table的行为，每个行为关联了对应的元方法。

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

当Lua试图对两个表进行相加时，先检查两者之一是否有元表，之后检查是否有一个叫"__add"的字段，若找到，则调用对应的值。"__add"等即时字段，其对应的值（往往是一个函数或是table）就是"元方法"。

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

    setmetatable(table,metatable): 对指定 table 设置元表(metatable)，如果元表(metatable)中存在 __metatable 键值，setmetatable 会失败。

    getmetatable(table): 返回对象的元表(metatable)。

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

mytable = {}                          -- 普通表

mymetatable = {}                      -- 元表

setmetatable(mytable,mymetatable)     -- 把 mymetatable 设为 mytable 的元表

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

mytable = setmetatable({},{})

以下为返回对象元表：

getmetatable(mytable)                 -- 这回返回mymetatable

__index 元方法

这是 metatable 最常用的键。

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

我们可以在使用 lua 命令进入交互模式查看：

$ lua

Lua 5.3.0  Copyright (C) 1994-2015 Lua.org, PUC-Rio

> other = { foo = 3 }

> t = setmetatable({}, { __index = other })

> t.foo

3

> t.bar

nil

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

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

mytable = setmetatable({key1 = "value1"}, {

  __index = function(mytable, key)

    if key == "key2" then

      return "metatablevalue"

    else

      return nil

    end

  end

})

print(mytable.key1,mytable.key2)

实例输出结果为：

value1    metatablevalue

实例解析：

    mytable 表赋值为 {key1 = "value1"}。

    mytable 设置了元表，元方法为 __index。

    在mytable表中查找 key1，如果找到，返回该元素，找不到则继续。

    在mytable表中查找 key2，如果找到，返回 metatablevalue，找不到则继续。

    判断元表有没有__index方法，如果__index方法是一个函数，则调用该函数。

    元方法中查看是否传入 "key2" 键的参数（mytable.key2已设置），如果传入 "key2" 参数返回 "metatablevalue"，否则返回 mytable 对应的键值。

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

mytable = setmetatable({key1 = "value1"}, { __index = { key2 = "metatablevalue" } })

print(mytable.key1,mytable.key2)

    总结

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

        1.在表中查找，如果找到，返回该元素，找不到则继续

        2.判断该表是否有元表，如果没有元表，返回 nil，有元表则继续。

        3.判断元表有没有 __index 方法，如果 __index 方法为 nil，则返回 nil；如果 __index 方法是一个表，则重复 1、2、3；如果 __index 方法是一个函数，则返回该函数的返回值。

    该部分内容来自作者寰子：https://blog.csdn.net/xocoder/article/details/9028347

__newindex 元方法

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

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

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

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)

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

value1

nil    新值2

新值1    nil

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

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

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)

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

new value    "4"

为表添加操作符

以下实例演示了两表相加操作：

-- 计算表中最大值，table.maxn在Lua5.2以上版本中已无法使用

-- 自定义计算表中最大键值函数 table_maxn，即计算表的元素个数

function table_maxn(t)

    local mn = 0

    for k, v in pairs(t) do

        if mn < k then

            mn = k

        end

    end

    return mn

end

-- 两表相加操作

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

  __add = function(mytable, newtable)

    for i = 1, table_maxn(newtable) do

      table.insert(mytable, table_maxn(mytable)+1,newtable[i])

    end

    return mytable

  end

})

secondtable = {4,5,6}

mytable = mytable + secondtable

    for k,v in ipairs(mytable) do

print(k,v)

end

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

1    1

2    2

3    3

4    4

5    5

6    6

__add 键包含在元表中，并进行相加操作。 表中对应的操作列表如下：(注意：__是两个下划线)

模式     描述

__add   对应的运算符 '+'.

__sub   对应的运算符 '-'.

__mul   对应的运算符 '*'.

__div    对应的运算符 '/'.

__mod  对应的运算符 '%'.

__unm  对应的运算符 '-'.

__concat     对应的运算符 '..'.

__eq     对应的运算符 '=='.

__lt 对应的运算符 '<'.

__le      对应的运算符 '<='.

__call 元方法

__call 元方法在 Lua 调用一个值时调用。以下实例演示了计算表中元素的和：

-- 计算表中最大值，table.maxn在Lua5.2以上版本中已无法使用

-- 自定义计算表中最大键值函数 table_maxn，即计算表的元素个数

function table_maxn(t)

    local mn = 0

    for k, v in pairs(t) do

        if mn < k then

            mn = k

        end

    end

    return mn

end

-- 定义元方法__call

mytable = setmetatable({10}, {

  __call = function(mytable, newtable)

    sum = 0

    for i = 1, table_maxn(mytable) do

        sum = sum + mytable[i]

    end

    for i = 1, table_maxn(newtable) do

        sum = sum + newtable[i]

    end

    return sum

  end

})

newtable = {10,20,30}

print(mytable(newtable))

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

70

__tostring 元方法

__tostring 元方法用于修改表的输出行为。以下实例我们自定义了表的输出内容：

mytable = setmetatable({ 10, 20, 30 }, {

  __tostring = function(mytable)

    sum = 0

    for k, v in pairs(mytable) do

        sum = sum + v

    end

    return "表所有元素的和为 " .. sum

  end

})

print(mytable)

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

表所有元素的和为 60