Question

我有一个包含多个功能的表。我正在尝试编写一个单独的函数，通过将随机信息传递给它来使用所有函数。

方法= {}

将函数插入方法表

函数方法：Multi（）if #self＆gt; 0   然后.........................

我猜我需要一个遍历整个表的循环，但我不能做#self因为我需要它多次执行每个函数。不知道如何将随机信息传递给函数。任何帮助将不胜感激

Answer 1

您的问题似乎并不是那么具体 - 您可能需要更详细地定义您想要发生的事情，以便能够为其实现程序。（有点像你告诉我“我需要一个计算数字的程序” - 我可能会回答“好吧，你想要它计算什么数字？”

需要考虑的事项：

您想要多少次调用每个函数？每个功能都是一样的吗？它会变化吗？
如果通话次数有所不同，应该决定什么？
您究竟想确定传递的参数是什么？他们的类型/数量？他们的价值观？

一个非常基本的起始框架可能如下所示：

Methods = {}

-- Insert functions into Methods table

for _,func in ipairs(Methods) do
    for i=1,5 do
        func()
    end
end

将调用每个函数5次，尽管没有参数。

Answer 2

试试这个：

function CallFuncs(times, funcs, ...)
    for i=1,times do
        for _, func in pairs(funcs) do
            if type(...) == "table" then func(unpack(...)) else func(...) end
        end
    end
end

用法：

local t = {
    function(n) print(n) end,
    function(n) print(n+1) end,
    function(n) print(n+2) end
}

CallFuncs(3, t, 2)

这假设表中的所有函数都有或多或少相同的参数。

的信息：你看到的...是lua的变量参数语法（这些被打包到一个表中并用作函数的最后一个参数），unpack函数接受一个表并多次返回一系列值。

Answer 3

我将上述建议修改为

function CallFuncs(times, funcs, ...)
    while (times > 0) do
        for _, func in pairs(funcs) do
            func(...)
        end
        times = times - 1
    end
end

使用示例：

t = {
    function( n ) print( n ) end,
    function( n ) print( #n ) end,
}

CallFuncs( 2, t, 'foo' )

产量

foo
3
foo
3

Answer 4

如果您要求调用功能列表，我只需为您输入这个非常小的模块（如果您甚至可以调用它）。

-- No guarantees whether this will work.
function ExecFunc (fnctn,nTimes,Threaded,...)
    local to_call = function ()
        fnctn(...)
    end
    for x = 1,nTimes do
        if Threaded then
            coroutine.resume(coroutine.create(to_call))
        else
            to_call()
        end
    end
end
function ExecFuncs (Async,...)
    -- All parts of ... should be tables {function f, number t[, table args]}
    local funcInfo = {...}
    for _,funcThing in pairs(funcInfo) do
        local a = funcThing.args
        if a then
            ExecFunc(funcThing.f,funcThing.t,Async,unpack(a))
        else
            ExecFunc(funcThing.f,funcThing.t,Async)
        end
    end
end
-- These don't check for argument validity,
-- so you should either be careful with the arguments
-- or call these in protected mode (with pcall).

如果我浪费了我的时间，那无论如何都很有趣，但在输入之后我重读了你的问题......你想要一些东西来迭代一个函数列表并将随机数传递给每个函数。

function ExecuteWithRandomValues (func_list,async)
    assert(type(func_list) == "table","Expected table.")
    local passbacks = {}
    local threads
    if async then
        threads = {}
    end
    for _,func in pairs(func_list) do
        assert(type(func) == "function","Value [" .. _ .. "] is not a function.")
        local toCall = function ()
            local rnd = math.random(-math.huge,math.huge)
            local out = func(rnd)
            passbacks[_] = {input = rnd, output = out}
        end
        if async then
            table.insert(threads,coroutine.create(toCall))
        else
            toCall()
        end
    end
    if async then
        for _,thread in pairs(threads) do
            coroutine.resume(thread)
        end
        for _,thread in pairs(threads) do
            while coroutine.status(thread) ~= "dead" do
            end
        end
    end
    return passbacks
end
-- Again, no guarantees this thing is free of errors.
-- There are better ways to run and check the statuses
-- of asynchronous threads, but this is fairly convenient.

表中的函数 - Lua

4 个答案: