JavaScript - 如何在递归期间重置局部变量？

Question

有一个具有“值”或/和“子项”作为属性的对象。问题是将所有值相加并返回总和。这是有效的。我使用了递归。我正在使用全局变量来存储总和。

请参考-https://jsfiddle.net/ws6ty78b/1/

function sumup(node) {
  sum+=node.value;
  if (node.children && node.children.length > 0) {
    for (var i =0; i < node.children.length; i++) {
        sumup(node.children[i]);
    }
}
return sum
}

问题 - 再次调用相同的函数时，我没有得到相同的结果。总和翻了一番。我知道为什么会这样，因为我使用的是全局变量。

问题 - 对于上述问题，有没有一种方法可以让任意数量的调用得到相同的结果。

请注意限制 -

1) 不要更改函数签名和声明。

2) 在“sumup”函数中使用“sum”变量。

3) 不要使用任何额外的变量。

4) 仅在 sumup 函数内进行更改。

Answer 1

您可以简单地将每个子节点的值与当前节点的值相加：

function sumup(node) {
      sum=node.value;
      if (node.children && node.children.length > 0) {
        for (var i =0; i < node.children.length; i++) {
          sum+=sumup(node.children[i]);
        }
      }
      return sum
    }

Answer 2

您可以在递归和分配/测试自定义this 时进行call 总结：

var obj = {
  "value": 4,
  "children": [{
      "value": 2,
      "children": [{
        "value": 1
      }]
    },
    {
      "value": 9
    }
  ]
};
var sum = 0;

function sumup(node) {
  //Only make change within this function body
  if (!this || !this.recurse) sum = 0;
  sum += node.value;
  if (node.children && node.children.length > 0) {
    for (var i = 0; i < node.children.length; i++) {
      sumup.call({ recurse: true }, node.children[i]);
    }
  }
  return sum
}

console.log(sumup(obj));
console.log(sumup(obj));

或者，您可以完全取消全局变量，并在子级上使用递归 reduce：

var obj = {
  "value": 4,
  "children": [{
      "value": 2,
      "children": [{
        "value": 1
      }]
    },
    {
      "value": 9
    }
  ]
};

const sumup = (node) => (
  node.value + (node.children
    ? node.children.reduce((a, child) => a + sumup(child), 0)
    : 0
  )
);

console.log(sumup(obj));
console.log(sumup(obj));

Answer 3

为了实现您的目标，函数sumup() 将被调用 N 次。我们不知道这个 N 是多少，因为它取决于子节点的递归次数。另外，由于限制，我们不能编辑函数签名，也不能在别处编写代码来做任何事情，甚至不能手动将 sum 设置为 0。

因此，我们需要一种方法来区分一组调用和下一组调用，并重置它。

我的想法是我们设置一个阈值，使用closure。在示例中，从第一次调用开始，您有 5 秒的时间继续调用，之后它将重新开始。除非提供另一种区分调用的方法，否则我们确实可以做到这一点。

编辑：我在这里尝试的是将所有递归保留为基本情况，而不是更改对象。由于 OP 已接受该解决方案，因此我添加了一个节点重置器属性。如果任何节点的重置器未定义或为空或零或未定义，这将重置总和。我们必须假设它没有在启动对象中定义。正如我所说，这是一个弱假设。通过在递归时定义它，当前总和被结转。 我也会保留最初的时间阈值想法，以备最终兴趣。

var obj = {
  "value": 4,
  "children": [
    {
      "value": 2,
      "children": [
        {
          "value": 1
        }
      ]
    },
    {
      "value": 9
    }
  ]
}


const sumup = (function(){
  var lastTime = 0;
  var newTime = 0;
  var sum = 0;
  const timeThreshold = 5000; // 5 seconds
  return function(node) {
    newTime = new Date().getTime();
    if(!node["resetter"] || (newTime-lastTime >= timeThreshold)){
      sum=0;
      lastTime = newTime;
      }
      sum+=node.value;
      if (node.children && node.children.length > 0) {
        for (var i =0; i < node.children.length; i++) {
          sumup(Object.assign({"resetter":true},node.children[i]));
        }
      }
      return sum;
   }
})();

console.log(sumup(obj)); //16
console.log(sumup(obj)); //32! should print 16 everytime