Benchmark: objct vs function vs class

Script Preparation code:



pr=function(){
    let a=0;
    this.add=()=>{
       a+=1;
    }
};

const pro={
   a:0,
   add(){
     const $=this;
       $.a+=1;
  }
};

const pro2=Object.assign({},pro);
pro2.add2=function(){
	const $=this;
    $.a+=1;
};


class Pr {
    constructor() {
        this.a = 0;
    }
    add() {
        this.a += 1;
    }
}

let c=0;

Tests:

function
k = new pr(); for(c=0;c<1000;c++){ k.add(); }
object
const ob=Object.assign({},pro); for(c=0;c<1000;c++){ ob.add(); }
object with extern method
const ob2=Object.assign({},pro2); for(c=0;c<1000;c++){ ob2.add2(); }
class
j=new Pr(); for(c=0;c<1000;c++){ j.add(); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
function
object
object with extern method
class

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 19 days ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
function	8246.3 Ops/sec
object	9476.8 Ops/sec
object with extern method	9406.3 Ops/sec
class	8613.3 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON focuses on comparing the performance of different JavaScript object-oriented programming paradigms: functions, plain objects, and classes. Each approach encapsulates methods and tracks state differently, and the benchmark evaluates how well each performs when executing a simple incrementation operation repeatedly (1,000 times).

### Benchmark Overview:

1. **Function-Based Approach (Test Name: "function")**
   - Code:
     ```javascript
     k = new pr();
     for(c=0; c<1000; c++) {
         k.add();
     }
     ```
   - **Description**: This approach defines a function constructor `pr` that initializes an internal variable `a` and has an `add` method defined using an arrow function. When `add` is called, it increments `a` by 1.
   - **Pros**: 
     - Memory efficient for small instances, as it doesn't require creating a full class prototype.
     - Flexibility to modify the function's behavior as required.
   - **Cons**:
     - Arrow functions do not have their own `this`, which can lead to confusion if not properly understood in different contexts.
     - Each instance of the function can potentially have its own separate state, which may not be suitable for all use cases.

2. **Object Literal Approach (Test Name: "object")**
   - Code:
     ```javascript
     const ob = Object.assign({}, pro);
     for(c=0; c<1000; c++) {
         ob.add();
     }
     ```
   - **Description**: Here, an object `pro` is created with a method `add` using a standard method definition. This structure allows access to object properties directly using `this`.
   - **Pros**: 
     - More straightforward readability and understanding of how the state is managed within the method.
     - Usable as part of a larger object-oriented design.
   - **Cons**:
     - Each object method must be defined separately; it does not offer inheritance like classes do.
     - Potentially less performant when many similar objects are created, as you cannot share methods easily without prototype-based inheritance.

3. **Object with External Method (Test Name: "object with extern method")**
   - Code:
     ```javascript
     const ob2 = Object.assign({}, pro2);
     for(c=0; c<1000; c++) {
         ob2.add2();
     }
     ```
   - **Description**: Similar to the previous object test, but with an external method `add2` defined directly on the `pro2` object. This method increments `a` similar to `add`.
   - **Pros**:
     - Similar benefits as the object literal approach with modularization of methods.
   - **Cons**:
     - As with the previous test, this pattern is less scalable when complex relationships or hierarchies are required.

4. **Class-Based Approach (Test Name: "class")**
   - Code:
     ```javascript
     j = new Pr();
     for(c=0; c<1000; c++) {
         j.add();
     }
     ```
   - **Description**: This uses the ES6 class syntax to define a `Pr` class, encapsulating state management and methods within a class structure.
   - **Pros**:
     - Clear representation of OOP principles: encapsulation, inheritance, and polymorphism.
     - Instances can inherit methods, making it easier to maintain and extend code.
   - **Cons**:
     - Overhead of class legacy may be unnecessary for simple tasks, resulting in potential performance loss for very lightweight operations.
     - Complexity may increase as more properties and methods are added to the class.

### Performance Results:
The results show that the performance measured in executions per second was highest for the plain object approach (`object`), followed closely by the object with an external method (`object with extern method`). The class approach saw significantly lower performance, possibly due to the additional overhead of class instantiation and method resolution. The function constructor approach (`function`) displayed the least performance, which is surprising given its flexibility—this could be attributed to the behavior of arrow functions concerning the execution context.

### Other Considerations and Alternatives:
- **Using Prototypes**: Extending objects through prototypes can be a middle ground that combines the inheritance benefits of classes with the efficiency of object literals.
- **Functional Programming**: For some tasks, a functional approach can be adopted, focusing on immutability and pure functions rather than encapsulation, which may lead to clearer code and performance gains.
- **Libraries and Frameworks**: Various libraries like React or Lodash provide utility functions that simplify object manipulation and performance improvements. These should be considered based on project requirements and complexity.

### Conclusion:
Each approach has its use case and trade-offs. When deciding which to use, developers should consider not only performance but also readability, maintainability, and specific application requirements. Understanding the differences among these paradigms will aid software engineers in making informed decisions tailored to their project needs.

Related benchmarks:

objct vs function vs class (version: 1)

Comparing performance of: function vs object vs object with extern method vs class

Created: one month ago by: Guest

Jump to the latest result

function

object

object with extern method

class

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):