6

我相当确定在 Lua 中，您可以使用给定的元表__index, __newindex, 并__call大致复制 Ruby 的method_missing. 我有点：

function method_missing(selfs, func)

    local meta = getmetatable(selfs)
    local f
    if meta then
        f = meta.__index
    else
        meta = {}
        f = rawget
    end
    meta.__index = function(self, name)
        local v = f(self, name)
        if v then
            return v
        end

        local metahack = {
            __call = function(self, ...)
                return func(selfs, name, ...)
            end
        }
        return setmetatable({}, metahack)
    end

    setmetatable(selfs, meta)
end

_G:method_missing(function(self, name, ...)
    if name=="test_print" then
        print("Oh my lord, it's method missing!", ...)
    end
end)

test_print("I like me some method_missing abuse!")

print(this_should_be_nil)

我的问题是：虽然语法相似，我当然可以使用它来复制功能，但它引入了一个破坏性错误。您在应用 a 的表的上下文中使用的每一个变量method_missing都永远不会为零，因为我必须返回一个可以调用的对象，以便pass the buck从索引函数到实际调用的潜在调用。

即如上所述定义全局method_missing后，尝试调用未定义的方法'test_print'按预期运行，但索引时test_print的值是非nil，其他没有响应的方法/变量，如this_should_be_nil非nil .

那么有没有可能避免这个陷阱呢？或者在不修改语言源本身的情况下可以不弯曲语法来支持这种修改吗？我想困难出现在 Ruby 中，索引和调用是相似的，而在 Lua 中它们是不同的。

4

3 回答 3

3

nil您可以通过使值可调用来避免此问题。
不幸的是，这只能从宿主代码（即C 程序）中完成，而不能从Lua 脚本中完成。

帕斯卡代码： 

function set_metatable_for_any_value_function(L: Plua_State): Integer; cdecl;
begin   // set_metatable_for_any_value(any_value, mt)
   lua_setmetatable(L, -2);
   Result := 0;
end;

procedure Test_Proc;
   var
      L: Plua_State;
   const
      Script =
'set_metatable_for_any_value(nil,                                        ' +
' {                                                                      ' +
'   __call = function()                                                  ' +
'              print "This method is under construction"                 ' +
'            end                                                         ' +
' }                                                                      ' +
')                                                                       ' +
'print(nonexisting_method == nil)                                        ' +
'nonexisting_method()                                                    ';
begin
   L := luaL_newstate;
   luaL_openlibs(L);
   lua_pushcfunction(L, lua_CFunction(@set_metatable_for_any_value_function));
   lua_setglobal(L, 'set_metatable_for_any_value');
   luaL_dostring(L, Script);
   lua_close(L);
end;

输出：

true
This method is under construction
于 2013-11-04T22:57:05.323 回答
2

您已经很好地确定了问题：据我所知，在纯 Lua 中解决该问题是不可能的。

编辑：我错了，你可以通过nil调用。查看其他答案。IMO 仍然是个坏主意。的主要用例method_missing是代理对象，您可以通过另一种方式解决这个问题。method_missing在Kernel（Ruby）/ _G（Lua）上很糟糕:)

您可以做的只是处理一些方法，例如，如果您知道您希望方法以以下方式开头test_：

local function is_handled(method_name)
    return method_name:sub(1,5) == "test_"
end

function method_missing(selfs, func)

    local meta = getmetatable(selfs)
    local f
    if meta then
        f = meta.__index
    else
        meta = {}
        f = rawget
    end
    meta.__index = function(self, name)
        local v = f(self, name)
        if v then
            return v
        end

        if is_handled(name) then
            local metahack = {
                __call = function(self, ...)
                    return func(selfs, name, ...)
                end
            }
            return setmetatable({}, metahack)
        end
    end

    setmetatable(selfs, meta)
end

_G:method_missing(function(self, name, ...)
    if name=="test_print" then
        print("Oh my lord, it's method missing!", ...)
    end
end)

test_print("I like me some method_missing abuse!")

print(this_should_be_nil)

现在也许问题应该是：你为什么要复制method_missing，你能避免它吗？即使在 Ruby 中，也建议尽可能避免使用动态方法生成，method_missing并且更喜欢动态方法生成。

于 2013-11-04T22:28:48.700 回答
1

因此，根据@lhf 的提示，我管理了一个可以通过的双倍（据我所知）method_missing。最后，我开发了以下内容：

local field = '__method__missing'

function method_missing(selfs, func)

    local meta = getmetatable(selfs)
    local f
    if meta then
        f = meta.__index
    else
        meta = {}
        f = rawget
    end
    meta.__index = function(self, name)
        local v = f(self, name)
        if v then
            return v
        end

        rawget(self, name)[field] = function(...)
            return func(self, name, ...)
        end
    end

    setmetatable(selfs, meta)
end

debug.setmetatable(nil, { __call = function(self, ...) 
    if self[field] then
        return self[field](...)
    end
    return nil
end, __index = function(self, name) 
    if name~=field then error("attempt to index a nil value") end
    return getmetatable(self)[field]
end, __newindex = function(self, name, value)
    if name~=field then error("attempt to index a nil value") end
    getmetatable(self)[field] = value
end} )

_G:method_missing(function(self, name, ...)
    local args = {...}
    if name=="test_print" then
        print("Oh my lord, it's method missing!", ...)
        return
    elseif args[1] and string.find(name, args[1]) then --If the first argument is in the name called... 
        table.remove(args, 1)
        return unpack(args)
    end
end)

test_print("I like me some method_missing abuse!")
test_print("Do it again!")

print(test_print, "method_missing magic!")
print(this_should_be_nil == nil, this_should_be_nil() == nil)

print(conditional_runs("runs", "conditionally", "due to args"))
print(conditional_runs("While this does nothing!")) --Apparently this doesn't print 'nil'... why?

输出：

Oh my lord, it's method missing!        I like me some method_missing abuse!
Oh my lord, it's method missing!        Do it again!
nil     method_missing magic!
true    true
conditionally   due to args

这个片段让您可以使用method_missing与在 Ruby 中的使用方式非常相似的方式（尽管没有任何响应检查）。这与我最初的反应相似，只是它通过 nil 的元表“推卸责任”，这是我认为我做不到的。（感谢您的提示！）但正如@greatwolf 所说，可能没有理由在 Lua 中使用这样的构造；通过更清晰的元方法操作可能可以实现相同的活力。

于 2013-11-05T04:24:02.717 回答