Lua元表理解_lua 的m元表-CSDN博客

本文链接：https://blog.csdn.net/yunjianxi0000/article/details/96331903

Lua元表

lua元表(Metatable)是lua提供给我们改变table行为的方法，每个行为关联了对应的元方法。

有两个很重要的函数来处理元表：
- setmetatable(table,metatable): 对指定 table 设置元表(metatable)，如果元表(metatable)中存在 __metatable 键值，setmetatable 会失败；
- getmetatable(table): 返回对象的元表(metatable)。

设置元表

    mytable = {}                          -- 普通表 
    mymetatable = {}                      -- 元表
    setmetatable(mytable,mymetatable)     -- 把mymetatable设为mytable的元表 
    --也可写为一行
    mytable = setmetatable({},{})
    --返回对象的元表
    getmetatable(mytable)                 -- 返回mymetatable

Lua元方法

函数	描述
__add	运算符 +
__sub	运算符 -
__mul	运算符 *
__ div	运算符 /
__mod	运算符 %
__unm	运算符 -（取反）
__concat	运算符 …
__eq	运算符 ==
__lt	运算符 <
__le	运算符 <=
__call	当函数调用
__tostring	转化为字符串
__index	调用一个索引
__newindex	给一个索引赋值

__add

使用元表定义Lua如何计算两个table的相加操作a+b。

    local t1 = {1,2,3}
    local t2 = {4,5,6}
    setmetatable(t1,{__add = function(t1,t2)
        local temp = {}
        for k,v in pairs(t1) do
            table.insert(temp,v)
        end
        for k,v in pairs(t2) do
            table.insert(temp,v)
        end
        return temp
    end
    })
    local t3 = t1 + t2
    for k,v in pairs(t3) do
        print(v)
    end
    -- 输出为：1，2，3，4，5，6

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

sub, mul, div, mod, unm, concat, eq, lt, le与add雷同，这里就不做说明了

__index

__index是 metatable 最常用的键，用来对表访问，__index可以是一个函数也可是一个table。
- __index 为 table:
  
  当你通过键来访问 table 的时候，如果这个键没有值，那么Lua就会寻找该table的metatable（假定有metatable）中的__index 键。如果__index包含一个表，Lua会在表中查找相应的键。
```
    local tarkey = {
        name = "__index为table",
    }
    local tempT = {}
    setmetatable(tempT,{__index = tarkey})
    print(tempT.name)
    -- 输出为 __index为table
```
- __index 为函数:
  
  如果__index包含一个函数的话，Lua就会调用那个函数，table和键会作为参数传递给函数。__index 元方法查看表中元素是否存在，如果不存在，返回结果为 nil；如果存在则由 __index 返回结果。
```
    local mt = {
        name = "__index 为函数",
    }
    
    local tempT = {}
    print(tempT.name)
    -- 输出为 nil
    setmetatable(tempT,{__index = function (tab,key)
        if mt[key] then 
            return mt[key]
        else
            return "mt 中不存在 " .. key
        end
    end})
    print(tempT.name)
    -- 输出为 __index 为函数
    print(tempT.value)
    -- 输出为 mt 中不存在 value
```
- 总结
  
  出处菜鸟教程lua元表
  - Lua 查找一个表元素时的规则，其实就是如下 3 个步骤:
    - 1、在表中查找，如果找到，返回该元素，找不到则继续；
    - 2、判断该表是否有元表，如果没有元表，返回 nil，有元表则继续；
    - 3、判断元表有没有 __index 方法，如果 __index 方法为 nil，则返回 nil；如果 __index 方法是一个表，则重复 1、2、3；如果 __index 方法是一个函数，则返回该函数的返回值。

__newindex

__newindex 元方法用来对表更新，当为table中一个不存在的key时，会去调用元表中的__newindex元方法,而不进行赋值；如果为table中一个存在的key时，则会进行赋值，而不调用元方法 __newindex。__newindex可以是一个函数也可是一个table。

__newindex 为table

    local mt = {}
    local tempT = {value = "当前值"}
    print(tempT.value)
    -- 输出为 当前值

    setmetatable(tempT,{__newindex = mt})
    tempT.newvalue = "新值1"
    print(tempT.newvalue,mt.newvalue)
    -- 输出为 nil , 新值1

    tempT.value = "新值2"
    print(tempT.value,mt.value)
    --输出为 新值2 , nil

__newindex 为函数

    local tempT = {
        name = "原始"
    }
    print(tempT.name)
    -- 输出为 原始

    setmetatable(tempT,{__newindex = function (t,key,value)
        rawset(t,key,"new " .. value)
    end})
    tempT.name = "new 原始"
    tempT.age = 10
    print(tempT.name,tempT.age)
    -- 输出为 new 原始 , new 10

rawget 和 rawset
- rawget可以让你直接获取到表中索引的实际值，而不通过元表的__index元方法
- rawset可以让你直接为表中索引的赋值，而不通过元表的__newindex元方法

__call

__call可以让table当做一个函数来使用

    local tempT = {1,2,3}
    -- tempT()
    -- 报错 attempt to call local 'tempT' (a table value) 
    -- 正常情况下一个table 不能这样使用

    setmetatable(tempT,{__call = function (t)
        for k,v in pairs(t) do
            print(v)
        end
    end})
    tempT()
    -- 输出 1，2，3

__tostring

__tostring用于修改表的输出行为

    local tempT = {1,2,3}
    print(tempT)
    -- 输出 table: 0x2565120

    setmetatable(tempT,{__tostring = function (t)
        local s = ""
        for k,v in pairs(t) do
            s = s .. v .. ","
        end
        return s
    end})
    print(tempT)
    -- 输出为 1，2，3，