Benchmark: Scoped function vs Object Literal vs prototype vs external dependencies - v1

Scoped function vs Object Literal vs prototype vs external dependencies - v1 (version: 0)

Test the speed of 2 different techniques for constructing kind of a prototype equivalent against a true prototype and another also against another way to do thing

Comparing performance of: Object Literal vs Scoped Function vs Prototype vs External dependencies

Created: 2 years ago by: Guest

Jump to the latest result

Tests:

Object Literal
function Point(x, y){ return { x, y, add: (point)=>Point(this.x + point.x, this.y + point.y), sub: (point)=>Point(this.x - point.x, this.y - point.y) } } var p1 = Point(10, 10); var p2 = Point(10, -10); var sum = p1.add(p2); var dif = p1.sub(p2);
Scoped Function
function point(x = 0, y = 0){ return { add: (pointc)=>point(x + pointc.x, y + pointc.y), sub: (pointc)=>point(x - pointc.x, y - pointc.y), get: ()=>({x, y}), set: (v)=> (x = v.x, y=v.y) } } var p1 = point(10, 10); var p2 = point(10, -10); var sum = p1.add(p2.get()); var dif = p1.sub(p2.get());
Prototype
function Point(x, y){ this.x = x; this.y = y; } const pointParent = { add(point) { return new Point(this.x + point.x, this.y + point.y); }, sub(point) { return new Point(this.x - point.x, this.y - point.y); } }; Point.prototype = pointParent; var p1 = new Point(10, 10); var p2 = new Point(10, -10); var sum = p1.add(p2); var dif = p1.sub(p2);
External dependencies
const utility = { sub:(base, point) => { return pointNew(base.x - point.x, base.y - point.y); }, add:(base, point) => { return pointNew(base.x + point.x, base.y + point.y); } } function pointNew (x, y) { let p = { x:x, y:y } return p } let a1 = pointNew(10, 10); let a2 = pointNew(10, -10); let sum = utility.add(a1, a2); let dif = utility.sub(a1, a2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object Literal
Scoped Function
Prototype
External dependencies

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON benchmark.

**Benchmark Definition**
The benchmark is comparing four approaches to construct a prototype equivalent:

1. **Object Literal**: Creating an object directly on the fly using curly brackets `{}`.
2. **Scoped Function**: Defining a function with a specific scope, which returns an object when called.
3. **Prototype**: Inheriting from a parent prototype and overriding its methods.
4. **External Dependencies**: Using external libraries or modules to create the prototype equivalent.

**Options Compared**

* **Memory allocation**: How much memory is allocated for each approach?
* **Function call overhead**: The cost of creating and destroying functions (or objects) in each approach.
* **Prototype lookup**: The efficiency of looking up properties on a prototype chain.

**Pros and Cons**

1. **Object Literal**
	* Pros: Efficient, straightforward, no function creation overhead.
	* Cons: Limited scope, not suitable for complex logic or reusability.
2. **Scoped Function**
	* Pros: Encapsulates logic, easy to reuse, can be optimized for performance.
	* Cons: Creates an extra function object, potentially slower due to overhead.
3. **Prototype**
	* Pros: Reusable, efficient, and scalable; inherits from parent prototype's methods.
	* Cons: Requires inheritance setup, can lead to complex prototype chains.
4. **External Dependencies**
	* Pros: Can be highly optimized for performance, leverages existing libraries.
	* Cons: Adds dependency on external libraries, potential maintenance issues.

**Library/External Dependency**
In the benchmark, the "External Dependencies" option uses a custom `utility` object with two functions, `add` and `sub`, which create new objects using a separate function, `pointNew`. This approach relies on an external library or module to create the prototype equivalent.

**Special JS Features/Syntax**
None mentioned in this benchmark. However, some approaches might require:

* **ES6 classes**: Used in some examples for creating prototypes.
* **Object destructuring**: Used in some examples to simplify object creation.

**Other Alternatives**

1. **Constructor functions**: Creating objects using a constructor function can be another approach to prototype equivalence.
2. **Class syntax**: Using ES6 classes can also create a similar effect to the prototype approach.

Please let me know if you'd like more detailed explanations or have any further questions!

Related benchmarks: