Lua元表与元方法实例讲解

Lua中提供的元表（metatable）与元方法（metamethod）是一种非常重要的语法，metatable主要用于做一些类似于C++重载操作符式的功能。

Lua中提供的元表是用于帮助lua变量完成某些非预定义功能的个性化行为，如两个table的相加，通过让两者指向同一元表并修改该元表的元方法可以实现该功能。

任何table都可以成为任何值的元表，而一组相关的table也可以共享一个元表。

一些MetaMethod：

复制代码 代码如下:
__add(a, b)                     对应表达式 a + b
__sub(a, b)                     对应表达式 a - b
__mul(a, b)                     对应表达式 a * b
__div(a, b)                     对应表达式 a / b
__mod(a, b)                     对应表达式 a % b
__pow(a, b)                     对应表达式 a ^ b
__unm(a)                        对应表达式 -a
__concat(a, b)                  对应表达式 a .. b
__len(a)                        对应表达式 #a
__eq(a, b)                      对应表达式 a == b
__lt(a, b)                      对应表达式 a < b
__le(a, b)                      对应表达式 a <= b
__index(a, b)                   对应表达式 a.b
__newindex(a, b, c)             对应表达式 a.b = c
__call(a, ...)                  对应表达式 a(...)

1、算术类and关系类元方法

先看一个简单的例子：
复制代码 代码如下:
--我们想让两个分数相加，这是一种非预定义的行为

fraction_a = {numerator=2, denominator=3}
fraction_b = {numerator=4, denominator=7}
fraction_op={}   --元表

-- __add这是metatable，这是lua内建约定的
function fraction_op.__add(a,b)   
  res={}
  res.numerator=a.numerator*b.denominator+b.numerator*a.denominator
  res.denominator=a.denominator*b.denominator
  return res
end

--将fraction_a，fraction_b的元表设置为fraction_op
--其中setmetatable是库函数
setmetatable(fraction_a,fraction_op)
setmetatable(fraction_b,fraction_op)

--调用的是fraction_op.__add()函数
fraction_c=fraction_a+fraction_b
print(fraction_c.numerator.."/"..fraction_c.denominator)
--输出结果
--26/21

再来看一个深度一点的例子，例举了算数类的元方法，关系类的元方法，库定义的元方法。

复制代码 代码如下:
Set={}

local metatable={}  --元表

--根据参数列表中的值创建一个新的集合
function Set.new(a)
   local set={}
   --将所有由该方法创建的集合的元表都指定到metatable
   setmetatable(set,metatable)
   for i,v in pairs(a) do
       set[v]=true
   end
   return set
end

--计算两个集合的并集
function Set.union(a,b)
   local res=Set.new{}
   for i in pairs(a) do
      res[i]=true
   end
   for i in pairs(b) do
      res[i]=true
   end
   return res
end

--计算两个集合的交集
function Set.intersect(a,b)
  local res=Set.new{}
  for i in pairs(a) do
     res[i]=b[i]
  end
  return res
end

--print总是调用tostring来格式化输出
--这里我们稍作修改库定义的print
function Set.tostring(a)
  local t={}
  for i in pairs(a) do
     t[#t+1]=i
  end
  return "{"..table.concat(t,",").."}"
end

--判断a集合是否是b集合的子集
function Set.lessorequal(a,b)
   for i in pairs(a) do
       if  not b[i] then return false end
   end
   return true
end

--最后将重定向的元方法加入到元表中
metatable.__add=Set.union
metatable.__mul=Set.intersect
metatable.__tostring=Set.tostring
metatable.__le=Set.lessorequal
metatable.__eq=function(a,b) return a<=b and b<=a end
metatable.__lt=function(a,b) return a<=b and not (b<=a) end

s1=Set.new{2,9,8,4}
s2=Set.new{2,4,7}
s3=s1+s2
s4=s1*s2
print(s3)
print(s4)
print(3+4,3*4)  --新加的方法不改变表本身具有的方法，因为传入的参数不同，只会让元方法更完善
s5=Set.new{2,4}
s6=Set.new{2,4,6}
print(s5<=s6)
print(s5<s6)
print(s5==s6)
--输出结果
--{2,8,4,9,7}
--{2,4}
--7  12
--true
--true
--false

2、table访问的元方法：

算数类和关系类的元方法都为各自错误情况定义了行为，他们不会改变语言的常规行为，但lua还是提供了一种可以改变table的行为。有两种可以改变table的行为：查询table以及修改table中不存在的字段。

1）、__index元方法

   当访问table中不存在的字段时，得到的结果为nil。如果我们为table定义了元方法__index，那访问的结果将由该方法决定。

复制代码 代码如下:
Window={}
Window.prototype={x=10,y=20,width=100,height=200}
Window.mt={} --Window的元表

function Window.new(o)
  setmetatable(o,Window.mt)
  return o
end

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

w=Window.new{x=1,y=22}
print(w.width)
print(w.width1)
--输出结果
--100
--nil

2）、__newindex元方法

和__index不同的是，该元方法用于不存在键的赋值，而前者用于访问。

复制代码 代码如下:
Window={}
Window.prototype={x=10,y=20,width=100,height=200}
Window.mt={} --Window的元表

function Window.new(o)
  setmetatable(o,Window.mt)
  return o
end

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

w=Window.new{x=1,y=22}
w.length=50
print(w.width)
print(w.width1)
print(Window.prototype.length)
--输出结果
--100
--nil
--50