深入Lua：元表

太过爱你忘了你带给我的痛 2022-11-19 12:50 196阅读 0赞

## 元表 ##

我觉得Lua最强大的地方在于对象可以设置元表，而元表会影响对象的访问行为。

Table的结构有一个metatable成员，userdata类型的结构也有一个metatable成员，这表明Table和userdata对象可以单独设置元表，其他每种类型的元素是共享的。通过情况下，我们只会对Table或Userdata设置元表，其他类型没有办法通过Lua代码设置元表。

字符串库默认给string类型设置了一个元表。使得它可以像对象一样调用字符串库的函数，比如"hello":len()

设置元表的API为lua\_setmetatable:

LUA_API int lua_setmetatable(lua_State *L, int objindex) {
      TValue *obj;
      Table *mt;
      lua_lock(L);
      // 从栈中取对象
      obj = index2addr(L, objindex);
      //从栈中取元表
      if (ttisnil(L->top - 1))
        mt = NULL;
      else {
        api_check(L, ttistable(L->top - 1), "table expected");
        mt = hvalue(L->top - 1);
      }
      //根据不同类型设置元表
      switch (ttnov(obj)) {
        case LUA_TTABLE: {  //table
          hvalue(obj)->metatable = mt;
          if (mt) {
            luaC_objbarrier(L, gcvalue(obj), mt);
            luaC_checkfinalizer(L, gcvalue(obj), mt);
          }
          break;
        }
        case LUA_TUSERDATA: { //userdata
          uvalue(obj)->metatable = mt;
          if (mt) {
            luaC_objbarrier(L, uvalue(obj), mt);
            luaC_checkfinalizer(L, gcvalue(obj), mt);
          }
          break;
        }
        default: {  // 其他类型
          G(L)->mt[ttnov(obj)] = mt;
          break;
        }
      }
      L->top--;
      lua_unlock(L);
      return 1;
    }

## 元方法 ##

元表是通过定义在其上的字段来影响对象的行为的，这些字段也称为元方法，但其实不是每个字段都是函数，有些是字符串，有些甚至可以是另外一个表，大概列举如下:

> \_\_tostring, \_\_pairs, \_\_name, \_\_index, \_\_newindex, \_\_call, \_\_add, \_\_sub, \_\_mul, \_\_div, \_\_mod, \_\_pow, \_\_unm, \_\_idiv, \_\_band, \_\_bor, \_\_bxor, \_\_bnot, \_\_shl, \_\_shr, \_\_concat, \_\_len, \_\_eq, \_\_lt, \_\_le, \_\_gc, \_\_mode,

关于元方法的具体含义，具体请看文档，这里不再描述。

在ltm.h|.c中实现了元方法的一些辅助函数，其中有一个枚举:

typedef enum {
      TM_INDEX,
      TM_NEWINDEX,
      TM_GC,
      TM_MODE,
      TM_LEN,
      TM_EQ, /* 在这之前的元方法可以快速访问 */
      ...
      TM_N   /* 枚举数量 */
    } TMS;

枚举了元方法的类型，在global\_state中有一个tmname字段，为TMS到元方法名字的映射，在下面代码初始化:

void luaT_init (lua_State *L) {
        static const char *const luaT_eventname[] = { /* ORDER TM */
            "__index", "__newindex",
            "__gc", "__mode", "__len", "__eq",
            "__add", "__sub", "__mul", "__mod", "__pow",
            "__div", "__idiv",
            "__band", "__bor", "__bxor", "__shl", "__shr",
            "__unm", "__bnot", "__lt", "__le",
            "__concat", "__call"
        };
        int i;
        for (i=0; i<TM_N; i++) {
            G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
            luaC_fix(L, obj2gco(G(L)->tmname[i])); /* never collect these names */
        }
    }

由上面代码可知tmname的字段为不会被GC回收的短字符串对象。这样的话使用TMS宏即可快速从tmname找到相应的元方法名。再由元方法名找元表的字段值。

## 快速访问元方法 ##

正常取元方法值是下面这个函数:

