Question

我需要绕道各种各样的功能，一个接一个地做它不是一个选择。我正在寻找一个理想情况下需要一个表的函数，这个表是类。循环遍历它，对于每个键，作为函数的值对使得函数指针在原始函数名之前具有前缀。我已经尝试了几种变体来实现这种效果，但它们都会产生不同的问题。不管你给他们什么，有些人根本不会做迂回指针，有些人会绕道而行，但他们不能工作，有些人会溢出堆栈或根本无法识别。

我想知道是否有一种方法，即rawsets，metatable覆盖，常量循环，直到它们匹配等为止，使得函数可以得到一个表（或一个与表名相同的字符串，因此，loadtring方法也可以在这里工作）并循环遍历每个函数并创建一个工作的绕行指针......无论如何。

我更喜欢使用self：prefix_orig_name（...）语法[...可以用实际的args替换]。

以下是我尝试使用示例用法的两种变体。

-- 1st Method
detours = detours or {}

function detour(object, class) -- Class is an extra arg that I would send if for some reason just sending an object didn't work...it was theory oh'ed
    if detours[object] then -- Check if the detour already exists...might be worth remaking it especially if the function gets overridden several times in different places?
        print("detour: Previous " .. object .. " detour found, using previous detour")
        return
    end
    for name, func in pairs(class and class or loadstring("return " .. object)()) do
        -- the loadstring method here is used because the argument received is a string of the same name as the table...thus loading it will yield a table
        if type(func) == "function" then
            local execute, error = loadstring(object .. ".custom_detour_" .. name .. " = " .. object .. "." .. name) -- This makes the actual pointer
            if error then
                print("detour Error: " .. " Failed to detour: " .. object .. " Error: " .. error)
            end
            local luanch, assert = pcall(execute)
            if not luanch then
                print("detour Error: " .. " Failed to detour: " .. object .. " Error: " .. assert)
            end
        end
    end
    print("Table: " .. object .. " successfully detourd")
    detours[object] = true -- tells us we made a detour of this table/string
end

-- 2nd Method
function detour(object) -- Takes a table
    for k, v in pairs(object) do
        if type(v) == "function" and not detours[k] then
            if not object.custom_detour_ then
                object.custom_detour_ = clone(object) -- use a simple cloning function (shallow) to put a clone of the main table into a sub table of the main table
            end
            if object["custom_detour_" .. k] ~= object.custom_detour_[k] then
                object["custom_detour_" .. k] = object.custom_detour_[k] -- this makes it so the self:custom_detour_orig_name(...) syntax can be used, if I am not mistaken
            end
        end
    end
end

-- Example Usage:
MyClass = class() -- class function is relatively OOP standard

function MyClass:init()
    self._something = true
end

function MyClass:change(value)
    self._something = value
end

function MyClass:table_print(tbl) -- just making funcs up
    for k, v in pairs(tbl) do
        print(v)
    end
end

my_class = MyClass:new()

-- 1st Method
detour("MyClass")

--2nd Method
detour(MyClass)

我个人更喜欢第一种方法或者至少是一个字符串，因为我可以记录每次绕道，如果以后出现问题，它会使调试变得更容易......但我会为任何工作而努力。

Answer 1

简单的迂回易于使用闭合;不需要loadstring：

function detour(cls)
    local detours = {}
    for key, value in pairs(cls) do
        if type(value) == "function" then -- note: ignores objects with __call metamethod
            detours["custom_detour_"..key] = function(...)
                -- Do whatever you want here
                return value(...)
            end
        end
    end
    for key, value in pairs(detours) do
        cls[key] = value
    end
end

Lua - 创造弯路的功能

1 个答案: