lua中的面向对象

lua实现面向对象编程是基于元表 metatable，元方法 __index 来实现的。

lua中的语法糖

lua的table中可以定义函数，如下图：

local a = {
    x = 1,
    print = function(obj)
        print("x=" .. obj.x)
    end
}

如上图，定义了一个名叫 a 的table，可以通过调用 a.print(a) 来打印table a 中的 x key对应的value值。

像是 a.print(a) 这种形式，在lua中可以简化为 a:print()，这是lua中的语法糖，使用 : 而不是 .，lua会默认把 “调用者” 给传递进去。

元表 metatable

元表的表现行为类似于操作符重载，比如我们可以重载 __add，来计算两个 Lua 数组的并集；或者重载 __tostring，来定义转换为字符串的函数。

Lua 提供了两个处理元表的函数：

• setmetatable(table, metatable), 用于为一个 table 设置元表
• getmetatable(table)，用于获取 table 的元表

比如：

local version = { major = 1, minor = 1, patch = 1 }
version = setmetatable(version, 
    { 
        __tostring = function(t) 
            return string.format("%d.%d.%d", t.major, t.minor, t.patch) 
        end 
    }) 
print(tostring(version))        -- 1.1.1

这段代码的作用就是重载了 version 表的 tostring() 方法，如果不重载的话，直接调用默认方法，那么打印结果是：

local version = { major = 1, minor = 1, patch = 1 }
print(tostring(version))        -- table: 0x000647a8

元方法: __index

我们在 table 中查找一个元素时，首先会直接从 table 中查询，如果没有找到，就继续到元表的 __index 中查询。

local version = { major = 1, minor = 1}
version = setmetatable(version, 
    { 
        __index = function(t, key) 
            if key == "patch" then 
                return 2 
            end 
        end,
        __tostring = function(t) 
            return string.format("%d.%d.%d", t.major, t.minor, t.patch) 
        end 
    }) 
print(tostring(version))        -- 1.1.2

这样当 t.patch 取不到值时，就会去 __index 中进行查找。

__index 不仅可以是一个函数，也可以是一个table。

local version = { major = 1, minor = 1}
version = setmetatable(version, 
    { 
        __index = { patch=3 },
        __tostring = function(t) 
            return string.format("%d.%d.%d", t.major, t.minor, t.patch) 
        end 
    }
) 
print(tostring(version))        -- 1.1.3

上面的代码可以变换为如下形式：

local version = { major = 1, minor = 1}
local mt = {
    __index = { 
        patch=3 
    },
    __tostring = function(t) 
        return string.format("%d.%d.%d", t.major, t.minor, t.patch) 
    end
}
version = setmetatable(version, mt) 
print(tostring(version))        -- 1.1.3

元方法：__call

使用 __call 可以让 table 被调用。

local version = { major = 1, minor = 1, patch = 1 }
local function print_version(t)             
    print(string.format("%d.%d.%d", t.major, t.minor, t.patch))
end
version = setmetatable(version, 
    {
        __call = print_version
    }
) 

version()       -- 1.1.1

面向对象

lua-resty-mysql 是OpenResty 官方的 MySQL 客户端，里面就使用元表模拟了类和类方法，它的使用方式如下所示：

local mysql = require "resty.mysql"     -- 先引用 lua-resty 库
local db, err = mysql:new()     -- 新建一个类的实例
db:set_timeout(1000)    -- 调用类的方法

那么lua-resty-mysql的源码是如何实现的呢？

local _M = { _VERSION = '0.21' } -- 使用 table 模拟类
local mt = { __index = _M } -- mt 即 metatable 的缩写，__index 指向类自身

-- 类的构造函数
function _M.new(self) 
    local sock, err = tcp() 
    if not sock then 
        return nil, err 
    end 
    return setmetatable({ sock = sock }, mt) -- 使用 table 和 metatable 模拟类的实例
end 

-- 类的成员函数 
function _M.set_timeout(self, timeout) 
    -- 使用 self 参数，获取要操作的类的实例 
    local sock = self.sock 
    if not sock then 
        return nil, "not initialized" 
    end 
    return sock:settimeout(timeout)
end

上面的代码中，-M 这个table代表的就是mysql类，_M.new(self) 方法中返回一个 setmetatable({ sock = sock }, mt) 就是返回一个类的对象，socket 这个属性就是这个对象的成员属性，而不是类的属性。