问 获取lua中函数的参数名称

EN

不能说是 PrintVariable(MyVariable) ，因为Lua无法确定使用哪个变量(如果有的话；可以使用常量)将参数传递给您的函数。但是，您可以说， PrintVariable('MyVariable') 然后使用调试API在调用者的作用域中查找具有该名称的局部变量：

function PrintVariable(name)
  -- default to showing the global with that name, if any
  local value = _G[name]
  -- see if we can find a local in the caller's scope with that name
  for i=1,math.huge do
    local localname, localvalue = debug.getlocal(2,i,1)
    if not localname then
      break -- no more locals to check
    elseif localname == name then
      value = localvalue
  if value then
    print(string.format("%s = %s", name, tostring(value)))
    print(string.format("No variable named '%s' found.", name))
end

现在你可以说：

PrintVariable('MyVariable')

在本例中，将打印"MyVariable = 4“。

不是，如果您真的想在没有引号的情况下这样做，您可以检查调用者的局部变量是否有提供的值，但如果调用者的作用域中有多个变量具有给定的值，这偶尔会给出一个错误的变量名。这么说吧，你怎么做到的：

function PrintVariable(value)
  local name
  -- see if we can find a local in the caller's scope with the given value
  for i=1,math.huge do
    local localname, localvalue = debug.getlocal(2,i,1)
    if not localname then
      break
    elseif localvalue == value then
      name = localname
  -- if we couldn't find a local, check globals
  if not name then
    for globalname, globalvalue in pairs(_G) do
      if globalvalue == value then
        name = globalname
  if name then
    print(string.format("%s = %s", name, tostring(value)))
    print(string.format("No variable found for the value '%s'.", tostring(value)))
end

现在您可以说是 PrintVariable(MyVariable) 了，但是如果调用者的作用域中碰巧有另一个变量 4 值，并且发生在 MyVariable 之前，那么就会打印变量名。

我有个坏消息我的朋友。您可以访问函数参数名，因为它们出现在函数的顶部，但是访问调用函数中它们的确切名称的数据并不存在。见以下内容：

function PrintVariable(VariableToPrint)
  --we can use debug.getinfo() to determine the name 'VariableToPrint'
  --we cannot determine the name 'MyVariable' without some really convoluted stuff (see comment by VBRonPaulFan on his own answer)
  print(VariableToPrint);
MyVariable = 4
PrintVariable(MyVariable)

为了说明这一点，想象一下如果我们做了：

x = 4
MyVariable = x
MyOtherVariable = x
x = nil
PrintVariable(MyVariable)

现在，如果您是Lua，您会在元数据中将什么名称附加到最终被传递给函数的变量上？是的，您可以使用debug.getint()遍历堆栈，查找传入的变量，但您可能会找到几个引用。还应考虑：

PrintVariable("StringLiteral")

你把这个变量叫做什么？它有一个值，但没有名称。

你可以用调试库做这样的事情..。像这样的事情做了你想要做的事：

function a_func(arg1, asdf)
    -- if this function doesn't use an argument... it shows up as (*temporary) in 
    -- calls to debug.getlocal() because they aren't used...
    if arg1 == "10" then end
    if asdf == 99 then end
    -- does stuff with arg1 and asdf?
-- just a function to dump variables in a user-readable format
function myUnpack(tbl)
    if type(tbl) ~= "table" then
        return ""
    local ret = ""
    for k,v in pairs(tbl) do
        if tostring(v) ~= "" then
            ret = ret.. tostring(k).. "=".. tostring(v).. ", "
    return string.gsub(ret, ", $", "")
function hook()
    -- passing 2 to to debug.getinfo means 'give me info on the function that spawned 
    -- this call to this function'. level 1 is the C function that called the hook.
    local info = debug.getinfo(2)
    if info ~= nil and info.what == "Lua" then
        local i, variables = 1, {""}
        -- now run through all the local variables at this level of the lua stack
        while true do
            local name, value = debug.getlocal(2, i)
            if name == nil then
                break
            -- this just skips unused variables
            if name ~= "(*temporary)" then
                variables[tostring(name)] = value
            i = i + 1
            -- this is what dumps info about a function thats been called
        print((info.name or "unknown").. "(".. myUnpack(variables).. ")")