Warum ist die Veränderung des [Prototyps] eines Objekts für die Leistung schlecht?

__proto__/setPrototypeOf ist nicht identisch mit der Zuweisung an den Objektprototyp. Zum Beispiel, wenn Sie eine Funktion/ein Objekt mit zugeordneten Mitgliedern haben:

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

Jeder scheint sich nur auf den Prototyp zu konzentrieren und vergisst, dass Funktionen Mitglieder zugewiesen werden können, die nach der Mutation instanziiert werden. Es gibt derzeit keine andere Möglichkeit, dies zu tun, ohne __proto__/setPrototypeOf zu verwenden. Kaum jemand verwendet einen Konstruktor ohne die Möglichkeit, von einer übergeordneten Konstruktorfunktion zu erben, und Object.create kann nicht ausgeführt werden.

Und außerdem sind das zwei Object.create-Aufrufe, die in V8 (sowohl Browser als auch Node) im Moment unglücklich langsam sind, was __proto__ zu einer praktikabeleren Wahl macht

Ja .prototype = ist genauso schlecht, daher die Formulierung "egal, wie es ausgeführt wird". Prototyp ist ein Pseudoobjekt zur Erweiterung der Funktionalität auf Klassenebene. Seine dynamische Natur verlangsamt die Skriptausführung. Das Hinzufügen einer Funktion auf Instanzebene verursacht dagegen weit weniger Aufwand.

Hier ist ein Benchmark mit Knoten v6.11.1

NormalClass : Eine normale Klasse, deren Prototyp nicht bearbeitet wurde

PrototypeEdited : Eine Klasse, deren Prototyp bearbeitet wurde (die Funktion test() wird hinzugefügt).

PrototypeReference : Eine Klasse mit der hinzugefügten Prototypfunktion test(), die auf eine externe Variable verweist

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, ist die prototypisch bearbeitete Klasse wesentlich schneller als die normale Klasse. Der Prototyp, der über eine Variable verfügt, die auf eine externe Variable verweist, ist der langsamste. Dies ist jedoch eine interessante Möglichkeit, Prototypen mit bereits instantied-Variablen zu bearbeiten

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()