Javascript中的内部函数作用域

在本文中，我不理解以下陈述：

请注意，内部函数不能调用外部函数的 然而，arguments对象，即使它可以调用外部 函数的参数

有人能帮我理解这两点吗

内部函数无法调用外部函数的arguments对象

内部函数可以直接调用外部函数的参数

---

在每个函数体中，都有一个特殊的类似数组的对象，名为

arguments

，它包含调用函数时使用的所有实际参数。例如：

function f() {
    console.log(arguments);
}

f('one', 2, 3.0);

大多数语言都要求您声明这些参数，但JavaScript并不关心您使用了多少参数

由于在任何给定时间（最多）作用域中只有一个

参数

变量，因此无法从封闭函数访问

参数

变量是有意义的：

function f() {
    function g() {
        console.log(arguments);  // will log ['blue'], not ['red']
    }
    g('blue');
}

f('red');

function foo(a) {
    console.log("a = " + a);
    console.log("arguments[0] = " + arguments[0]);
}
foo("Hi there");

---

理解这两种说法的关键是：

了解

参数是什么

理解“阴影”

那么让我们先来讨论

参数

，然后再讨论阴影，然后我认为这两个语句想要表达的意思会相当清楚

参数

arguments

对象作为函数范围的一部分提供：它实际上是一个自动定义的变量，具有调用函数时使用的伪参数数组：

function foo() {
    console.log("My arg count: " + arguments.length);
}
foo(1, 2, 3); // My arg count: 3

当我说“自动定义”时，我的意思是，就像你有这样一个：

// CONCEPTUAL, not real
function foo() {
    var arguments = /*...magic code to get the arguments we were called with */;
    console.log("My arg count: " + arguments.length);
}
foo(1, 2, 3); // My arg count: 3

…这只是JavaScript引擎为您完成的

arguments

对象非常像一个数组-正如我们在上面看到的，它有

长度

，您可以使用通常的

[]

符号访问各个参数：

function foo() {
    var n;
    console.log("My arg count: " + arguments.length);
    for (n = 0; n < arguments.length; ++n) {
        console.log(arguments[n]);
    }
}
foo(1, 2, 3);

输出：

My arg count: 3 1 2 3 a = Hi there arguments[0] = Hi there befer: a = 10 after: a = 20 Outer's a = 10 a = undefined 输出：

My arg count: 3 1 2 3 a = Hi there arguments[0] = Hi there befer: a = 10 after: a = 20 Outer's a = 10 a = undefined

a

存在于

外部

的范围内，

内部

可以访问该范围<代码>b仅存在于

内部

中

只要我们使用不同的名称就可以了，但假设我们对这两个名称都使用了

a

：

function outer() {
    var a = 10;

    // `a` exists here

    function inner() {
        var a = 20;

        // `a` exists here -- but which one is it?

        console.log("a = " + a);
    }

    inner();
}

在那里，由于

internal

有自己的

a

变量，它不能再访问

outer

的

a

-

internal

的

a

阴影（隐藏）

outer

a

对于变量、命名参数、在范围内创建的函数，以及在范围内赋予名称含义的任何内容，都是如此

那么阴影和这两个语句有什么关系呢？让我们看看

“1.内部函数无法调用外部函数的arguments对象” “Call”在这里是个错误的词；“访问”会更有意义

还记得我们上面的概念示例吗，其中

参数

基本上是一个自动声明的变量

// CONCEPTUAL, not real
function foo() {
    var arguments = /*...magic code to get the arguments we were called with */;
    console.log("My arg count: " + arguments.length);
}
foo(1, 2, 3); // My arg count: 3

现在，您已经了解了阴影，您可能可以看到它的发展方向。此代码：

function outer() {
    function inner() {
        console.log("Inner arg count: " + arguments.length);
    }
    console.log("Outer arg count: " + arguments.length);
    inner();
}
outer(1, 2, 3);

显示

显示

输出：

My arg count: 3 1 2 3 a = Hi there arguments[0] = Hi there befer: a = 10 after: a = 20 Outer's a = 10 a = undefined 输出：

My arg count: 3 1 2 3 a = Hi there arguments[0] = Hi there befer: a = 10 after: a = 20 Outer's a = 10 a = undefined a=未定义 实际上，这两种说法都是关于范围和阴影的

内部函数无法调用外部函数的arguments对象

如果你有

function outer(){
    function inner(){
       doSomething(arguments);
    }
 }

然后，

arguments

引用直接包含该行的函数的参数。因此，对于

internal

的参数也是如此。您无法从那里获得

outer

的参数

内部函数可以直接调用外部函数的参数

---

只要保持参数（和局部变量）名称不同，您仍然可以从内部

内部
访问
外部
的参数（这里是
a
、
b
和
c
）。
您知道，什么是对象吗？太神奇了。我正准备发布同样的问题，参考同一篇文章，但标题不同：闭包：“调用外部函数的参数对象”和“直接调用外部函数的参数”是什么意思@蒂姆的链接正好回答了这个问题。非常感谢。