javascript - 为什么要将 Something 分配给 Something.prototype.constructor？

Question

我正在阅读有关 Javascript 原型(prototype)属性如何与继承一起工作的内容，然后开始查看 Angular.js 代码并提出了一些问题。

首先，我读到原型(prototype)属性指向一个对象，该对象具有一个“构造函数”属性，该属性指向用于创建该对象的原始函数。例如:

// This is the constructor
function Shape() {
    this.position = 1;
}

// The constructor points back to the original function we defined
Shape.protoype.constructor == Shape;

原型(prototype)还包含我们或 Javascript 语言本身定义的任何其他方法或属性，这些对象的所有实例都共享这些方法或属性。如果你想让一个名为 Square 的对象继承自 Shape，你需要将 Square 的原型(prototype)设置为一个新的 Shape 实例，因为 Square.prototype 的内部 [[prototype]] 属性被设置为 Shape.prototype 属性的公共(public)对象值.

function Square() {}
Square.prototype = new Shape();
var square = new Square();
square.position; // This will output 1

这一切对我来说都很有意义。

但是，我有疑问的 Angular.js 代码似乎与所有这些相关，但做了一些我不理解的事情。它似乎没有处理继承，所以我可以理解为什么会有差异，但我只是很好奇为什么他们会这样写。

在 Angular.js 中，有一个 HashMap 对象和一个 Lexer 对象，但它们的定义不同，但似乎以完全相同的方式实例化和使用。首先定义了 Lexer 构造函数，然后他们将原型(prototype)设置为一个对象字面量，其中包含应由所有 Lexer 实例共享的方法。这一切都是有道理的。我不明白的是为什么他们指定“构造函数”属性并将其设置为“Lexer”，而他们不为下面的 HashMap 设置。

var Lexer = function(options) {
    this.options = options;
};

// Notice they specify Lexer as the constructor even though they don't for HashMap below
Lexer.prototype = {
    constructor: Lexer,
    lex: function(text) { ... },
    is: function(ch, chars) { ... },
    peek: function(i) { ... },
    isNumber: function(ch) { ... },
    isWhitespace: function(ch) { ... },
    isIdent: function(ch) { ... },
    isExpOperator: function(ch) { ... },
    throwError: function(error, start, end) { ... },
    readNumber: function() { ... },
    readIdent: function() { ... },
    readString: function(quote) { ... }
};

然后，如果您查看 HashMap 代码，它们会做同样的事情，只是它们没有指定构造函数属性。为什么是这样？它的工作方式似乎完全相同，而且我已经测试过构造函数仍然会被调用。

// The HashMap Constructor
function HashMap(array, isolatedUid) {
    if (isolatedUid) {
        var uid = 0;
        this.nextUid = function() {
            return ++uid;
        };
    }
    forEach(array, this.put, this);
}

HashMap.prototype = {
    put: function(key, value) { ... },
    get: function(key) { ... },
    remove: function(key) { ... }
};

那么当没有继承时构造函数属性是可选的，所以也许一个人写了 Lexer 而另一个人写了 HashMap 然后决定指定构造函数？

Answer 1

默认情况下，每个原型(prototype)都有一个 constructor 属性，该属性引用它“属于”的函数。

function A() {
}

console.log(A.prototype.constructor === A); // true

如果您用对象字面量或其他构造的原型(prototype)完全覆盖原型(prototype)，则此 constructor 值将被删除并保留为未定义或其他值。

function A() {
}
A.prototype = {
    greeting: "Hello!"
};

console.log(A.prototype.constructor === A); // false

原型(prototype)constructor属性不是构造函数正确运行所必需的，但人们通常会将prototype.constructor重新分配回其初始值以维护一致性，这就是您在 Lexer 中看到的。

考虑:

function A() {
}

function B() {
}

B.prototype = Object.create(A.prototype);

var b = new B();

console.log(b.constructor === A); // true
console.log(b.constructor === B); // false

B.prototype.constructor = B;

console.log(b.constructor === A); // false
console.log(b.constructor === B); // true

只能推测为什么 HashMap 没有这样做。我怀疑这样做是否出于任何正当理由，可能只是疏忽。