const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
        // 主体逻辑很简单，根据类型取出ua尿素，然后调用luaH_getshortstr取元方法
        Table *mt;
        switch (ttnov(o)) {
            case LUA_TTABLE:
                mt = hvalue(o)->metatable;
                break;
            case LUA_TUSERDATA:
                mt = uvalue(o)->metatable;
                break;
            default:
                mt = G(L)->mt[ttnov(o)];
        }
        return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : luaO_nilobject);
    }

ltm.h中有一个fasttm宏，用于加速取表中某些元方法的值，看最上面的枚举，在TM\_EQ之上那些元方法会用加速的方式，怎么加速呢：

// L为lua_State, et为元素， e为TMS枚举
    #define fasttm(l,et,e) gfasttm(G(l), et, e)
    // 先通过Table的flag标记位判断，如果该位存在，表示没有该元方法，直接返回NULL
    // 否则才通过luaT_gettm去取
    #define gfasttm(g,et,e) ((et) == NULL ? NULL : \
        ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))

luaT\_gettm代码如下:

const TValue *luaT_gettm(Table *events, TMS event, TString *ename) {
        // 先尝试从Table中取元方法值
        const TValue *tm = luaH_getshortstr(events, ename);
        lua_assert(event <= TM_EQ);
        // 如果值不存在，设置表中的flags相应位为1
        // 下次再调用fasttm, 就不会调到这个函数了。
        if (ttisnil(tm)) {  /* no tag method ? */
            events->flags |= cast_byte(1u<<event); /* cache this fact */
            return NULL;
        }
        else return tm;
    }

我们前面看Table结构时，注意到这个flags成员，现在终于知道它是用在这里的。flags的位为1表示该位的元方法不存在，这样就避免每次查询元方法都要从元表去取，某些元方法的查询是很频繁的。

但既然有了状态，就得维护这个状态，ltable.h有一个宏invalidateTMcache,作用是把flags清0：

> \#define invalidateTMcache(t)   ((t)->flags = 0)

注意fasttm只能用于表，用户数据只能通过luaT\_gettmbyobj查询元方法。

## 列举元方法的调用 ##

不同的元方法会在不同的代码出现，下面只能列举一些。

### \_\_index ###

索引表，流程大概是这样的:

*  调用luaV\_gettable取表的字段，其中:
 *  调用luaV\_fastget取字段，如果失败则调用luaV\_finishget, 这里面就会使用元方法
 *  通过fasttm或luaT\_gettmbyobj得到元方法后，判断它是否为函数，如果为函数则调用luaT\_callTM,否则它应该是一个表，则继续这个过程。
 *  假如一直这个循环，直到MAXTAGLOOP次，则Lua直接报错，说明这个\_\_index链太长了。

具体逻辑请看上面这几个函数。

\_\_newindex

设置表，流程大概是这样的:

*  调用luaV\_settable设置表字段，其中:
 *  调用luaV\_fastset设置字段，如果失败则调用luaV\_finishset,这里面就会使用元方法。
 *  通过fasttm或luaT\_gettmbyobj得到元方法后，判断他是否为函数，如果为函数则调用luaT\_callTM,否则它应该是一个表，则继续这个过程。
 *  假如一直这个循环，直到MAXTAGLOOP次，则Lua直接报错，说明这个\_\_newindex链太长了。

具体逻辑请看上面这几个函数。

### \_\_eq ###

比较两个对象是否相等，在`luaV_equalobj`中如果对象是表或用户数据，则尝试通过`fasttm`取得它们的元方法，如果取得到，就调用`luaT_callTM`。

### \_\_len ###

取对象长度，在`luaV_objlen`函数中，中如果对象是表或用户数据，则尝试通过`fasttm`取得它们的元方法，如果取得到，就调用`luaT_callTM`。

### \_\_name ###

自定义对象的名字，`luaT_objtypename`函数返回一个对象的名字，比如boolean, nil, table等等，但对象的名字可以自定义，只要这个对象有一个元表，指定元表的\_\_name元方法即可，对象名字一般用于错误提示上，比如`luaG_typeerror`等函数。

### \_\_tostring ###

返回对象的字符串表现，看一下Lua的tostring函数的调用链：

tostring -> luaB_tostring -> luaL_tolstring

luaL\_tolstring尝试调用对象元表的**tostring，如果没有**tostring就根据类型来，最后默认就是typename : 对象地址

### \_\_pairs ###