一、元表、元方法

元表：metatable
元方法：metamethod
自定义table的行为，如table加法操作。

元表metatable

  2. t, t1, t2 = {}, {}, {}
  3. print(getmetatable(t))                    --> nil，获取元表
  4. setmetatable(t, t2)                            --> t设置元表为t2，任何表都可以是其他表的元表
  5. setmetatable(t1, t2)                        --> t、t1共享元表t2，类似父类，描述共同行为
  6. setmetatable(t2, t2)                        --> 元表是自己，描述私有行为

元方法（关系运算符）

  1. local mt = {
  3.   -- 隐藏Set的元表，无法被外部getmetatable或者setmetatable
  4.   -- getmetatable时，返回__metatable值
  5.   -- setmetatable时，报错
  6.   __metatable = "not your business"
  8. ----------------关系运算符的元方法----------------
  9.   -- 只有下面三种：小于和等于的组合排列。为什么？见下面解释。
  11.   __lt             = function(a, b) end    -- a < b 时触发，类型不同会报错
  12.   __eq             = function(a, b) end    -- a == b时触发，必须有相同的元表，否则不会触发
  13.   __le            = function(a, b) end    -- a <= b时触发，类型不同会报错
  15.   --其他关系运算可被等价转换为上面的运算
  16.   --a > b     等价于 b < a，有人说这不废话嘛，但实际触发的元方法就不一样了。
  17.   --a >= b    等价于    b <= a
  18.   --a ~= b    等价于    not(a == b)
  19.   --！！注意a>b不等价于not(a<=b)，偏序的时候，a>b和a<=b都可能不成立，比如两个不相见交的集合。
  20.   --综上原因，三个足矣。
  21. }
  23. ----------------关系运算符定义技巧----------------
  24. -- a < b     转换为：a <= b and not(b <= a)
  25. -- a == b 转换为：a <=b and b <=a
  26. -- 这样唯一需要定义的就是__le元方法。
  27. mt.__le = function (a,b)    -- set containment
  28.     for k in pairs(a) do
  29.         if not b[k] then return false end
  30.     end
  31.     return true
  32. end
  34. mt.__lt = function (a,b)
  35.     return a <= b and not (b <= a)
  36. end
  38. mt.__eq = function (a,b)
  39.     return a <= b and b <= a
  40. end

元方法（算术运算符）

  1. local mt = {
  2. ----------------算术运算符的元方法----------------
  3.   -- Lua选择metamethod的过程：
  4.   -- a + b时，先看a有没有，再看b有没有，如果都没有就报错。
  5.   __add         = function(a, b) end    -- a + b时触发
  6.   __mul         = function(a, b) end    -- a * b时触发
  7.   __sub         = function(a, b) end    -- a - b时触发
  8.   __div            = function(a, b) end    -- a / b时触发
  9.   __unm         = function(a)      end    -- -a   时触发
  10.   __pow         = function(a, b) end    -- a^b  时触发
  11.   __concat    = function(a, b) end    -- a..b 时触发
  12. }

元方法（lua库定义）

  1. local mt = {
  2. ----------------lua库定义的元方法----------------
  3.      __tostring    = function(a)         end -- print(a)时触发，print触发a.tostring
  5.   __index         = function(a, b) end -- a.b，b不是a的域时触发，实现继承
  7.   __index         = parent                         -- 同上，a.b等价于parent.b，这里也可能再触发__index
  8.                                                                    --rawset(a,b) 等价于a[b]，不触发__index
  10.   __newindex     = function(a, b) end --a.b = 1，b不是a的域时触发
  12.   __newindex     = parent                         --同上，a.b=1 等价于 parent.b=1
  13.                                                                    --rawset(t,k,v)等价于t[k]=v，不触发__newindex
  14. }

有默认值的表

  1. local key = {}    -- lua技巧，空表是唯一key的绝佳选择，任意创建的两个空表都不相等。
  2. local mt = {__index = function (t) return t[key] end}
  3. function setDefault (t, d)
  4.     t[key] = d
  5.     setmetatable(t, mt)
  6. end

