“这个”行为的理由是什么？ JavaScript 中的关键字？

Question

我是从语言设计的角度来问这个问题的。 所以我试图找出

1. this 行为的基本原理是什么？
2. this 的行为在多大程度上是错误的，或者可以改进？

---

为了澄清为什么我对 this 感到不安，请考虑以下示例：

var a = {};
a.f = function(){ return this; }
var f = a.f;
// f() != a.f()

注意 f() 所属的对象是多么容易丢失：与 a 分离code>，this 成为全局对象（浏览器的 window）。

现在考虑一下：

var newA = function(){
    var self = {};
    self.f = function(){ return self; }
    return self;
}

var a = newA();
var f = a.f;
// f() == a.f() !

根本不使用 this，无论在何处或如何使用该方法，我们都能够建立和维护对象上下文。 我不禁想到，凭借闭包提供的力量，this 变得多余，甚至可能有点危险......

我并没有对 this 怀恨在心。 code>，或者想要开始争论； 我只是想更好地理解它。 我确实很欣赏“这个”很有用，但认识到 它也可能令人困惑...当然会让初学者感到困惑，也许在足够晦涩的情况下也会让专家感到困惑。

然而，在该语言的其他核心方面似乎可以公平回避的时候（即 Crockford 和 with 或 新）。 那么我错过了什么，使得 this 不可或缺？

Answer 1

您似乎期望 this 的行为与某些面向对象语言中的行为相同，其中它始终引用方法所属的对象。

但在 JavaScript 中，一个函数可以附加到多个对象，或者根本不附加到任何对象。 在您的示例中，您编写了一个旨在在一个特定对象的上下文中使用的函数...但是没有什么可以阻止我获取该函数并将其附加到任何其他对象。 这就是语言的本质 - 函数是一流的，对象成员资格是可选的。

因此，this指的是调用函数的上下文。 现在，它可以是任意对象（通过 .、.apply 或 .call() 指定）或全局对象。 在该语言的未来版本中，它将引用定义函数的上下文：全局函数的全局对象，内部函数的外部 this； 您可以将此视为对设计缺陷的修正，因为在实践中能够使用它引用全局对象并不是特别有用。

Answer 2

我不认为让“this”不受约束是一个错误。 有时一开始可能会令人困惑，但这是有充分理由的。 首先想到的是，由于 JavaScript 不是基于类的语言，函数不与任何特定的类关联，因此没有一致的方法来自动将“this”绑定到正确的对象实例。 例如，

function Person(first, last, age) {
    this.firstName = first;
    this.lastName = last;
    this.age = age;
}

Person.prototype.getFullName = function() {
    return this.firstName + " " + this.lastName;
};

“this”需要引用 Person 对象，但是分配给 Person.prototype.getName 的函数没有任何方法知道它将如何使用，因此“this”需要绑定到任何对象它被召唤。

当您有嵌套函数时，这会导致问题。

// This is a really contrived example, but I can't think of anything better
Person.prototype.getInfo = function() {
    // get name as "Last, First"
    function getNameLastFirst() {
        // oops. "this" is the global object, *not* the Person
        return this.lastName + ", " + this.firstName;
    }

    // expect something like "Crumley, Matthew: Age 25",
    // but you get "undefined, undefined: Age 25"
    return getNameLastFirst() + ": Age " + this.age;
};

语法 将“this”绑定到特定对象非常容易：

function bind(func, obj) {
    return function() {
        return func.apply(obj, arguments);
    };
}

Person.prototype.getInfo = function() {
    // get name as "Last, First"
    var getNameLastFirst = bind(function () {
        return this.lastName + ", " + this.firstName;
    }, this);

    return getNameLastFirst() + ": Age " + this.age;
};

artificialidiot 建议会很方便，但是使用 apply:或使用闭包的更“传统”方法

Person.prototype.getInfo = function() {
    var self = this;

    // get name as "Last, First"
    function getNameLastFirst() {
        return self.lastName + ", " + self.firstName;
    }

    return getNameLastFirst() + ": Age " + this.age;
};

Answer 3

• 这不是
• 很多面向对象的东西，
• 这样就很好了

Answer 4

我认为未绑定的“这个”是一个错误。 否则它非常方便。 未绑定的“this”可能会误解浏览器事件处理中最明显的上下文。 此外，JavaScript 库对于事件处理和许多回调结构（如映射、过滤器）中的“this”应该指代的内容有不同的看法。

删除未绑定的“this”可能不会让事情变得更加困难。

编辑：我想一个替代语法示例将使我的立场更加清晰。

function Foo()
{
    //both this refer to the Foo instance
    this.blah=this.function(){this.bar;};

    //second this refers to baz
    this.blah=baz.function(){this.bar;};

    //second this refers to anonymous function itself
    this.blah=function(){this.bar;};
}

Answer 5

我认为未绑定的“this”关键字是必要的，因为 JavaScript 是一种基于原型的语言。 消息灵通的人可能可以在这里填写详细信息。

但事实确实如此，这毫无帮助。 特别是如果您想将对象的方法传递给高阶函数，事情就会开始变得丑陋（以下示例在 MooTools 的帮助下）：

myArray.each(myObject.foo);

将不起作用，因为 myObject.foo 中的“this”将引用myArray 而不是 myObject。 相反：

myArray.each(myObject.foo.bind(myObject))

这对我来说看起来很丑陋。 这就是为什么我通常不在 JavaScript 中以面向对象的方式进行编程，而是严重依赖闭包。

Answer 6

将习惯用法 af() 视为以下内容的简写：

a.f.call(a);

根据定义，它是使用范围 a 调用函数 f。

var f = a.f;
f(); // f.call(this);
a.f(); // f.call(a);

如果 this 和 a 不是同一个对象，f() 和 af() 将使用不同的作用域，并且因此可能表现不同。 考虑其他语言中静态方法和类方法之间的区别：

class Foo {
public:
    static void a(Foo *scope) {
        // do something with given scope
    };

    void b() {
        a(this); // do something with the scope of this object
    };
};

Foo foo;
Foo bar;

foo.a(&bar) != foo.b(); // just like f() != a.f()
foo.a(&foo) == foo.b(); // just like f.call(a) == a.f()

Answer 7

• 它应该被称为“self”，而不是
• 任何引用当前对象状态的东西。
• 通过选择“self”作为“this”的名称，并将其显式传递（作为第一个参数）给所有方法。 这样您就可以轻松区分实例方法和静态方法或函数。

抱歉，但我真的很喜欢 Python ;-)