用惯了python，觉得python真的好写。相比起来lua简直是一坨屎。
拿lua开发的话，面向对象还是必不可少的。虽然网上各种实现都有了，但是用起来都不是特别顺手。
于是来造个轮子，仿照python中的一些语法和使用习惯，写了个class.lua。
直接上代码：

-- utils.lua
string.split = function (fullstring, separator)
    local find_start_index = 1
    local split_index = 1
    local ret = {}
    while true do
        local find_last_index = string.find(fullstring, separator, find_start_index)  
        if not find_last_index then
            ret[split_index] = string.sub(fullstring, find_start_index, string.len(fullstring))  
            break
        end
        ret[split_index] = string.sub(fullstring, find_start_index, find_last_index - 1)
        find_start_index = find_last_index + string.len(separator)
        split_index = split_index + 1
    end
    return ret
end

function rawtostring(t)
    local metatable = getmetatable(t)
    if metatable then
        if metatable.__tostring then
            local tmp = metatable.__tostring
            metatable.__tostring = nil
            local ret = tostring(t)
            metatable.__tostring = tmp
            return ret
        end
    end
    return tostring(t)
end

function topointer(t)
    local ttype = type(t)
    if ttype == "function" or ttype == "table" then
        local strs = rawtostring(t):split(": ")
        return strs[2]
    end
    return nil
end

-- class.lua
require "utils"

local Class = {
    __name__ = "Class",
}
Class.__class__ = Class

local MetaClass = { }

MetaClass.__tostring = function (obj)
    return string.format( "<class \"%s\">", obj.__name__)
end

MetaClass.__call = function (_, name, base)
    local class_type = {
        __class__ = Class,
        __name__ = name,
        __super__ = base,
    }
    local class_object_meta = {
        __index = class_type,
        __tostring = function (obj)
            return string.format( "<%s Object>: %s", obj.__class__.__name__, topointer(obj))
        end
    }
    local class_type_meta = {
        __tostring = function (cls)
            return string.format( "<class \"%s\">: %s", cls.__name__, topointer(cls))
        end,
        __call = function (cls, ...)
            local object = {
                __class__ = class_type
            }
            setmetatable(object, class_object_meta)
            if object.__init__ then
                object.__init__(object, ...)
            end
            return object
        end
    }

    if class_type.__super__ then
        class_type_meta.__index = class_type.__super__
    end

    setmetatable(class_type, class_type_meta)
    return class_type
end

setmetatable(Class, MetaClass)

Class.super = function (class)
    return class.__super__
end

return Class

然后看如何使用：

local class = require "class"
local super = class.super

local Foo = class("Foo")

function Foo:Echo()
    print(self.msg)
end
-- Foo类，无初始化方法，有一个Echo方法

local Bar = class("Bar", Foo)

function Bar:__init__(msg)
    print "Bar Init Call"
    self.msg = msg
end
-- Bar类，继承自Foo，有初始化方法

local Foobar = class("Foobar", Bar)

function Foobar:__init__(msg, count) -- 重写了初始化方法
    super(Foobar).__init__(self, msg)  -- 并且用super方法拿到父类的初始化方法并调用。用过python的应该很熟悉这种用法。
    self.count = count
end

function Foobar:Echo()
    for i=1, self.count do
        super(Foobar).Echo(self)
        -- 另一种写法 self.__super__.Echo(self)
    end
end
-- Foobar类，继承自Bar，重写了初始化方法，和Echo方法

local obj = Foobar("哈哈", 2)
obj:Echo()

print(obj)
print(obj.__class__)
print(obj.__class__.__super__)
print(obj.__class__.__super__.__super__)
print(obj.__super__.__init__)

print(obj.__class__ == Foobar)
print(obj.__super__ == super(Foobar))
print(super(Foobar) == Bar)

输入：
Bar Init Call
哈哈
哈哈
<Foobar Object>: 0000028788634A80
<class "Foobar">: 0000028788635000
<class "Bar">: 00000287886352C0
<class "Foo">: 0000028788635800
function: 000002878682E660
true
true
true

如果用过python的对这个用法应该感到很亲切吧。

然后就是一些拓展性的东西，比如用self.__class__ == T来判断某个obj是否是一个类的实例，用c.__class__ == class来判断一个变量是否是一个Class，也可以利用__super__，实现一个方法issubclass(c, base)来判断某个c是否继承自base，实现isinstance(obj, c)判断obj是否是继承自c的实例。