混淆 JavaScript 嵌套执行结果

Question

我尝试遵循简单的 JavaScript 嵌套代码，但结果令人困惑。

谁能详细解释一下？非常感谢。

我在等...

<script>
  // args = [];

  function foo (param) {
    args= [];
    if (param <= 1) {
      args.push(foo(2));
    } else {
      return param;
    }
  }

  foo(1)
</script>

最后的args是[], 我猜外面的 args （是 [2]) 被嵌套的内部 args 覆盖（即 [] )。谁能详细解释一下结果？执行顺序如何？谢谢。

Answer 1

你的代码调用 foo 函数两次 1. foo(1)是第一次调用，当foo运行语句

if (param <= 1) {
  args.push(foo(2)); // run here for the first call of foo 
} else {
  return param;
}

这与

类似

if (param <= 1) {
  var foo2= foo(2); // -> trigger the second call of foo
  args.push(foo2); // first element is pushed in args
} else {
  return param;
}

然后在第二次调用 foo(2) param=2 时，上面代码中的 foo2=2，最后，你得到了一个只有一个项目和 args[0]=2

的数组

编辑：

args 没有被覆盖，你已经将 args 声明为 foo 函数的局部变量，然后当 foo(1) 被调用时，它会创建一个 args 变量。当调用 foo(2) 时，会创建另一个 args。

Answer 2

args = [];

  function foo (param) { // param is 1
    if (param <= 1) { // param <= 1 is true
      args.push(foo(2)); // so args is now [foo(2)]
    } else { // ignored
      return param;
    }
  }

  /*
    This is foo(2) is computed
    function foo (param) { // param is 2
    if (param <= 1) { // param <= 1 is false, so this if statement is ignored
      args.push(foo(2));
    } else {
      return param; // returns 2
    }
  }
  */

  foo(1) // args is [2]

Answer 3

来自@Dmitry，谢谢。

args 是全局绑定（因为您不使用 var）。在第一次调用 foo(1) 时，您将其设置为：

args -----> [];

然后你通过递归调用给它加2。然而，当你递归调用foo时，它重新绑定全局foo标识符到内存中的一个新数组，仍然保持旧的.

args -----> []  // new array

     -----> [] // old one

所以当 return 来自递归时，你将 2 添加到旧的 :

args -----> []  // new array

     -----> [2] // old one

退出后，args绑定到空的新的，遗漏对旧的引用（会被GC）。

查看绑定和变异主题：http://dmitrysoshnikov.com/ecmascript/es5-chapter-3-1-lexical-environments-common-theory/#name-binding

混淆 JavaScript 嵌套执行结果

Confusing JavaScript nested execution result

javascript

nested-function