Javascript：函数/类的原型属性的默认值背后的逻辑是什么？ [复制]

Question

我们知道 JavaScript 有原型继承而不是经典继承，这意味着每个对象 具有 [[Prototype]] 属性，可用于通过原型链进行继承。

然而，我无法理解的这个原型继承模型的一部分是函数（或类）对象最初获得的默认原型属性背后的逻辑。即

  //For classes
  class Dog {}
  Dog.prototype // {constructor: Dog}

  //For functions
  function Cat() {}
  Cat.prototype // {constructor: Cat};

让这个属性包含指向函数本身的构造函数属性的可能用途是什么？我理解一种用法，即创建的任何对象都将获得构造函数属性，并且如果定义以某种方式丢失（像这样），则可用于创建更多对象：

function Dog(name) {
  this.name = name;
  alert(name);
}

let dog = new Dog("White Dog");

let dog2 = new dog.constructor("Black Dog");

但这并不能证明这样的设置是合理的，老实说这是相当复杂的（因为函数/类是唯一对自身具有这种循环引用的对象）。这个决定背后还有其他原因吗？

Answer 1

_{（已更新以回答实际问题，请参阅下面的旧答案）}

这个决定背后还有其他原因吗？

我只能猜测，但它可能来自影响 javascript 的语言的设计。在pure prototype-based programming 中，根本没有构造函数。只有原型对象本身来定义一个“类”，并且它将有一个init 方法可以在从它派生的实例上调用。伪语言示例：

dog = object create()
dog init = (name) {
  this name = name
}
mydog = dog create()
mydog init("whitey")

注意mydog 是如何从dog 继承的，而dog 又是从object 继承的。 dog 对象有一个 init 方法，这是自然链接。辅助方法new 可能将create 和init 捆绑在一起，称为mydog = dog new("blackey")。

现在在 JavaScript 中，一切都变成了对象，甚至函数/方法本身也是如此。为了看起来更像 Java（当时很流行），new 被做成了一个操作符而不是一个继承的方法。出于某种原因，决定不将其应用于原型对象，而是应用于构造函数——为此，它被赋予了.prototype 属性。也许这样可以用简单的function 声明类？或者通过使用自定义对象覆盖.prototype 来启用继承？我不知道。

无论如何，.constructor 是两个循环属性中更自然的一个。没有.prototype，我们可以轻松生活：

 // assuming builtins:
 const object = Object.create(null)
 object.create = function() { return Object.create(this) }
 object.new = function() { const o = this.create(); o.constructor(); return o }

// we would use them as (assuming the object literal to inherit from `object`)
var Dog = {
  constructor(name) { this.name = name },
  woof() { alert(this.name + "makes: Woof!") }
}
var myDog = Dog.new("Whitey")
myDog.woof()

---

强大的力量来自被用作使用new 运算符创建的所有实例的 [[prototype]] 的对象：

const mydog = new Dog("White Dog");
console.assert(Object.getPrototypeOf(mydog) === Dog.prototype)

这是类的中心对象，所有共享方法都在其中。其中的.constructor property 只是一个有用的（if rarely used）默认值。但是你会写

Dog.prototype.woof = function() {
    alert(this.name + "makes: Woof!");
};

并且该方法可以通过继承获得

dog.woof();

使用class 语法定义方法会导致相同的Dog.prototype 对象。