Benchmark: Closure v Prototypical Objects 2

Script Preparation code:

function Foo() {
   'use strict';
   let self = {};

   /****************************************************************************
    * Properties
    ***************************************************************************/
   self.foo1 = 15;
   self.foo2 = 'testing';
   self.foo3 = { i: 1, am: 2, a: 3, literal: 4 };
   self.foo4 = null;

   /****************************************************************************
    * Methods
    ***************************************************************************/
   self.constructor = function () {
      self.foo4 = self.foo2 + self.foo1;
   }

   self.doFoo1 = function () {
      return self.foo2;
   }

   self.doFoo2 = function () {
      self.foo1 += 1;
      return self.foo1;
   }

   /****************************************************************************
    * Public Exports
    ***************************************************************************/
   self.public = {
      doFoo1: self.doFoo1,
      doFoo2: self.doFoo2
   }

   self.constructor();
   return self.public;
}

preFoo = Foo();

function Bar() {
   this._foo1 = 15;
   this._foo2 = 'testing';
   this._foo3 = { i: 1, am: 2, a: 3, literal: 4 };
   this._foo4 = this._foo2 + this._foo1;
}

Bar.prototype.doFoo1 = function () {
   return this._foo2;
}

Bar.prototype.doFoo2 = function () {
   this._foo1 += 1;
   return this._foo1;
}

preBar = new Bar();

Tests:

Instantiation - Closure
let foo = Foo();
Instantiation - Prototype
let bar = new Bar();
Utilization - Closure
let baz = preFoo.doFoo2();
Utilization - Prototype
let baz = preBar.doFoo2();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Instantiation - Closure
Instantiation - Prototype
Utilization - Closure
Utilization - Prototype

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Instantiation - Closure	45437896.0 Ops/sec
Instantiation - Prototype	81688656.0 Ops/sec
Utilization - Closure	224137568.0 Ops/sec
Utilization - Prototype	239797104.0 Ops/sec

Autogenerated LLM Summary (model llama3.1:latest, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript benchmarking.

**What is being tested?**

The provided JSON represents a benchmark test case that compares the performance of two different approaches to creating and utilizing objects in JavaScript: using closures (functions) versus prototypical objects (objects with prototypes).

**Options compared:**

1. **Instantiation - Closure**: This test case instantiates an object using a closure function (`Foo()`) and measures its execution time.
2. **Instantiation - Prototype**: This test case instantiates an object using the `new` keyword and a prototype-based approach (`Bar()`).
3. **Utilization - Closure**: This test case uses the already created closure object (`preFoo`) to call one of its methods (`doFoo2()`) and measures its execution time.
4. **Utilization - Prototype**: This test case uses the already created prototypical object (`preBar`) to call one of its methods (`doFoo2()`) and measures its execution time.

**Pros/Cons of each approach:**

1. **Closures (Functions)**:
	* Pros: Easier to reason about, more predictable performance.
	* Cons: May incur overhead due to function creation and context switching.
2. **Prototypical Objects (Objects with Prototypes)**:
	* Pros: Can provide better performance for frequently accessed properties and methods.
	* Cons: More complex to understand and maintain, potential for memory leaks if not used carefully.

**Library and its purpose**

In this test case, there is no external library being used. The code defines two functions (`Foo()` and `Bar()`) that create objects with different approaches.

**Special JS feature or syntax**

The code uses the following JavaScript features:

1. **Arrow function**: Not explicitly mentioned in the code, but implied by the use of anonymous functions.
2. **Strict mode**: Enabled using `'use strict';` at the beginning of each function definition.
3. **Prototype-based object creation**: Demonstrated through the `Bar()` function and its usage with `new`.

**Other alternatives**

In addition to closures and prototypical objects, other approaches to creating and utilizing objects in JavaScript include:

1. **Classes**: Introduced in ES6 (2015), classes provide a more traditional OOP approach.
2. **Modules**: Using modules can help encapsulate code and improve performance by reducing global scope pollution.

Now that we've explored the test case, let's summarize:

* The benchmark compares the execution time of four test cases:
	+ Instantiation using closures (`Foo()`)
	+ Instantiation using prototypes (`Bar()` )
	+ Utilization of closure object (`preFoo.doFoo2()`)
	+ Utilization of prototypical object (`preBar.doFoo2()`)
* The results show that instantiation and utilization of prototypical objects (`Bar()`) perform slightly better than closures (`Foo()`).
* This test case highlights the importance of considering performance implications when choosing between different approaches to creating and utilizing objects in JavaScript.

Related benchmarks:

Closure v Prototypical Objects 2 (version: 0)

Comparing performance of: Instantiation - Closure vs Instantiation - Prototype vs Utilization - Closure vs Utilization - Prototype

Created: 6 years ago by: Guest

Jump to the latest result

Instantiation - Closure

Instantiation - Prototype

Utilization - Closure

Utilization - Prototype

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated one year ago):