监控表

为表添加一个中间代理(空表)即可。

  1. -------------监控表使用-------------
  2. local test = {}
  3. test = track(test)        --对test域的访问和赋值都将被监控
  5. -------------监控表实现-------------
  6. -- 为表设置代理proxy，对proxy的访问就是对表的访问。
  7. -- proxy一直为空，即可监控所有访问和赋值
  8. -- 触发的元方法，又实际操作的是表的值
  10. local index = {}        -- 唯一key
  12. local mt = {
  13.     __index = function (t,k)                --监控域访问
  14.         return t[index][k]
  15.     end
  16.     __newindex = function (t,k,v)        --监控域赋值
  17.         t[index][k] = v
  18.     end
  19. }
  21. function track (t)        --为t返回一个代理：空表。
  22.     local proxy = {}
  23.     proxy[index] = t
  24.     setmetatable(proxy, mt)
  25.     return proxy
  26. end

只读表

同监控表原理。

  1. -------------只读表使用-------------
  2. days = readOnly{"Sunday", "Monday", "Tuesday", "Wednesday","Thursday", "Friday", "Saturday"}
  3. print(days[1])        --> Sunday
  4. days[2] = "Noday" --> 报错：stdin:1: attempt to update a read-only table
  6. -------------只读表实现-------------
  7. function readOnly (t)
  8.     local proxy = {}    --中间代理
  9.     local mt = {
  10.         __index = t,
  11.         __newindex = function (t,k,v)
  12.             error("attempt to update a read-only table", 2)
  13.         end
  14.     }
  15.     setmetatable(proxy, mt)
  16.     return proxy
  17. end

二、面向对象设计

  1. Account = { a = "100" }
  3. function Account.fuck(self, b)
  4.   print(b)
  5. end
  6. function Account:go()
  7.   print(self.a)
  8. end
  10. Account.fuck(100)    --> 100
  11. Account.go()            --> 100

继承

元方法__index = table实现。这样的话只能指定一个table（父类）

  1. Account = {balance = 0}
  3. function Account:new (o)
  4.     o = o or {}
  5.     setmetatable(o, self)
  6.     self.__index = self
  7.     return o
  8. end
  10. function Account:deposit (v)
  11.     self.balance = self.balance + v
  12. end
  14. function Account:withdraw (v)
  15.     if v > self.balance then error"insufficient funds" end
  16.     self.balance = self.balance - v
  17. end

多重继承

