Benchmark: Prototype chains

Script Preparation code:

const level1 = {a: 1};
const level2 = {b: 1};
const level3 = {c: 1};
const level4 = {d: 1};
const level5 = {e: 1};

level2.__proto__ = level1;
level3.__proto__ = level2;
level4.__proto__ = level3;
level5.__proto__ = level4;

Tests:

level 5
for (var i=0; i<10000; i++) { level5.a; }
level 4
for (var i=0; i<10000; i++) { level4.a; }
level 3
for (var i=0; i<10000; i++) { level3.a; }
level 2
for (var i=0; i<10000; i++) { level2.a; }
level 1
for (var i=0; i<10000; i++) { level1.a; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
level 5
level 4
level 3
level 2
level 1

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 months ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 132 on Android

View result in a separate tab

Test name	Executions per second
level 5	102619.8 Ops/sec
level 4	102650.3 Ops/sec
level 3	102334.4 Ops/sec
level 2	102468.3 Ops/sec
level 1	102033.4 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

### Benchmark Overview

The benchmark named "Prototype chains" evaluates the performance of property access in JavaScript objects organized in a prototype chain. The benchmark tests various levels of prototypes, where each level inherits properties from its preceding level in the chain.

### Prototype Chain Setup

In the provided preparation code, several objects are created:

- `level1`: `{a: 1}`
- `level2`: `{b: 1}`
- `level3`: `{c: 1}`
- `level4`: `{d: 1}`
- `level5`: `{e: 1}`

The prototype chain is established as follows:

- `level2.__proto__ = level1`
- `level3.__proto__ = level2`
- `level4.__proto__ = level3`
- `level5.__proto__ = level4`

### Test Cases Explained

Five different test cases are executed, each accessing the property `a` from different levels of the prototype chain:

1. **Test Name: level 5**  
   *Benchmark Definition:* Access `level5.a`  
   The access goes through four layers of prototypes (from `level5` to `level1`). This is the most indirect access and will generally take longer than direct access.

2. **Test Name: level 4**  
   *Benchmark Definition:* Access `level4.a`  
   This involves three levels of prototypes (from `level4` to `level1`).

3. **Test Name: level 3**  
   *Benchmark Definition:* Access `level3.a`  
   Accessing `a` from `level3` necessitates looking up two levels in the prototype chain.

4. **Test Name: level 2**  
   *Benchmark Definition:* Access `level2.a`  
   In this case, the lookup involves only one prototype.

5. **Test Name: level 1**  
   *Benchmark Definition:* Direct access to `level1.a`  
   This is the most straightforward access since `a` is directly on the object.

### Performance Results

The results indicate the number of executions per second for each test case. Here’s a summary of the performance outcomes:

- **level 4**: 82,477 exec/sec (Fastest)
- **level 5**: 82,417 exec/sec
- **level 3**: 81,940 exec/sec
- **level 2**: 81,243 exec/sec
- **level 1**: 80,084 exec/sec (Slowest)

From this, it's evident that the deeper the property access (i.e., the further down the prototype chain), the slower the performance. Each level of indirection potentially adds overhead as the JavaScript engine has to navigate through the prototype chain to find the property.

### Pros and Cons of Different Approaches

- **Inheritance**:
  - **Pros**: Promotes code reuse, allowing the creation of rich object-oriented hierarchies. Can simplify code maintenance by centralizing shared functionality.
  - **Cons**: Increased lookup time when properties are accessed indirectly through multiple prototype levels can lead to performance hits.

- **Direct Property Access**:
  - **Pros**: Fastest access since the lookup occurs on the object without involving the prototype chain.
  - **Cons**: Reduces code reuse and may lead to duplication across objects if similar properties or functionalities are needed.

### Other Considerations & Alternatives

This benchmark highlights an important aspect of JavaScript's object-oriented features. While prototypes are powerful for enabling inheritance, developers must be mindful of performance implications, especially in scenarios requiring frequent property access.

Alternatives include:

1. **Object Composition**: Instead of using prototype chaining, use composition to combine behavior from multiple objects. This can reduce the complexity of the object and often affords better performance for certain access patterns.

2. **Object Property Cloning**: If property access is critical, consider flattening the structure by copying properties into the object itself instead of relying on prototypes, though this can lead to increased memory usage.

3. **Using ES6 Classes**: Implement class-based inheritance, which provides syntactic sugar around prototype inheritance but doesn't fundamentally change the prototype-based nature of JavaScript.

In summary, this benchmark provides insights into how JavaScript's prototype chain influences property access performance. Understanding these principles allows developers to make informed decisions based on performance needs and code maintainability.

Related benchmarks:

Prototype chains (version: 1)

Comparing performance of: level 5 vs level 4 vs level 3 vs level 2 vs level 1

Created: 3 months ago by: Guest

Jump to the latest result

level 5

level 4

level 3

level 2

level 1

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):