定义函数与 function.prototype 的属性

Question

tl;dr In case you are familiar with how javascript works, skip to the "question" part.

I come from javascript, where we use the prototype chaining to define our "class" methods such as:

function MyClass(){
    return this
}
MyClass.prototype.method = function(){
    // do stuff
}
MyClass.directPropFunction = function(){
    // do direct stuff
}

MyClass.method()                    // doesn't work
MyClass.directPropFunction()        // works
new MyClass()                       // instantiates an object from said "class"
new MyClass().method()              // now it works!
new MyClass().directPropFunction()  // however now no longer works.

In other words, defining direct properties on function could be considered static methods, where as defining properties on the prototype can be considered regular methods. All this rides on the fact that we "fake" classes by using functions as constructors for objects which we then access and use their prototype chains to do magic stuff.

One important thing to note is that even the .method that is declared on the prototype is not created for each instance of the object. Does LUA have a "proper" way to extend function objects?

Question:

I have been fiddling around with LUA a bit and have come across this: I got to ask, since I do not know how it works internally, what is the difference and what is the preferred way of doing things? Also, I am not sure if LUA has the whole "faking" classes, but I wouldn't use it anyway probably, so which of the methods shown bellow is the "correct" way to do things?

function Foo()
    -- do stuff
end
Foo.method = function()
    -- do stuff
end
Foo.prototype.protoMethod = function()
    -- do stuff
end

What I want to achieve is have the following:

function doSomething()
    -- does something, duh
    -- return uniqueID
end
doSomething.revert = function(uniqueID)
    -- reverts stuff
end

and then I would be able to do both:

local a = doSomething()
doSomething.revert(a)

so what is the right approach?

Answer 1

Consider this exercise:

local function reversible (func)
    local states = {}
    states [func] = states [func] or {}
    return function (...)
        local result = func (...)
        states [func] [result] = {...}
        return result
    end, function (result)
        return unpack (states [func] [result])
    end
end

local square, root = reversible (function (a)
    return a ^ 2
end)

local initial = -2
local squared = square (initial)
local reversed = root (squared)

io.write ('initial = ' .. tostring (initial) .. ', squared = ' .. tostring (squared) .. ', reversed = ' .. tostring (reversed) .. '\n')

Of course, in this example, the "state" that is restored consists of only function arguments; so that func has to be pure. It is assumed that the original function returns only obe value (if more, states should be indexed with hashes of func results packed into a table).

Unlike JavaScript, in Lua functions do not have properties, and objects have no prototypes. However, Lua tables have metatables .

Also, function properties can be emulated by table fields, if the table's metatable has a field __call , which is used when a table is called like a function. The example below imprements the pseudo-property revert and also allows multiple returns for the original finction:

local function hash (array)
    return table.concat (array, ',')
end

local function reversible (func)
    local states = {}
    states [func] = states [func] or {}
    local wrapped = {
        revert = function (...)
            return unpack (states [func] [hash {...}])
        end
    }
    setmetatable (wrapped, {
        __call = function (tbl, ...)
            local results = {func (...)}
            states [func] [hash (results)] = {...}
            return unpack (results)
        end
    })
    return wrapped
end

local square = reversible (function (a)
    return a ^ 2
end)

print ('square (-2)', square (-2))
print ('square.revert (4)', square.revert (4))