28

因为当我们声明一个函数时，我们将其原型的构造函数属性指向函数本身，所以像这样覆盖函数的原型是一种不好的做法：

function LolCat() {
}

// at this point LolCat.prototype.constructor === LolCat

LolCat.prototype = {
    hello: function () {
        alert('meow!');
    }
    // other method declarations go here as well
};

// But now LolCat.prototype.constructor no longer points to LolCat function itself

var cat = new LolCat();

cat.hello(); // alerts 'meow!', as expected

cat instanceof LolCat // returns true, as expected

我不是这样做的，我还是更喜欢下面的方法

LolCat.prototype.hello = function () { ... }

但我经常看到其他人这样做。

那么，为了方便起见，如第一个示例中那样，为了方便起见，通过覆盖函数的原型对象从原型中删除构造函数引用是否有任何影响或缺点？

4

6 回答 6

23

就这一点而言，我看不到任何人提到最佳实践，所以我认为这归结为您是否可以看到该constructor属性有用。

值得注意的一件事是constructor，如果您不销毁它，该属性也将在创建的对象上可用。在我看来，这可能很有用：

var ClassOne = function() {alert("created one");}
var ClassTwo = function() {alert("created two");}

ClassOne.prototype.aProperty = "hello world"; // preserve constructor
ClassTwo.prototype = {aProperty: "hello world"}; // destroy constructor

var objectOne = new ClassOne(); // alerts "created one"
var objectTwo = new ClassTwo(); // alerts "created two"

objectOne.constructor(); // alerts "created one" again
objectTwo.constructor(); // creates and returns an empty object instance

所以在我看来，这是一个架构决定。您是否要允许创建的对象在实例化后重新调用其构造函数？如果是这样保存它。如果没有，就销毁它。

请注意，objectTwo 的构造函数现在完全等于标准的 Object 构造函数 - 没用。

objectTwo.constructor === Object; // true

所以调用new objectTwo.constructor()等价于new Object().

于 2012-09-04T09:42:02.407 回答
6

这不是坏习惯，但你必须知道你在做什么以及为什么。它对于原型继承非常有用。您覆盖原型的对象将获得您分配给它的原型的对象的所有属性：

你使一个对象继承使用

ChildClassName.prototype = new ParentClass();.

现在 ChildClassName 具有 ParentClass 的所有功能，但失去了之前分配给它的原型的任何功能。您需要记住使用重置对象的构造函数属性

ChildClassName.prototype.constructor=ChildClassName.

否则，该对象将被报告为（在测试对象的类型时）ParentClass 类型而不是 ChildClassName 类型。

现在您可以按照您自己描述的方式向 ChildClassName 对象添加更多方法。

ChildClassName.prototype.myMethod = function(){
    //do stuff
}

结果是一个父对象/“类”（当然，javascript 中没有真正的类）和一个从它继承并扩展其功能的子对象/“类”。

您只需要知道，如果您覆盖原型，分配给它的任何属性都将消失。在构造继承对象时，这可能正是您想要的。

于 2012-09-04T09:34:19.077 回答
3

这种形式：

LolCat.prototype = {
  hello: function () {
      alert('meow!');
  }
};

销毁任何现有方法和公共属性。在示例中，正如给定的那样，这并不重要，因为新创建的 LolCat 没有任何属性或方法。但是，在更复杂的代码中应该注意这一点。

这种形式：

LolCat.prototype.hello = function () { ... }

将新方法添加到现有对象并保持现有对象不变。

于 2012-09-04T09:26:52.663 回答
1

constructor使用原型继承时覆盖它不是一个坏习惯。事实上，很多人都是这样做的：

LolCat.prototype = {
    constructor: LolCat,
    hello: function () {
        alert('meow!');
    }
};
于 2012-09-04T09:28:13.833 回答
1

经过多年的 javascript，我偶然发现了一个奇怪的错误，其中一个对象的新实例，然后传入一个 mixin，__proto__当它的prototype类声明为：

MyClass.prototype = {
   constructor: MyClass,
   myMethod(){ ...}
};

使用时不再有问题：

Object.assign( MyClass.prototype, {
   myMethod(){ ...}
});

奖励：您不必再重新签名构造。

我想这是因为当我们完全覆盖原型属性时，我们也会擦除它的特殊属性并将其转换为普通属性......也许这个默认情况下不应该是可写的......

于 2018-06-19T13:40:01.620 回答
0

这不是一个坏习惯。但是有一种简单而标准的方法可以覆盖下面的函数。每当我们在全局范围内定义“函数 LolCat()”时，它都会在窗口下创建，因此您始终可以像下面这样编写代码。

window.LolCat = function() {...};
LolCat.prototype.hello = function () { ... }
于 2012-09-04T09:39:18.950 回答