Benchmark: prototype function

Script Preparation code:

function s(obj) {
    obj.c++;
}

function C1() {
}
C1.prototype.test = function () {
    s(this);
    s(this);
}

function C2() {
    this.test = function () {
        s(this);
        s(this);
    }
}

function C3() {
    var self = this;
    this.test = function () {
        s(self);
        s(self);
    }
}

var c1 = new C1();
var c2 = new C2();
var c3 = new C3();
var c4 = {
    test: function () {
        s(this);
        s(this);
    }
}

Tests:

prototype function
c1.test();
object function
c2.test();
object function (self reference)
c3.test();
object function 3
c4.test();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
prototype function
object function
object function (self reference)
object function 3

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.53 Safari/537.36

Browser/OS: Chrome 103 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
prototype function	5848578.5 Ops/sec
object function	5423905.0 Ops/sec
object function (self reference)	5287133.0 Ops/sec
object function 3	4632260.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared options, pros and cons of those approaches, library usage, special JavaScript features or syntax, and alternative approaches.

**Benchmark Overview**

The benchmark tests the performance difference between three approaches to create an object function with a test method:

1. **Prototype-based approach**: `C1.prototype.test = function () { ... }`
2. **Non-prototype based approach**: `function C2() { this.test = function () { ... } }`
3. **Self-referential approach**: `var self = this; this.test = function () { s(self); s(this); }`

**Options Compared**

The benchmark compares the performance of these three approaches:

* **Prototype-based approach (C1)**: Creates an object with a prototype that has a test method.
* **Non-prototype based approach (C2)**: Creates an object with a direct property `test` that is a function.
* **Self-referential approach (C3)**: Creates an object with a self-referential variable `self` that is used to call the `s` function.

**Pros and Cons of Each Approach**

1. **Prototype-based approach (C1)**:
	* Pros: Easy to create and manage objects, flexible inheritance model.
	* Cons: Can lead to slow performance due to prototype lookup.
2. **Non-prototype based approach (C2)**:
	* Pros: Fast execution since the `test` function is directly attached to the object.
	* Cons: Limited flexibility in terms of inheritance and object creation.
3. **Self-referential approach (C3)**:
	* Pros: Efficient use of `this` keyword, avoids prototype lookup.
	* Cons: Can lead to confusing code due to self-referential variable usage.

**Library Usage**

None of the approaches rely on any external libraries.

**Special JavaScript Features or Syntax**

The benchmark uses the following special features:

1. **Self-referential variable (`self`)**: Used in approach C3 to create a self-referential variable that allows calling `s` function.
2. **Prototype-based object creation**: Used in approach C1 and C2 to create objects with prototype or direct property `test`.

**Alternative Approaches**

Other approaches could be used, such as:

1. Using an arrow function for the `test` method (e.g., `C2() => { this.test = () => { s(this); } }`)
2. Using a class syntax for object creation and inheritance
3. Creating objects using constructors or factories

However, these alternatives might not provide significant performance differences in this specific benchmark, as they are mostly variations of the existing approaches.

**Benchmark Result Analysis**

The latest benchmark result shows that approach C1 (prototype-based) is faster than approach C2 (non-prototype based), but slower than approach C3 (self-referential). This suggests that the self-referential approach avoids prototype lookup and provides better performance.

Related benchmarks:

prototype function (version: 4)

Comparing performance of: prototype function vs object function vs object function (self reference) vs object function 3

Created: 8 years ago by: Registered User

Jump to the latest result

prototype function

object function

object function (self reference)

object function 3

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):