Question

我有一张这样的表

local ftable = {
  getPinId = app.getPinId
}

将ftable传递给另一个将其作为RPC接口导出的函数。这有效但现在我想将函数调用跟踪添加到日志文件中。

简单的方法是

local ftable = {
  getPinId = function(...) print("getPinId") app.getPinId(...) end
}

但是，这不是特别好。我想提出类似的内容：

local trace = function(func, ...)
   return function(...) print(func) func(...) end
end

local ftable = {
  getPinId = trace(app.getPinId)
}

但这并没有产生相当理想的结果。参数未通过。

另一个选择是使用这样的元表：

local ftable = {}
setmetatable(ftable, { 
  __index = function(_, k) 
  printf("Call: app.%s\n", k) return app[k] end 
})

哪个有效。但我也希望能够打印出通过的参数。

有什么建议吗？如果这有任何区别，我会专门使用luajit。

Answer 1

Lua很容易包装函数调用：

local function wrap( f )
  local function after( ... )
    -- code to execute *after* function call to f
    print( "return values:", ... )
    return ...
  end
  return function( ... )
    -- code to execute *before* function call to f
    print( "arguments:", ... )
    return after( f( ... ) )
  end
end


local function f( a, b, c )
  return a+b, c-a
end

local f_wrapped = wrap( f )
f_wrapped( 1, 2, 3 )

输出是：

arguments:  1   2   3
return values:  3   2

记录/跟踪的一个问题是Lua值（包括函数）本身没有名称。调试库试图通过检查函数的调用方式或存储位置来查找函数的合适名称，但如果要确定，则必须自己提供名称。但是，如果您的函数存储在（嵌套）表中（如注释中所示），您可以编写一个迭代嵌套表的函数，并使用表键将它找到的所有函数包装为名称：

local function trace( name, value )
  local t = type( value )
  if t == "function" then -- do the wrapping
    local function after( ... )
      print( name.." returns:", ... )
      return ...
    end
    return function( ... )
      print( "calling "..name..":", ... )
      return after( value( ... ) )
    end
  elseif t == "table" then -- recurse into subtables
    local copy = nil
    for k,v in pairs( value ) do
      local nv = trace( name.."."..tostring( k ), v )
      if nv ~= v then
        copy = copy or setmetatable( {}, { __index = value } )
        copy[ k ] = nv
      end
    end
    return copy or value
  else -- other values are ignored (returned as is)
    return value
  end
end


local ftable = {
  getPinId = function( ... ) return "x", ... end,
  nested = {
    getPinId = function( ... ) return "y", ... end
  }
}

local ftableTraced = trace( "ftable", ftable )
ftableTraced.getPinId( 1, 2, 3 )
ftableTraced.nested.getPinId( 2, 3, 4 )

输出是：

calling ftable.getPinId:    1   2   3
ftable.getPinId returns:    x   1   2   3
calling ftable.nested.getPinId: 2   3   4
ftable.nested.getPinId returns: y   2   3   4

有些事情需要注意：

表键可以是任意Lua值，而不仅仅是完全由可打印字符组成的短字符串。
表可以包含循环引用。如果他们这样做，上面的天真实现将因堆栈溢出而死亡。

Answer 2

改为使用__call元方法：

M = { __call =
    function (t,...) print("calling ",t.name,...) return t.func(...) end
}

trace = function(func,name)
    return setmetatable({func=func,name=name},M)
end

function f(...)
    print("in f",...)
end

g=trace(f,"f")
g(10,20,30)

如何实现表到函数的跟踪函数？

2 个答案: