如何获取尚未声明但即将声明的变量？

Question

如何获取尚未声明的变量？

下面是简单的例子：

a = b
b = 123

这两行我想要的是a 123。但是obv它不起作用。

我知道获得答案a = 123 的简单方法是剪切第一行并将其粘贴到第二行以下。

但我遇到了一些问题。我需要一些像“WillDeclaredVar()”这样的函数，我可以这样使用：

a = WillDeclaredVar(b)
sheepCount = 123
b = sheepCount
print(a)

所以我可以得到答案“123”。

或者有什么内置函数可以让我做类似的事情？

===

我认为 timrau 提供的链接并没有说明我的情况。关键是如何获取“尚未声明的变量”。

===

添加实际代码：

triggerCount = 0 -- Counting number of 'Trigger' function
local Trigger = function (t)
triggerCount = triggerCount + 1
return Trigger (t)
end


-- following Triggers are same as while statement.
-- following Triggers doing: Add 1 MarineCount until get 64000 MarineCount



Trigger { -- Here the Trigger function. Now triggerCount = 1.
    players = {P1}
    actions = {
        SetDeaths(P1, Add, 1, "Terran Marine")
    },
flag = {preserved},
}
Portal(LoopStart);
-- function Portal(VariableName) returns VariableName = triggerCount. So LoopStart = 1.

Trigger { -- Now triggerCount = 2.
    players = {P1}
    actions = {
        LinkList(LoopEnd, LoopStart);
-- function LinkList(From, To) changes 'From' Trigger's next pointer to the 'To' Trigger.
-- But now the problem happens. Because 'LoopEnd' is not declared yet.
    },
flag = {preserved},
}


Trigger { -- Now triggerCount = 3.
    players = {P1}
    conditions = {
        Deaths(P1, Exactly, 64000, "Terran Marine");
    }
    actions = {
        _LinkList(LoopEnd);
        -- Reset LoopEnd's next pointer(= LoopEscape) if MarineCount hits 64000
    },
flag = {preserved},
}
Portal(LoopEnd); -- LoopEnd = 3.

1. 更改触发器顺序会破坏触发器逻辑（while 语句）。

2. 我想要的只是轻松编码。说白了，我不需要解决这个问题（get undeclared var）。我可以想象一些避免它的方法。但是如果我使用这些方式，那么编码工作会非常复杂，编码的难度会大大增加。困难让我最近几个月停止了编码。

Answer 1

如何获取尚未声明的变量？

时间短，你不能。

您的示例代码没有解释问题的动机，因为：

a = WillDeclaredVar(b)
sheepCount = 123
b = sheepCount
print(a)

可以简单地重新排列成这样：

sheepCount = 123
b = sheepCount
a = WillDeclaredVar(b)
print(a)

如果您展示了您要解决的实际问题（以避免XY problem），那么回答您的问题会更容易。

但是，如上所述，我们可以注意到的事情很少。

首先，您需要区分声明一个变量和给它一个值。在 Lua 中你可以说：

local b

将b 声明为局部变量，这可能会在堆栈帧中为其创建一个插槽，并让您在给它一个值之前将闭包绑定到它。但是，该行：

a = WillDeclaredVar(b)

将传递WillDeclaredVar b 当前 具有的值，并且由于b 被分配了一个新值，a 无法追溯更改。这永远不会发生。 a 和 WillDeclaredVar 甚至都不知道 b 的存在，它们在调用点收到它包含的值。

但是，您可以将变量 b 绑定到一个闭包，该闭包将在需要时获取 b 的当前值。

-- declare b before giving it a value, aka "forward reference"
local b
a = function() return b end
sheepCount = 123
b = sheepCount
print(a()) -- call a to get b's current value

另一种方法是让b 成为一个全局 变量，它实际上只是你的环境表的一个键，所以你可以说：

a = WillDeclaredVar('b')

并让a 成为可以在需要时获取__ENV['b'] 的当前值的对象。

但是，它们都不支持这种语法：

print(a)

a 需要是一个函数，它在需要时查找b 的值，而不是简单地保存先前计算的值。您可以在这个特定的实例中（即a 需要可转换为字符串）通过创建实现__tostring 的代理对象来实现。

function WillDeclaredVar(variableName)
    local proxy = { environment = _ENV or _G, variableName = variableName }
    return setmetatable(proxy, {
        __tostring = function(proxy)
            return proxy.environment[proxy.variableName]
        end
    })
end

-- a will compute a value based on the current value of b when needed
a = WillDeclaredVar('b')
sheepCount = 123
b = sheepCount
print(a)

输出：

123

Answer 2

要使var1 成为var2 的引用，请写var1 = ReferenceF or var2（请注意“ReferenceFor”中的空格！）

do
   local values, references, reference_flag = {}, {}
   setmetatable(_G, {
      __index = function (_, name)
         if name == 'ReferenceF' then
            reference_flag = true
         elseif reference_flag then
            reference_flag = false
            return {[references] = name}
         elseif references[name] then
            return _G[references[name]]
         else
            return values[name]
         end
      end,
      __newindex = function (_, name, val)
         if type(val) == 'table' and val[references] then
            references[name] = val[references]
         else
            values[name] = val
         end
      end
   })
end

a = ReferenceF or b  -- a is Reference For b
b = ReferenceF or c  -- b is Reference For c
sheepCount = 123
c = sheepCount
print(a, b, c)  --> 123 123 123