Javascript:覆盖函数的原型 - 不好的做法? [英] Javascript: Overwriting function's prototype - bad practice?

问题描述

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

Since when we declare a function we get its prototype's constructor property point to the function itself, is it a bad practice to overwrite function's prototype like so:

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

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

This is not how I do it, I still prefer the following approach

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

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

but I often see other people doing this.

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

So are there any implications or drawbacks by removing the constructor reference from the prototype by overwriting the function's prototype object for the sake of convenience as in the first example?

推荐答案

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

I can't see anyone mentioning best practice as far as this is concerned, so I think it comes down to whether you can see the constructor property ever being useful.

值得一提的是，constructor 属性，如果你不销毁它，也将在创建的对象上可用.在我看来，这可能很有用:

One thing worth noting is that the constructor property, if you don't destroy it, will be available on the created object too. It seems to me like that could be useful:

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

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

So it seems to me that it's an architectural decision. Do you want to allow a created object to re-call its constructor after it's instantiated? If so preserve it. If not, destroy it.

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

Note that the constructor of objectTwo is now exactly equal to the standard Object constructor function - useless.

objectTwo.constructor === Object; // true

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

这篇关于Javascript:覆盖函数的原型 - 不好的做法?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！