Javascript ES5和x27；s"；使用“严格”；；影响关闭？

如果我没有记错的话，在严格模式下，函数不能访问全局对象（函数的“this”未定义）。另一方面，内部函数需要访问其父函数的“this”才能使闭包工作。JavaScript对严格模式下的内部函数有例外吗？

你的问题是，我相信你指的是构造函数和实例化对象<代码>使用严格的杂注不影响它。通过表达式中的点或方括号表示法访问和调用对象的function类型属性会自动将

ThisBinding

设置为从中获取函数引用的对象

function Foo() {}
Foo.prototype.someMethod = function() {
    console.log(this.blah);
};
var foo = new Foo();
foo.blah = 1;

//this:
foo.someMethod();
//implicitly does this:
foo.someMethod.call(foo);

TJ可能以更简单的方式解释了这种行为：

[…]当您使用从对象属性（例如，

object.functionName（）

或

object['functionName']（）

）获取函数引用的表达式调用函数时，该对象在函数调用中自动设置为“this”

---

use strict

仅在未设置

此

绑定（

null

或

未定义

）时才起作用，此处的情况并非如此

然后，如您所知，当输入函数代码时未设置

此

参考时，在非严格模式下，它指的是全局对象（浏览器环境中的

窗口

对象），而在严格模式下，它是

未定义的

。看

---

现在，如果您指的是闭包，就像在另一个函数内部的函数中一样，请使用旧的词汇作用域技巧

function outerFunction() {
    var _this = this;
    function innerFunction() {
        // _this references the outerFunction's this
    }
}

---

这种行为也不受

使用strict

的影响。

根据您的问题，我相信您指的是构造函数和实例化对象<代码>使用严格的杂注不影响它。通过表达式中的点或方括号表示法访问和调用对象的function类型属性会自动将

ThisBinding

设置为从中获取函数引用的对象

function Foo() {}
Foo.prototype.someMethod = function() {
    console.log(this.blah);
};
var foo = new Foo();
foo.blah = 1;

//this:
foo.someMethod();
//implicitly does this:
foo.someMethod.call(foo);

TJ可能以更简单的方式解释了这种行为：

[…]当您使用从对象属性（例如，

object.functionName（）

或

object['functionName']（）

）获取函数引用的表达式调用函数时，该对象在函数调用中自动设置为“this”

---

use strict

仅在未设置

此

绑定（

null

或

未定义

）时才起作用，此处的情况并非如此

然后，如您所知，当输入函数代码时未设置

此

参考时，在非严格模式下，它指的是全局对象（浏览器环境中的

窗口

对象），而在严格模式下，它是

未定义的

。看

---

现在，如果您指的是闭包，就像在另一个函数内部的函数中一样，请使用旧的词汇作用域技巧

function outerFunction() {
    var _this = this;
    function innerFunction() {
        // _this references the outerFunction's this
    }
}

---

此行为也不受

使用strict

的影响。

闭包与

此

指针无关。闭包是函数式编程的概念，而不是面向对象编程。

这个

指针是面向对象编程的概念。两者可以同时独立工作，而不会产生问题

例如在严格模式下考虑以下函数：

function getCounter() {
    "use strict";

    var count = 0;

    return function counter() {
        return ++count;
    };
}

这里对

getCounter

的调用返回一个闭包。函数

计数器

关闭值

计数

。然后，您可以按如下方式使用返回的计数器：

var counter = getCounter();

counter(); // 1
counter(); // 2
counter(); // 3

var counter = new Counter;
counter.increment();
counter.getCount();        // 1

var counter = new Counter;

counter(); // 1
counter(); // 2
counter(); // 3

我认为你把闭包和嵌套函数混淆了。阅读下面的线程。它很好地解释了闭包：

在严格模式下，

此

指针指向全局对象时为

未定义

。否则您可以正常使用。这样可以防止意外创建全局变量。然而，它不会造成任何阻碍

例如，考虑以下构造函数：

function Counter() {
    "use strict";

    var count = 0;

    this.increment = function () {
        count++;
    };

    this.getCount = function () {
        return count;
    };
}

function Counter() {
    "use strict";

    var that = this;

    that.count = 0;

    return function counter() {
        return ++that.count;
    };
}

您可以按如下方式创建实例并使用它：

var counter = getCounter();

counter(); // 1
counter(); // 2
counter(); // 3

var counter = new Counter;
counter.increment();
counter.getCount();        // 1

var counter = new Counter;

counter(); // 1
counter(); // 2
counter(); // 3

但是，如果忘记放置

新的

，则

此

将指向在严格模式下为

未定义的全局对象。因此，尝试将方法
increment
分配给
this
将抛出错误

回到原来的问题，如果希望在嵌套函数中访问
this
指针，则始终可以将其值存储在另一个变量中。例如：

function Counter() {
    "use strict";

    var count = 0;

    this.increment = function () {
        count++;
    };

    this.getCount = function () {
        return count;
    };
}

function Counter() {
    "use strict";

    var that = this;

    that.count = 0;

    return function counter() {
        return ++that.count;
    };
}

我知道这是一个非常愚蠢的例子，但它包含了使我的观点得到理解所需的所有元素。您现在可以按如下方式使用上述功能：

var counter = getCounter();

counter(); // 1
counter(); // 2
counter(); // 3

var counter = new Counter;
counter.increment();
counter.getCount();        // 1

var counter = new Counter;

counter(); // 1
counter(); // 2
counter(); // 3

这就是它的全部。
闭包与
这个
指针无关。闭包是函数式编程的概念，而不是面向对象编程。
这个
指针是面向对象编程的概念。两者可以同时独立工作，而不会产生问题

例如在严格模式下考虑以下函数：
function getCounter() {
    "use strict";

    var count = 0;

    return function counter() {
        return ++count;
    };
}

这里对
getCounter
的调用返回一个闭包。函数
计数器
关闭值
计数
。然后，您可以按如下方式使用返回的计数器：

var counter = getCounter();

counter(); // 1
counter(); // 2
counter(); // 3

var counter = new Counter;
counter.increment();
counter.getCount();        // 1

var counter = new Counter;

counter(); // 1
counter(); // 2
counter(); // 3

我认为你把闭包和嵌套函数混淆了。阅读下面的线程。它很好地解释了闭包：

在严格模式下，
此
指针指向全局对象时为
未定义
。否则您可以正常使用。这样可以防止意外创建全局变量。然而，它不会造成任何阻碍

例如，考虑以下构造函数：

function Counter() {
    "use strict";

    var count = 0;

    this.increment = function () {
        count++;
    };

    this.getCount = function () {
        return count;
    };
}

function Counter() {
    "use strict";

    var that = this;

    that.count = 0;

    return function counter() {
        return ++that.count;
    };
}

您可以按如下方式创建实例并使用它：

var counter = getCounter();

counter(); // 1
counter(); // 2
counter(); // 3

var counter = new Counter;
counter.increment();
counter.getCount();        // 1

var counter = new Counter;

counter(); // 1
counter(); // 2
counter(); // 3

但是，如果忘记放置
新的
，则
此
将指向在严格模式下为
未定义的全局对象。因此