Benchmark: function vs Class_

Tests:

function instance

function func(v) {
    const instance = { a: v }
    instance.b = function() {
        return instance.a
    }
    return instance
}
for (let i = 0; i < 100; i++) {
    const instance = func(i)
    instance.b()
    instance.b()
    instance.b()
    instance.b()
    instance.b()
}

AخA
 
function func(v) {    const instance = { a: v }    instance.b = function() {        return instance.a    }    return instance}for (let i = 0; i < 100; i++) {    const instance = func(i)    instance.b()    instance.b()    instance.b()    instance.b()    instance.b()}

new Class

class Class {
    constructor(v) {
        this.a = v
        this.b = function() {
            return this.a
        }
    }
}
for (let i = 0; i < 100; i++) {
    const instance = new Class(i)
    instance.b()
    instance.b()
    instance.b()
    instance.b()
    instance.b()
}

 
class Class {    constructor(v) {        this.a = v        this.b = function() {            return this.a        }    }}for (let i = 0; i < 100; i++) {    const instance = new Class(i)    instance.b()    instance.b()    instance.b()    instance.b()    instance.b()}

new Function

function Func(v) {
    this.a = v
    this.b = function() {
        return this.a
    }
}

for (let i = 0; i < 100; i++) {
    const instance = new Func(i)
    instance.b()
    instance.b()
    instance.b()
    instance.b()
    instance.b()
}

​x
 
function Func(v) {    this.a = v    this.b = function() {        return this.a    }}​for (let i = 0; i < 100; i++) {    const instance = new Func(i)    instance.b()    instance.b()    instance.b()    instance.b()    instance.b()}

new Class singletone function

function func() {
	return this.a
}
class Class {
    constructor(v) {
        this.a = v
        this.b = func
    }
}
for (let i = 0; i < 100; i++) {
    const instance = new Class(i)
    instance.b()
    instance.b()
    instance.b()
    instance.b()
    instance.b()
}

 
function func() {    return this.a}class Class {    constructor(v) {        this.a = v        this.b = func    }}for (let i = 0; i < 100; i++) {    const instance = new Class(i)    instance.b()    instance.b()    instance.b()    instance.b()    instance.b()}

function lexical

function func(v) {
    let a = v
    function b() {
        return a
    }
    return { b }
}
for (let i = 0; i < 100; i++) {
    const instance = func(i)
    instance.b()
    instance.b()
    instance.b()
    instance.b()
    instance.b()
}

 
function func(v) {    let a = v    function b() {        return a    }    return { b }}for (let i = 0; i < 100; i++) {    const instance = func(i)    instance.b()    instance.b()    instance.b()    instance.b()    instance.b()}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
function instance
new Class
new Function
new Class singletone function
function lexical

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome Mobile 118 on Android

View result in a separate tab

Test name	Executions per second
function instance	814419.3 Ops/sec
new Class	111140.0 Ops/sec
new Function	113115.6 Ops/sec
new Class singletone function	113687.3 Ops/sec
function lexical	1004202.2 Ops/sec

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

Let's dive into the world of JavaScript microbenchmarks.

Benchmark Overview

The provided benchmark compares the performance of three approaches: creating a function instance, using a class with an instance method, and using a Function constructor. The test cases are designed to measure the execution speed of each approach by calling the instance method 10 times in a loop.

Options Compared

Function Instance: Creating a new function instance using the function keyword.
Class with Instance Method: Defining a class with an instance method and creating instances of that class.
Function Constructor: Using the Function constructor to create a new function instance.
Singleton Function: A variation of the function instance approach where the function is defined inside another function.

Pros and Cons

Function Instance:
- Pros: Simple, concise, and easy to read.
- Cons: Can lead to slower execution due to the overhead of creating a new scope.
Class with Instance Method:
- Pros: Encapsulates data and behavior, can be more efficient than function instances.
- Cons: Requires defining a class, which can add complexity.
Function Constructor:
- Pros: Provides a way to create functions programmatically, can be flexible.
- Cons: Can lead to slower execution due to the overhead of creating a new scope.
Singleton Function:
- Pros: Combines the benefits of function instances and classes, provides a way to share data.
- Cons: Requires defining an outer function, which can add complexity.

Library Usage

None of the test cases use external libraries.

Special JS Features or Syntax

The test cases do not explicitly use any special JavaScript features or syntax. However, the Function constructor is used in one of the test cases, which might be considered a legacy feature.

Benchmark Results

The latest benchmark results show that the Singleton Function approach performs best, followed closely by the Class with Instance Method approach. The Function Instance approach performs relatively poorly.

Other Alternatives

Arrow Functions: An alternative to traditional function expressions, which can provide a more concise and readable way of defining functions.
Classes with Static Methods: Another variation of the class-based approach, where instance methods are defined outside the constructor.
Module-Based Function Creation: A way to create functions using modules, which can provide a more modular and reusable way of creating functions.

Overall, the benchmark highlights the importance of considering the performance implications of different programming approaches in JavaScript. The test cases demonstrate that even seemingly minor differences in syntax can lead to significant variations in execution speed.

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

**Options Compared**

1. **Function Instance**: Creating a new function instance using the `function` keyword.
2. **Class with Instance Method**: Defining a class with an instance method and creating instances of that class.
3. **Function Constructor**: Using the `Function` constructor to create a new function instance.
4. **Singleton Function**: A variation of the function instance approach where the function is defined inside another function.

**Pros and Cons**

1. **Function Instance**:
	* Pros: Simple, concise, and easy to read.
	* Cons: Can lead to slower execution due to the overhead of creating a new scope.
2. **Class with Instance Method**:
	* Pros: Encapsulates data and behavior, can be more efficient than function instances.
	* Cons: Requires defining a class, which can add complexity.
3. **Function Constructor**:
	* Pros: Provides a way to create functions programmatically, can be flexible.
	* Cons: Can lead to slower execution due to the overhead of creating a new scope.
4. **Singleton Function**:
	* Pros: Combines the benefits of function instances and classes, provides a way to share data.
	* Cons: Requires defining an outer function, which can add complexity.

**Library Usage**

None of the test cases use external libraries.

**Special JS Features or Syntax**

The test cases do not explicitly use any special JavaScript features or syntax. However, the `Function` constructor is used in one of the test cases, which might be considered a legacy feature.

**Benchmark Results**

The latest benchmark results show that the **Singleton Function** approach performs best, followed closely by the **Class with Instance Method** approach. The **Function Instance** approach performs relatively poorly.

**Other Alternatives**

1. **Arrow Functions**: An alternative to traditional function expressions, which can provide a more concise and readable way of defining functions.
2. **Classes with Static Methods**: Another variation of the class-based approach, where instance methods are defined outside the constructor.
3. **Module-Based Function Creation**: A way to create functions using modules, which can provide a more modular and reusable way of creating functions.

Related benchmarks:

function vs Class_ (version: 2)

Comparing performance of: function instance vs new Class vs new Function vs new Class singletone function vs function lexical

Created: one year ago by: Registered User

Jump to the latest result