Warum mutiert die [[prototype]] von einem Objekt schlecht für die performance?

__proto__/setPrototypeOf sind nicht die gleichen wie die Zuordnung zu den object-Prototyp. Zum Beispiel, wenn Sie eine Funktion/Objekt mit den Mitgliedern zugeordnet es:

function Constructor(){
    if (!(this instanceof Constructor)){
        return new Constructor();
    } 
}

Constructor.data = 1;

Constructor.staticMember = function(){
    return this.data;
}

Constructor.prototype.instanceMember = function(){
    return this.constructor.data;
}

Constructor.prototype.constructor = Constructor;

//By doing the following, you are almost doing the same as assigning to 
//__proto__, but actually not the same :P
var newObj = Object.create(Constructor);//BUT newObj is now an object and not a 
//function like !!!Constructor!!! 
//(typeof newObj === 'object' !== typeof Constructor === 'function'), and you 
//lost the ability to instantiate it, "new newObj" returns not a constructor, 
//you have .prototype but can't use it. 
newObj = Object.create(Constructor.prototype); 
//now you have access to newObj.instanceMember 
//but staticMember is not available. newObj instanceof Constructor is true

//we can use a function like the original constructor to retain 
//functionality, like self invoking it newObj(), accessing static 
//members, etc, which isn't possible with Object.create
var newObj = function(){
    if (!(this instanceof newObj)){   
        return new newObj();
    }
}; 
newObj.__proto__ = Constructor;
newObj.prototype.__proto__ = Constructor.prototype;
newObj.data = 2;

(new newObj()).instanceMember(); //2
newObj().instanceMember(); //2
newObj.staticMember(); //2
newObj() instanceof Constructor; //is true
Constructor.staticMember(); //1

Alle scheinen sich nur auf das Prototyp, und vergessen, dass Funktionen können den Mitgliedern zugeordnet und instanziiert nach der mutation. Es gibt derzeit keinen anderen Weg, dies zu tun, ohne mit __proto__/setPrototypeOf. Kaum jemand verwenden Sie einen Konstruktor ohne die Möglichkeit der Vererbung von einem Elternteil Konstruktor-Funktion, und Object.create fehl zu dienen.

Und plus, das sind zwei Object.create Anrufe, die an die Gegenwart, ist gottlos langsam in V8 (beide browser und Knoten), die macht __proto__ eine tragfähige Wahl

InformationsquelleAutor pocesar

Hier ist ein benchmark mithilfe von Knoten - v6.11.1

NormalClass: Eine normale Klasse, bei dem der Prototyp nicht bearbeitet

PrototypeEdited: A-Klasse mit dem Prototyp bearbeitet (die test() Funktion Hinzugefügt wird)

PrototypeReference: Eine Klasse mit dem zusätzlichen Prototyp-Funktion test() wer referer, um eine externe variable

Ergebnisse :

NormalClass x 71,743,432 ops/sec ±2.28% (75 runs sampled)
PrototypeEdited x 73,433,637 ops/sec ±1.44% (75 runs sampled)
PrototypeReference x 71,337,583 ops/sec ±1.91% (74 runs sampled)

Wie Sie sehen können, der Prototyp bearbeitet-Klasse ist ein Weg, schneller als die normale Klasse. Der Prototyp, der hat eine variable, die sich auf einem externen ist die langsamste, aber das ist eine interessante Art und Weise zu Bearbeiten Prototypen mit bereits instantied variable

Quelle :

const Benchmark = require('benchmark')
class NormalClass {
  constructor () {
    this.cat = 0
  }
  test () {
    this.cat = 1
  }
}
class PrototypeEdited {
  constructor () {
    this.cat = 0
  }
}
PrototypeEdited.prototype.test = function () {
  this.cat = 0
}

class PrototypeReference {
  constructor () {
    this.cat = 0
  }
}
var catRef = 5
PrototypeReference.prototype.test = function () {
  this.cat = catRef
}
function normalClass () {
  var tmp = new NormalClass()
  tmp.test()
}
function prototypeEdited () {
  var tmp = new PrototypeEdited()
  tmp.test()
}
function prototypeReference () {
  var tmp = new PrototypeReference()
  tmp.test()
}
var suite = new Benchmark.Suite()
suite.add('NormalClass', normalClass)
.add('PrototypeEdited', prototypeEdited)
.add('PrototypeReference', prototypeReference)
.on('cycle', function (event) {
  console.log(String(event.target))
})
.run()

InformationsquelleAutor Simon Et la famille