Benchmark: prototype methods vs defined function

prototype methods vs defined function (version: 0)

Testing performance: multiple prototype methods chained after one another that invoke a function from a external source (like fs.readDir or fs.stat, but in this case onTodo1 and onTodo2) - VS - one prototype method that creates a new function in the scope of that one method every time the method is called.

Comparing performance of: Chaining multiple prototype Methods vs One prototype method

Created: 3 years ago by: Guest

Jump to the latest result

Script Preparation code:

class FunctionTester {
	counterA = 0;
	counterB = 0;
	callback;
	constructor(options = {}) {
		this.onTodo1 = options.onTodo1;
		this.onTodo2 = options.onTodo2;
	};
	stuffTodo1(thing) {
		this.counterA++;
		thing.aap = "noob";
		this.onTodo1(thing, () => this.stuffTodo2(thing));
	};
	stuffTodo2(thing) {
		this.counterB++;
		thing.y = "mongol";
		this.onTodo2(thing, this.callback);
	};
	multipleProtoMethods(callback) {
		this.callback = callback;
		this.stuffTodo1({ a: 10 });
	};
	oneProtoMethod(callback) {
		const stuffTodo1 = thing => {
			this.counterA++;
			thing.aap = "noob";
			this.onTodo1(thing, () => {
				this.counterB++;
				thing.y = "mongol";
				this.onTodo2(thing, callback);
			});
		};
		stuffTodo1({ a: 10 });
	};
};
var multipleProtoMethodsTester = new FunctionTester({
	onTodo1(thing, callback) {
		thing.noob = "aap";
		callback();
	},
	onTodo2(thing, callback) {
		thing.Y = "MONGOL";
		callback(thing);
	},
});
var oneProtoMethodTester = new FunctionTester({
	onTodo1(thing, callback) {
		thing.noob = "aap";
		callback();
	},
	onTodo2(thing, callback) {
		thing.Y = "MONGOL";
		callback(thing);
	},
});

Tests:

Chaining multiple prototype Methods
let theResult; multipleProtoMethodsTester.multipleProtoMethods(result => { theResult = result; });
One prototype method
let theResult; oneProtoMethodTester.oneProtoMethod(result => { theResult = result; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Chaining multiple prototype Methods
One prototype method

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36

Browser/OS: Chrome 115 on Linux

View result in a separate tab

Test name	Executions per second
Chaining multiple prototype Methods	11469528.0 Ops/sec
One prototype method	11658413.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what is being tested.

**Benchmark Definition**

The benchmark compares two approaches to invoke functions from an external source:

1. **Multiple Prototype Methods Chained**: In this approach, multiple prototype methods are chained together after each other. Each method invokes another function from an external source (in this case, `onTodo1` and `onTodo2`). The goal is to measure the performance of this approach.
2. **One Prototype Method with Function Creation**: In this approach, a single prototype method creates a new function in the scope of that method every time it's called. This function invokes another function from an external source (in this case, `onTodo1` and `onTodo2`). The goal is to measure the performance of this approach.

**Options Compared**

The benchmark compares the performance of two approaches:

* **Approach 1: Multiple Prototype Methods Chained**: Multiple prototype methods are chained together after each other.
* **Approach 2: One Prototype Method with Function Creation**: A single prototype method creates a new function in the scope of that method every time it's called.

**Pros and Cons**

**Multiple Prototype Methods Chained**

Pros:

* Less overhead due to fewer function creations
* May be more efficient since functions are already defined

Cons:

* More complex approach, which can lead to performance issues due to multiple method calls
* Each method call creates a new scope, which can increase memory allocation and garbage collection

**One Prototype Method with Function Creation**

Pros:

* Simplified approach, which can lead to fewer performance issues due to reduced method calls
* Functions are created in the same scope, reducing memory allocation and garbage collection overhead

Cons:

* More overhead due to function creation for each call
* May be less efficient since functions need to be created every time

**Library**

In both test cases, a `FunctionTester` class is used, which provides a way to create instances with custom methods. The library is part of the benchmark code and is not an external dependency.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntaxes being tested in this benchmark. Both approaches use standard JavaScript constructs.

**Other Alternatives**

To further improve performance, alternative approaches could be explored, such as:

* Using a single function that takes the necessary parameters and returns the result
* Caching results from expensive function calls to reduce overhead
* Optimizing function creation by reusing existing functions or using a function factory

However, these alternatives are not being tested in this benchmark.

**Benchmark Preparation Code**

The `FunctionTester` class is used to create instances with custom methods. The `multipleProtoMethods` and `oneProtoMethod` methods are used to invoke the external functions (`onTodo1` and `onTodo2`).

Related benchmarks: