Lua 元表与元方法

Lua 元表(Metatable)：

在 Lua table 中我们可以访问对应的key来得到value值，但是却无法对两个 table 进行操作。如：计算两个table的相加操作a+b

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

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

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

mytable = {}                          -- 普通表 
mymetatable = {}                      -- 元表
setmetatable(mytable,mymetatable)     -- 把 mymetatable 设为 mytable 的元表 

例：

tab1 = {"java","C#","C++","lua"}   --普通表

metatable = {}   --元表

tab1 = setmetatable(tab1,metatable)   --对tab1设置元表

tab1 = setmetatable({"java","C#","C++","lua"},{})  --也可写为一行

getmetatable(tab1)   --返回对象元表 metatable

__index 元方法：

__index 元方法查看表中元素是否存在，当访问到一个不存在的键时起作用

当你通过键来访问 table 的时候，如果这个键没有值，那么Lua就会寻找该table的metatable中的__index 键。

如果__index包含一个表格，Lua会在表格中查找相应的键。

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

tab1 = {"java","C#","C++","lua"}

metatable = {
 __index = function(tab,key)
   if(key>=10) then
      return "JavaScript"
   else
      return nil
   end
end
}

tab1 = setmetatable(tab1,metatable)



print(tab1[3])
print(tab1[9])
print(tab1[10])

输出结果为：
C++
nil
JavaScript

tab1 = {"java","C#","C++","lua"}

newtable = {}
newtable[9] = "9"
newtable [10] = "10"

metatable = {
__index = newtable
}

tab1 = setmetatable(tab1,metatable)



print(tab1[3])
print(tab1[9])
print(tab1[10])

输出结果为：
C++
9
10

__newindex 元方法：

__newindex 元方法用来对表更新

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

以下实例中表设置了元方法 __newindex，在对新索引键赋值时，会调用元方法，而不进行赋值。而如果是已存在的索引键

，则会进行赋值，而不调用元方法 __newindex。

tab1 = {"java","C#","C++","lua"}

metatable = {
__newindex = function(table,key,value)
    print("我们要修改的key为："..key.."，把这个key的值改为"..value)
	rawset(table,key,value)    --使用了 rawset 函数来更新表
end
}

tab1 = setmetatable(tab1,metatable)

tab1[1] = "python"  -- 没有调用__newindex，而是进行赋值
tab1[5] = "js"      -- 调用了
print(tab1[1])

输出：
我们要修改的key为：5，把这个key的值改为js
python

tab1 = {"java","C#","C++","lua"}

newtable = {}
newtable[5] = "5"
newtable [6] = "6"

metatable = {
__newindex = newtable
}

tab1 = setmetatable(tab1,metatable)

tab1[1] = "python"  
tab1[5] = "js"      
print(tab1[1])
print(tab1[5])
print(newtable[5])

输出：
python
nil
js

给表添加加法操作符 __add

tab1 = {"java","C#","C++","lua"}

newtable = {"python","C"}

metatable = {
__add = function(tab,newtab)
    local mi = 0
	for k,v in pairs(tab) do
	     if(k>mi) then
		 mi = k
		 end
	end

	for k,v in pairs(newtable) do
	mi = mi+1
	table.insert(tab,mi,v)
	end
	return tab
end
}

tab1 = setmetatable(tab1,metatable)

v = tab1 + newtable

for k,v in pairs(v) do
print(k..":"..v)
end


输出：
1:java
2:C#
3:C++
4:lua
5:python
6:C

其他操作符：

__add      对应的运算符 '+'.
__sub      对应的运算符 '-'.
__mul      对应的运算符 '*'.
__div      对应的运算符 '/'.
__mod      对应的运算符 '%'.
__unm      对应的运算符 '-'.
__concat   对应的运算符 '..'.
__eq       对应的运算符 '=='.
__lt       对应的运算符 '<'.
__le       对应的运算符 '<='.

__call 元方法

__call 元方法在 Lua 调用一个值时调用

tab1 = {"java","C#","C++","lua"}

newtable = {"python","C"}

metatable = {
__add = function(tab,newtab)
    local mi = 0
	for k,v in pairs(tab) do
	     if(k>mi) then
		 mi = k
		 end
	end

	for k,v in pairs(newtable) do
	mi = mi+1
	table.insert(tab,mi,v)
	end
	return tab
end,
__call = function(tab,arg1,arg2,arg3)   -- tab就是我们要操作的表
  print(arg1,arg2,arg3)
  return "hello"
  end
}

tab1 = setmetatable(tab1,metatable)

v = tab1(10,20,30)
print(v)

__tostring元方法

__tostring 元方法用于修改表的输出行为

tab1 = {"java","C#","C++","lua"}

newtable = {"python","C"}

metatable = {
__add = function(tab,newtab)
    local mi = 0
	for k,v in pairs(tab) do
	     if(k>mi) then
		 mi = k
		 end
	end

	for k,v in pairs(newtable) do
	mi = mi+1
	table.insert(tab,mi,v)
	end
	return tab
end,
__tostring = function(tab)
	local str = ""
	for k,v in pairs(tab) do
         str = str..v..","
	end
	return str
  end
}

tab1 = setmetatable(tab1,metatable)

print(tab1)

输出：
java,C#,C++,lua,

声明：代码部分为原创，部分文字转自

https://www.runoob.com/lua/lua-metatables.html