是否可以在不制作单个功能的情况下制作折叠变量？

Question

我有一个代码，它以少量变量开始，并使用这些初始变量创建更多元素。

function new(x, y, width, height) 
    local object = {} 
    --border 
    object.border = { x = x, y = y, width = width, height = height } 
    --body 
    object.body = { x = x+1, y = y+1, width = width-2, height = height-2 } 
    --font 
    object.font = {} 
    object.font.size = (object.body.height+2)-(math.floor((object.body.height+2)/4)+1) 
    object.font.height = love.graphics.setNewFont(object.font.size):getHeight() 
    --padding 
    object.padding = {} 
    object.padding.height = math.floor(object.border.height*(2/29)) 
    object.padding.width = object.padding.height*3 
    --text 
    object.text = { input = '' } 
    object.text.centerHeight = math.ceil(object.body.y+((object.body.height-object.font.height)/2)) 
    object.text.left = object.body.x+object.padding.width+object.padding.height 
    --backspacing 
    object.backspace = {key = false, rate = 3, time = 0, pausetime = 20, pause = true} 
    --config 
    object.config = { active = true, devmode = false, debug = false, id = gui.id(), type = 'textbox' } 
    gui.add(object) 
    return object.config.id 
end 

，当我在中间部分修改的东西，整个事情变得一团糟，因为从一个我改变，直到底部那些值开始不互相

local x = gui.get(2) 
x.body.height = 50 

我同意我们看看是否有一种方法可以重新定义这些变量，从它们开始直到底部，不需要：（a）为每个变量生成函数。和（b）编辑功能中所需的参数。

如果没有，是否有效地做到这一点的替代方法？

编辑： 的变量的结构如下：

：

border->body->padding->font 

我需要的是一种方法，我可以定义其中任何使后面也改变像一个

object.body.x = 15 

，它会从重新定义变量崩溃，直到底部：

body->padding->font 

我可以只从已编辑的可变重新定义它们，直到底部是这样的：

--not the actual code, just an example of variables dependent on the variable above 
object.body.x = 15 
object.padding.width = object.body.x+1 
object.font.size = object.padding.width+1 

但是这意味着我有重新定义的填充，直到这是非常低效的特别是当我扩展更多的字体时做同样的元素。

例如：

--padding->font 
object.padding.width = 5 
object.font.size = object.padding.width+1 

Answer 1

我很无聊，看到这个问题（再次）以及一个副本。 我开始写为了好玩一些代码，导致此：

local function getNeededVars(tab,func) 
    local needed,this = {} 
    this = setmetatable({},{ 
     __index = function(s,k) 
      -- See if the requested variable exists. 
      -- If it doesn't, we obviously complain. 
      -- If it does, we log it and return the value. 
      local var = tab.vars[k] 
      if not var then 
       error("Eh, "..k.." isn't registered (yet?)",5) 
      end needed[k] = true return tab.vals[k] 
     end; 
    }) func(this) return needed 
end 

local function updateStuff(self,key,done) 
    for k,v in pairs(self.levars) do 
     if v.needed and v.needed[key] then 
      if not done[v] then done[v] = true 
       self.vals[v.name] = v.func(self) 
       updateStuff(self,v.name,done) 
      end 
     end 
    end 
end 

local function createSubTable(self,key,tab) 
    return setmetatable({},{ 
     __newindex = function(s,k,v) 
      tab[k] = v updateStuff(self,key,{}) 
     end; __index = tab; 
    }) 
end 

