Why Does Mutating __proto__ Result in Performance Degradation in JavaScript?

Mutating __proto__: Why Performance Suffers

The documentation for the proto property in JavaScript strongly discourages modifying the [[Prototype]] of an object due to its detrimental impact on performance. This is because, contrary to adding properties to the Function.prototype, changing an object's prototype has profound implications for modern JavaScript implementations.

Consider the following example:

<code class="javascript">function Foo(){}
function bar(){}

var foo = new Foo();

// This is bad: 
//foo.__proto__.bar = bar;

// But this is okay
Foo.prototype.bar = bar;

// Both cause this to be true: 
console.log(foo.__proto__.bar == bar); // true</code>

While both approaches result in foo.__proto__.bar being set to bar, their impact on performance is vastly different. Reassigning Foo.prototype.bar is acceptable, but changing foo.__proto__.bar directly is strongly discouraged.

The key to understanding this performance penalty lies in the internal optimizations employed by JavaScript engines. When properties are accessed on an object, the engine employs optimizations based on type and structure inferences. However, any mutation of the [[Prototype]] invalidates these optimizations, forcing the engine to fall back on slower non-optimized code paths.

This performance penalty arises because changing an object's prototype essentially swaps its internal type, disrupting precompiled code and flushing property lookup optimizations. Consequently, subsequent execution in modern JavaScript implementations becomes unavoidably slower.

Furthermore, it is crucial to note that such prototype mutations can also lead to type confusion hazards, making reasoning about script behavior more challenging and introducing complexities in VM and JIT implementations. As a result, creating a new object with a different prototype chain via Object.create() is the recommended approach instead of mutating existing prototypes.

The above is the detailed content of Why Does Mutating __proto__ Result in Performance Degradation in JavaScript?. For more information, please follow other related articles on the PHP Chinese website!