Benchmark: vector dot function vs prototype vs class

Tests:

function
function Vector(x, y) { this.x = x; this.y = y; this.dot = function(other) { return this.x * other.x + this.y * other.y; } } let i = 1000; let a = new Vector(0.5, 0.3); let b = new Vector(0.21, 0.63); let c = 0; while(--i) { c += a.dot(b); } return c;
prototype
function Vector(x, y) { this.x = x; this.y = y; } Vector.prototype.dot = function(other) { return this.x * other.x + this.y * other.y; } let i = 1000; let a = new Vector(0.5, 0.3); let b = new Vector(0.21, 0.63); let c = 0; while(--i) { c += a.dot(b); } return c;
class
class Vector { constructor(x, y) { this.x = x; this.y = y; } dot(other) { return this.x * other.x + this.y * other.y; } } let i = 1000; let a = new Vector(0.5, 0.3); let b = new Vector(0.21, 0.63); let c = 0; while(--i) { c += a.dot(b); } return c;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
function
prototype
class

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36

Browser/OS: Chrome 116 on Windows

View result in a separate tab

Test name	Executions per second
function	15424.2 Ops/sec
prototype	9599.5 Ops/sec
class	14791.8 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks, comparing the performance of different approaches to achieve a specific task. In this case, we have three test cases: "function", "prototype", and "class". The goal is to measure which approach provides the best performance for calculating the dot product of two vectors.

**Benchmark Definition**

The benchmark definition specifies the script preparation code, HTML preparation code, and description for each test case. However, in this case, all three test cases have similar scripts with only minor differences:

* "function" and "class" use a constructor to create a `Vector` object.
* "prototype" uses prototype chain to add the `dot` method to the `Vector` prototype.

**Test Cases**

Let's analyze each test case:

### 1. "function"

This test case creates two `Vector` objects using the `function` keyword and calculates their dot product in a loop.

```javascript
function Vector(x, y) {
    this.x = x;
    this.y = y;

this.dot = function(other) {
        return this.x * other.x + this.y * other.y;
    }
}

let i = 1000;
let a = new Vector(0.5, 0.3);
let b = new Vector(0.21, 0.63);
let c = 0;
while (--i) {
    c += a.dot(b);
}
return c;
```

**Pros:** This approach allows for explicit control over the `Vector` object's creation and behavior.

**Cons:** The function expression creates a new scope for each iteration of the loop, leading to slower performance compared to other approaches.

### 2. "prototype"

This test case creates two `Vector` objects using the `function` keyword with prototype chain setup, and calculates their dot product in a loop.

```javascript
Vector.prototype.dot = function(other) {
    return this.x * other.x + this.y * other.y;
}

let i = 1000;
let a = new Vector(0.5, 0.3);
let b = new Vector(0.21, 0.63);
let c = 0;
while (--i) {
    c += a.dot(b);
}
return c;
```

**Pros:** This approach allows for shared behavior between all `Vector` objects, reducing the overhead of creating multiple instances.

**Cons:** The prototype chain setup requires an additional step in the code, and may lead to slower performance due to the creation of a new scope.

### 3. "class"

This test case creates two `Vector` objects using the `class` keyword, and calculates their dot product in a loop.

```javascript
class Vector {
    constructor(x, y) {
        this.x = x;
        this.y = y;
    }

dot(other) {
        return this.x * other.x + this.y * other.y;
    }
}

let i = 1000;
let a = new Vector(0.5, 0.3);
let b = new Vector(0.21, 0.63);
let c = 0;
while (--i) {
    c += a.dot(b);
}
return c;
```

**Pros:** This approach is similar to the prototype chain setup, allowing for shared behavior between all `Vector` objects.

**Cons:** The class syntax requires support from modern JavaScript engines and may lead to slower performance due to additional overhead.

**Other Considerations**

* **Library Usage**: None of these test cases use any external libraries or frameworks. However, MeasureThat.net itself relies on the Web Workers API for parallel execution of benchmarks.
* **Special JS Features or Syntax**: None of these test cases employ special JavaScript features or syntax, such as ES6 modules, async/await, or Promises.
* **Alternatives**: Other approaches to achieve a similar result could include:
	+ Using an existing library like Mathjs or FastMath for vector operations.
	+ Implementing the dot product using SIMD instructions (e.g., SSE, AVX).
	+ Using a Just-In-Time (JIT) compiler like V8's Nanhah.

Keep in mind that these alternatives may not be directly comparable to MeasureThat.net's approach, as they might involve additional overhead or trade-offs.

Related benchmarks:

vector dot function vs prototype vs class (version: 0)

Comparing performance of: function vs prototype vs class

Created: one year ago by: Guest

Jump to the latest result

function

prototype

class

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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