local dependenceMeta 
dependenceMeta = { 
    __index = function(self,k) 
     -- Allow methods, because OOP 
     local method = dependenceMeta[k] 
     if method then return method end 
     local variable = self.vars[k] 
     if not variable then 
      error("Variable "..k.." not found",2) 
     end return self.vals[k] 
    end; 
    __newindex = function(self,k,v) 
     local variable = self.vars[k] 
     if not variable then 
      error("Use :Register() to add stuff",2) 
     elseif type(v) == "table" then 
      self.vals[k] = createSubTable(self,k,v) 
      return updateStuff(self,k,{}) 
     end self.vals[k] = v updateStuff(self,k,{}) 
    end 
} 
function dependenceMeta:Register(var,value) 
    local varobject = {func=value,name=var} 
    self.vars[var] = varobject 
    table.insert(self.levars,varobject) 
    if type(value) == "function" then 
     varobject.needed = getNeededVars(self,value) 
     self.vals[var] = value(self) 
    elseif type(value) == "table" then 
     self.vals[var] = createSubTable(self,var,value) 
    elseif value then 
     self.vals[var] = value 
    end 
end 
function dependenceMeta:RegisterAll(tab) 
    for k,v in pairs(tab) do 
     self:Register(k,v) 
    end 
end 

local function DependenceTable() 
    return setmetatable({ 
     levars = {}; 
     vars = {}; 
     vals = {}; 
    },dependenceMeta) 
end 

local test = DependenceTable() 
test:Register("border",{ 
    x=20; y=50; 
    height=200; 
    width=100; 
}) 
test:Register("body",function(self) 
    return {x=self.border.x+1,y=self.border.y+1, 
     height=self.border.height-2, 
     width=self.border.width-2} 
end) 
test:Register("font",function(self) 
    local size = (self.body.height+2)-(math.floor((self.body.height+2)/4)+1); 
    return { size = size; -- Since we use it in the table constructor... 
     height = size-4; --love.graphics.setNewFont(self.font.size):getHeight(); 
     -- I don't run this on love, so can't use the above line. Should work though. 
    } 
end) 
test:Register("padding",function(self) 
    local height = math.floor(self.border.height*(2/29)) 
    return { height = height; width = height*3 } -- again dependency 
end) 
test:Register("text",{input=""}) -- Need this initially to keep input 
test:Register("text",function(self) 
    return { input = self.text.input; 
     centerHeight = math.ceil(self.body.y+((self.body.height-self.font.height)/2)); 
     left = self.body.x+self.padding.width+self.padding.height; 
    } 
end) 
test:Register("backspace",{key = false, rate = 3, time = 0, pausetime = 20, pause = true}) 
-- Again, didn't use gui.id() on the line below because my lack of LÖVE 
test:Register("config",{active=true,devmode=false,debug=false,id=123,type='textbox'}) 

print("border.x=20, test.text.left="..test.text.left) 
test.border = {x=30; y=50; height=200; width=100;} 
print("border.x=30, test.text.left="..test.text.left) 
test.border.x = 40 
print("border.x=40, test.text.left="..test.text.left) 

这是一个很大的代码，但我喜欢写它。它给出了这个不错的输出：

border.x=20, test.text.left=73 
border.x=30, test.text.left=83 
border.x=40, test.text.left=93 

所有属性只有在编辑其依赖项之一时才会被重新计算。我让它也适用于子表，这有点棘手，但最终实际上看起来很容易。您可以编辑（例如）正文字段，方法是将其设置为一个全新的表格或在已存在的表格中设置一个字段，如代码片段的最后几行所示。当你将它分配给一个新表时，它会设置一个metatable。除非您使用5.2并且可以使用__pairs，否则您不能使用配对（& co）。

它可能会解决您的问题。如果不是的话，我很乐意写它，所以至少我写这篇文章总是积极的。 （你不得不承认，这是一些漂亮的代码那么，它的工作方式，而不是实际的格式。）

注意：如果你要使用它，取消对love.graphics和gui.id部分，因为我没有LÖVE，我显然不得不测试代码。

这里是我的事情的API的快速“摘要”，因为它可能在一开始迷惑：

local hmm = DependenceTable() -- Create a new one 
print(hmm.field) -- Would error, "field" doesn't exist yet 

