javascript Class.prototype.method 与 this.prototype.method

Class.prototype.method vs this.prototype.method

提问by 00500005

I've always seen examples of Class.prototype.method, but never instances of this.prototype.method. For example:

我总是看到 Class.prototype.method 的例子，但从未见过 this.prototype.method 的实例。例如：

function Class() {
    this.prototype.method = function() {
        alert("is this allowed?");
    };
}

vs

对比

function Class() {}
Class.prototype.method = function() {
    alert("traditional example");
};

1. Does this.prototype exist?
2. Is it the same as Class.prototype?
3. What about inheritance?

1. this.prototype 存在吗？
2. 和 Class.prototype 一样吗？
3. 继承呢？

回答by Jonathan Lonowski

1. Does this.prototype exist?

   No. But, this.constructor.prototypeshould.

2. Is it the same as Class(.constructor).prototype?

   It will generally have the same value (so long as this.constructor === Class), but not the same intent.

3. What about inheritance?

   Each new Classinstance will inherit from Class.prototype. So, a prototypeobject is good for defining shared values accessible to all instances. Then, the constructor just has to setup state that's unique to each instance.

   But, attempting to mix the 2 and set a prototypeproperty within the constructor has a few problems, including a chicken-or-egg conflict as the method won't exist until the first instance is created:

   function Class() {
       this.constructor.prototype.method = function () {};
   }
   
   console.log(typeof Class.prototype.method); // "undefined"
   
   var a = new Class();
   
   console.log(typeof Class.prototype.method); // "function"
   

   And defeats some of the benefit of having the prototypeas the method is being recreated with each additional instance:

   var method = a.method;
   
   console.log(a.method === method); // true
   
   var b = new Class();
   
   console.log(a.method === method); // false
   

1. this.prototype 存在吗？

   this.constructor.prototype不。但是，应该。

2. 和 Class(.constructor).prototype 一样吗？

   它通常具有相同的值（只要this.constructor === Class），但意图不同。

3. 继承呢？

   每个new Class实例都将从Class.prototype. 因此，prototype对象适用于定义所有实例都可以访问的共享值。然后，构造函数只需要设置每个实例唯一的状态。

   但是，尝试混合 2 并prototype在构造函数中设置属性有一些问题，包括先有鸡还是先有蛋的冲突，因为在创建第一个实例之前该方法不存在：

   function Class() {
       this.constructor.prototype.method = function () {};
   }
   
   console.log(typeof Class.prototype.method); // "undefined"
   
   var a = new Class();
   
   console.log(typeof Class.prototype.method); // "function"
   

   并且失去了一些好处，prototype因为每个额外的实例都会重新创建方法：

   var method = a.method;
   
   console.log(a.method === method); // true
   
   var b = new Class();
   
   console.log(a.method === method); // false
   

回答by VtoCorleone

this.prototype would refer to that instance of the class object. It wouldn't give you much benefit because of the scope.

this.prototype 将引用类对象的实例。由于范围的原因，它不会给您带来太多好处。

Class.prototype is adding functionality to the Class, not the instance of it.

Class.prototype 正在向类添加功能，而不是它的实例。

回答by user2310967

Classis a function; thisis an object. Functions have a prototypeproperty; objects do not. There's a __proto__property defined on objects, but that interface is deprecated. You can do something like

Class是一个函数；this是一个对象。函数有一个prototype属性；对象没有。__proto__在对象上定义了一个属性，但不推荐使用该接口。你可以做类似的事情

function Class () {
    var prototype = Object.getPrototypeOf(this);
    prototype.method = function () {};
}

inside your constructor but it's not really good practice - every time Classis instantiated, it will needlessly waste cycles overwriting methodon the prototype, and in cases with more complex code, may end up wasting memory as well.

在您的构造函数内部，但这并不是一个很好的做法 - 每次Class实例化时，它都会不必要地浪费覆盖method原型的周期，并且在代码更复杂的情况下，最终也可能会浪费内存。

In short, there's no upside and possibly serious downsides to doing it that way.

简而言之，这样做没有好处，也可能有严重的坏处。