元方法__index = function，通过函数可以返回不同的table父类，达到多父类继承。

  1. -- look up for `k' in list of tables 'plist'
  2. local function search (k, plist)
  3.     for i=1, table.getn(plist) do
  4.         local v = plist[i][k]    -- try 'i'-th superclass
  5.         if v then return v end
  6.     end
  7. end
  9. function createClass (...)
  10.     local c = {}        -- new class
  12.     -- class will search for each method in the list of its
  13.     -- parents (`arg' is the list of parents)
  14.     setmetatable(c, {__index = function (t, k)
  15.     return search(k, arg)
  16. end})
  18. -- prepare `c' to be the metatable of its instances
  19. c.__index = c
  21. -- define a new constructor for this new class
  22. function c:new (o)
  23.     o = o or {}
  24.     setmetatable(o, c)
  25.     return o
  26. end
  28. -- return new class
  29.     return c
  30. end

成员私有

把对象拆分成：数据 + 操作。利用闭包，只需提供操作接口，即可调用数据。

  1. function newAccount (initialBalance)
  2.     local self = {balance = initialBalance}
  3.     local withdraw = function (v)            --闭包，操作接口
  4.         self.balance = self.balance - v
  5.     end
  7.     local deposit = function (v)            --闭包，操作接口
  8.         self.balance = self.balance + v
  9.     end
  11.     local getBalance = function () return self.balance end
  13.     return {
  14.         withdraw = withdraw,
  15.         deposit = deposit,
  16.         getBalance = getBalance
  17.     }
  18. end

单例

  1. function newObject (value)
  2.     return function (action, v)
  3.         if action == "get" then return value
  4.         elseif action == "set" then value = v
  5.         else error("invalid action")
  6.         end
  7.     end
  8. end
  9. 使用起来很简单：
  10. d = newObject(0)
  11. print(d("get"))        --> 0
  12. d("set", 10)
  13. print(d("get"))        --> 10

实战代码

  2. local LayerInGame = class("LayerInGame", function() return display.newLayer() end)
  3. -- 或者
  4. local LayerInGame = class("LayerInGame", cc.Layer)
  7. -- classname类名，...父类
  8. function class(classname, ...)
  9.     local cls = { __cname = classname }
  10.     -- 所有的父类
  11.     local supers = { ...}
  12.     -- 遍历所有的父类，将父类的特性附加给cls
  13.     for _, super in ipairs(supers) do
  14.         local superType = type(super)
  15.         -- 父类必须是nil或者table或者function
  16.         assert(superType == "nil" or superType == "table" or superType == "function",
  17.         string.format("class() - create class \"%s\" with invalid super class type \"%s\"",
  18.         classname, superType))
  19.         -- 父类如果是函数
  20.         if superType == "function" then
  21.             -- __create创建函数不能重复
  22.             assert(cls.__create == nil,
  23.             string.format("class() - create class \"%s\" with more than one creating function",
  24.             classname));
  25.             -- if super is function, set it to __create
  26.             -- 直接将函数赋值给创建函数
  27.             cls.__create = super
  28.         elseif superType == "table" then
  29.             if super[".isclass"] then
  30.                 -- 父类是一个cocos2dx的类，node，layer，sprite
  31.                 assert(cls.__create == nil,
  32.                 string.format("class() - create class \"%s\" with more than one creating function or native class",
  33.                 classname));
  34.                 -- 将父类的构建函数赋值给自己
  35.                 cls.__create = function() return super:create() end
  36.             else
  37.                 -- 一个普通的Lua table
  38.                 -- 将所有的Lua table型父类保存在__supers中
  39.                 cls.__supers = cls.__supers or { }
  40.                 cls.__supers[#cls.__supers + 1] = super
  41.                 -- 只将第一个父类赋值给super
  42.                 if not cls.super then
  43.                     -- set first super pure lua class as class.super
  44.                     cls.super = super
  45.                 end
  46.             end
  47.         else
  48.             error(string.format("class() - create class \"%s\" with invalid super type",
  49.             classname), 0)
  50.         end
  51.     end
  52.     -- 上面是解决了创建的问题，下面解决访问的问题
  53.     -- __index使得cls具备父类的属性
  54.     cls.__index = cls
  55.     if not cls.__supers or #cls.__supers == 1 then
  56.         -- 父类是普通的Luatable
  57.         setmetatable(cls, { __index = cls.super })
  58.     else
  59.         -- 遍历super一次访问父类的域，找到为止
  60.         setmetatable(cls, {
  61.             __index = function(_, key)
  62.                 local supers = cls.__supers
  63.                 for i = 1, #supers do
  64.                     local super = supers[i]
  65.                     if super[key] then return super[key] end
  66.                 end
  67.             end
  68.         } )
  69.     end
  71.     -- 默认构造函数
  72.     if not cls.ctor then
  73.         cls.ctor = function() end
  74.     end
  75.     -- 创建cls，并调用默认构造函数
  76.     cls.new = function(...)
  77.         local instance
  78.         if cls.__create then
  79.             instance = cls.__create(...)
  80.         else
  81.             instance = { }
  82.         end
  83.         setmetatableindex(instance, cls)
  84.         instance.class = cls
  85.         instance:ctor(...)
  86.         return instance
  87.     end
  88.     -- 另一种构造函数
  89.     cls.create = function(_, ...)
  90.         return cls.new(...)
  91.     end
  93.     return cls
  94. end