-- Sets the property 'idk' to 123. 
-- Everything except functions and tables are "primitive". 
-- They're like constants, they never change unless you do it. 
hmm:Register("idk",123) 
-- If you want to actually set a regular table/function, you 
-- can register a random value, then do hmm.idk = func/table 
-- (the "constructor registering" only happens during :Register()) 

-- Sets the field to a constructor, which first gets validated. 
-- During registering, the constructor is already called once. 
-- Afterwards, it'll get called when it has to update. 
-- (Whenever 'idk' changes, since 'field' depends on 'idk' here) 
hmm:Register("field",function(self) return self.idk+1 end) 
-- This errors because 'nonexistant' isn't reigstered yet 
hmm:Register("error",function(self) return self.nonexistant end) 
-- Basicly calls hmm:Register() twice with key/value as parameters 
hmm:RegisterAll{ 
    lower = function(self) return self.field - 5 end; 
    higher = function(self) return self.field + 5 end; 
} 
-- This sets the property 'idk' to 5. 
-- Since 'field' depends on this property, it'll also update. 
-- Since 'lower' and 'higher' depend on 'field', they too. 
-- (It happens in order, so there should be no conflicts) 
hmm.idk = 5 
-- This prints 6 since 'idk' is 5 and 'field' is idk+1 
print(hmm.field) 

你可以使用setfenv（如果Lua的5.1），以去除“self.FIELD”的必要性。有了一些环境魔法，你可以使用'field'的构造函数（作为示例）只是function() return idk+1 end。

Answer 2

你可以使用元表的，更具体的__newindex场：

（当然，需要将其与__index场组合，但EH）

function new(x, y, width, height) 
    local object = { 
     font = {}, padding = {}, text = {input=''}, -- tables themself are static 
     -- also I assume text.input will change and has to stay the way it is 
    } 
    -- more static data here (yes yes, I know. The code is a bit ugly, but if it works fine...) 
    object.config = { active = true, devmode = false, debug = false, id = gui.id(), type = 'textbox' } 
    object.backspace = {key = false, rate = 3, time = 0, pausetime = 20, pause = true} 
     object.border = { x = x, y = y, width = width, height = height } 
    -- stuff that has to be calculated from the above variables goes below 
    local border = object.border 
    local function calculate() 
     --border 
     --body 
     object.body = { x = border.x+1, y = border.y+1, width = border.width-2, height = border.height-2 } 
     --font 
     object.font.size = height-(math.floor(height/4)+1) 
     object.font.height = love.graphics.setNewFont(object.font.size):getHeight() 
     --padding 
     object.padding.height = math.floor(object.border.height*(2/29)) 
     object.padding.width = object.padding.height*3 
     --text 
     object.text.centerHeight = math.ceil(object.body.y+((object.body.height-object.font.height)/2)) 
     object.text.left = object.body.x+object.padding.width+object.padding.height 
     --backspacing 
     --config 
    end 
    calculate() 
    local proxy = setmetatable({},{ 
     __index = object; -- proxy.abc returns object.abc (to get width, use proxy.border.width) 
     __newindex = function(s,k,v) 
      -- fires whenever 'proxy[k] = v' is done 
      -- I assume you'll only change x/y/width/height, as other properties are dynamic 
      -- Doing 'proxy.x = 123' is the same as 'object.border.x = 123' + recalculating 
      object.border[k] = v -- Actually apply the change 
      calculate() -- Recalculate the other properties that depends on the above 
     end; 
    }) 
    gui.add(object) 
    return object.config.id 
end 

您可以运行代码如proxy.x = 12来编辑X属性。所有的值都将被重新计算。这不是最好的，但你的代码微小的恼人的改善。 （不过，嘿，如果它工作正常给你，这是很好的）

注意：您只能设置X，ÿ，宽度和高度。你可以用旧的方式获得所有的属性，例如proxy.padding.width（请注意，proxy.x无法正常工作，请使用proxy.border。x）