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

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):

LLMs can make mistakes. Check important info.

This benchmark compares the performance of creating and using objects in JavaScript through two different approaches: closures and prototypical inheritance.

**Closure Approach:**

* **Definition:**  A closure is a function that retains access to its lexical scope even after the outer function has completed execution. In this case, `Foo()` creates a closure where all properties and methods are encapsulated within the function itself.
* **`preFoo`:** The code defines a closure using `Foo()`. The resulting object (`preFoo`) holds properties and methods defined within the `Foo` function's scope.

**Prototypical Inheritance Approach:**

* **Definition:** JavaScript uses prototypical inheritance where objects inherit properties and methods from their prototype chain. Objects are instances of other objects (their prototypes).
* **`Bar()`:** This code defines a constructor function (`Bar()`) which sets up initial properties.
* **`prototype`:** The `Bar.prototype` object serves as the blueprint for all instances of `Bar`.  Methods like `doFoo1` and `doFoo2` are attached to this prototype, making them accessible to every instance created from `Bar`. 
* **`preBar`:** An instance (`preBar`) of the `Bar` constructor is created. It inherits its properties and methods from the `Bar.prototype`.

**Benchmark Tests:**

1. **Instantiation - Closure/Prototype:** Measures the time taken to create an object using either approach (`Foo()` or `new Bar()`).
2. **Utilization - Closure/Prototype:**  Measures the time taken to utilize a method (e.g., `doFoo2()`) on an already created object from each approach.

**Pros and Cons:**

| Approach       | Pros                                     | Cons                                          |
|---------------|---------------------------------------------|-------------------------------------------------|
| Closure         | Encapsulation, data hiding               | Can lead to more complex code if not managed well |
| Prototypical Inheritance |  More flexible inheritance models, easier code maintenance for large projects | Can be harder to understand initially          |

**Alternatives:**

* **Classes (ES6):** A more modern syntax for defining objects and inheritance in JavaScript. While the benchmark focuses on closures and prototypal inheritance, classes offer a clearer structure for object-oriented programming.

Let me know if you have any other questions about this benchmark or JavaScript concepts!

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1 Safari/605.1.15

Browser/OS: Safari 13 on Mac OS X 10.15.4

View result in a separate tab

Test name	Executions per second
Instantiation - Closure	6198245.0 Ops/sec
Instantiation - Prototype	11515855.0 Ops/sec
Utilization - Closure	8101654.5 Ops/sec
Utilization - Prototype	8271343.0 Ops/sec

Related benchmarks:

Closure v Prototypical Objects 2 (version: 0)

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

Created: 4 years ago by: Guest

Jump to the latest result

Instantiation - Closure

Instantiation - Prototype

Utilization - Closure

Utilization - Prototype

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):