Lua元表(Metatable)相关知识点总结

设置元表

元表是lua的核心语法之一。

作用：
类似“继承”，将两个table关联到一起，也可以理解为“附加”。

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

代码：

mytable = {}                          -- 普通表
mymetatable = {}                      -- 元表
setmetatable(mytable,mymetatable)     -- 把 mymetatable 设为 mytable 的元表
local temp =  getmetatable(mytable)   -- 获取mytable的元表
print(temp)          
print(mymetatable)

输出内存地址相同，说明getmetatable成功获取了mytable的元表mymetatable。

__index 元方法

只添加元表无法直接访问到元表的内容，此时如果直接访问元表中内容会返回nil。此时就需要使用到__index元方法。

作用：
设置元表的__index 索引，让这个索引指向元表自身，这样才能直接访问到元表内容。
当你通过键来访问 table 的时候，如果这个键没有值，那么lua就会寻找该table的metatable（假定有）中的__index 键。如果__index包含一个table，lua会在表格中查找相应的键。
注意：当table找不到索引时访问的是元表中__index指向的table，而不是元表。

代码：

mytable = {}
mymetatable = {}

--两种写法
--1.
setmetatable(mytable,mymetatable)
mymetatable.__index = mymetatable

--2.
setmetatable(mytable,{__index = mymetatable})

如果__index包含的是函数的话，lua就会调用那个函数，当前table和键会作为参数传递给函数。
__index元方法查看表中元素是否存在，如果不存在，返回结果为 nil；如果存在则由__index返回结果。

代码：

mytable = setmetatable({key1 = "value1"}, {
  __index = function(mytable, key) --这里不要纠结参数，实际传进来的就是self和键值
    if key == "key2" then
      return "metatablevalue"
    else
      return nil
    end
  end
})

print(mytable.key1,mytable.key2)

输出：value1 metatablevalue
等同于

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

__newindex 元方法

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

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

如果对已存在的索引键（key1）赋值，则不调用元方法 __newindex。
这里使用rawset函数给mytable赋值。rawset赋值可以让table元方法失效。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。
代码如下：

function readOnly(t)
    local proxy = {}  --定义一个空表，访问任何索引都是不存在的，所以会调用__index 和__newindex
    local mt = {
    __index = t, ---__index 可以是函数，也可以是table，是table的话，调用直接返回table的索引值
    __newindex = function(t,k,v)
        error("attempt to update a read-only table",2)
    end
    }
    setmetatable(proxy,mt)
    return proxy
end
 
days = readOnly{"Sunday","Monday","Tuesday","Wednessday","Thursday","Friday","Saturday"} 
print(days[1])
days[2] = "hello"  --这一行就非法访问了

输入结果：
Sunday
attempt to update a read-only table

总结：
1、如果 __newindex 是一个函数，则在给 table 中不存在的字段赋值时，会调用这个函数，并且赋值不成功。
2、如果 __newindex 是一个 table，则在给 table 中不存在的字段赋值时，会直接给 __newindex的table 赋值。

为表添加操作符

lua可以自定义表的操作符，类似C#。

作用：自定义操作符逻辑。

代码：
下面示例自定义+操作符。

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元方法在表调用时调用。

代码：
以下实例演示了计算表中元素的和：

-- 计算表中最大值，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

注意：__call的参数是可选的，可以多传也可以不传。第一个参数为自身table。

__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