从 javascript 构造函数调用原型方法

Question

我有以下简单的继承模式，我想知道是否可以按照我在构造函数中的方式调用方法（基本上，使用this 而不是“超级原型”。

父类，Pet

function Pet(name) {
  this.name = name;
  this.nickname = name;

  this.adopt();
}

Pet.prototype.adopt = function() {
  this.nickname = 'Cutty ' + this.name;
}

Pet.prototype.release = function() {
  this.nickname = null;
}

Pet.prototype.cuddle = function() {
  console.log(this.name + ' is happy');
}

子类，Lion

function Lion(name) {
  Pet.prototype.constructor.apply(this, arguments); // super(name)
  this.cuddle();
  this.release();
}
Lion.inherits(Pet);

Lion.prototype.adopt = function() {
  // DTTAH
}

Lion.prototype.release = function() {
  Pet.prototype.release.call(this);
  console.log('Thanks for releasing ' + this.name);
}

inherits 助手（我知道 polyfill 很糟糕）

Function.prototype.inherits = function(Parent) {
  function ProtoCopy() {}
  ProtoCopy.prototype = Parent.prototype;

  this.prototype = new ProtoCopy();
  this.prototype.constructor = this;
}

我的宠物像这样被实例化var lion = new Lion('Simba')

在 Lion 构造函数中，
我可以在调用子/父类方法时继续使用this 吗？或者我应该直接使用父原型中的方法吗？ （例如对super() 或release() 的伪调用）

我问的原因是：

• this 运行时替换
• constructor 财产并不总是我们所想的（从我在这里和那里读到的）

我不确定这些东西如何影响生成的对象。

感谢您的启发！

Answer 1

在构造函数中使用this.fn()和MyClass.prototype.fn.call(this)有什么区别？

这并不特定于构造函数，在实例上调用的所有函数（方法）中都是相同的。

确实，this.fn === MyClass.prototype.fn 时除了字符数之外没有太大区别，它们的行为完全相同。然而，这个假设并不总是正确的 - this 可能不会直接继承自 MyClass.prototype，而是一个子类实例，并且该子类可能覆盖 @ 987654327@方法。

那么哪一个是正确的？两者，事实上。如果您知道其中的区别，您可以根据自己的情况选择合适的。其他语言在此处有不同的默认期望，另请参阅calling static methods。

请注意，您不能用this.constructor 替换类引用，这也会被覆盖。在合理的设置中¹，this.fn() 将始终等价于 this.constructor.prototype.fn.call(this)。

这类似于 super 调用必须显式引用超类而不依赖于实例属性（例如 this.constructor、this.super 或类似的东西）的原因。

_{1：其中this.fn 是从原型继承的常用方法，而不是自己的实例特定方法，并且每个原型都有.constructor 指向其.prototype 的相应构造函数。}

Answer 2

简化问题，考虑 ES6 中的以下代码：

class Pet {
  constructor (name) {
    this.name = name;
    this.talk();
  }
  talk () {
    console.log('My name is ' + this.name);
  }
}

class Lion extends Pet {
  constructor (name) {
    super(name);
  }
  talk () {
    super.talk();
    console.log('I am a lion.');
  }
}

相当于：

function Pet (name) {
  this.name = name;
  this.talk();
}
Pet.prototype.talk = function () {
  console.log('My name is ' + this.name);
};

function Lion (name) {
  Pet.call(this, name);
}

// inheritance:
Lion.prototype = Object.create(Pet.prototype);
Lion.prototype.constructor = Lion;

// override .talk
Lion.prototype.talk = function () {
  Pet.prototype.talk.call(this);
  console.log('I am a lion');
}

运行new Lion('Bobby') 日志：

My name is Bobby
I am a lion

延伸阅读：http://eli.thegreenplace.net/2013/10/22/classical-inheritance-in-javascript-es5