Benchmark: Closure plus class check versus function apply

Tests:

Closure plus class check
class Foo {} class Bar extends Foo { add(a, b) { return a + b; } } function apply(ctor, impl, op) { if (impl instanceof ctor) { return op(impl); } } const bar = new Bar(); apply(Bar, bar, impl => impl.add(3, 5));
Function apply
class Foo {} class Bar extends Foo { add(a, b) { return a + b; } } const bar = new Bar(); const fn = bar['add']; if (fn) { return fn.apply(bar, [3, 5]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Closure plus class check
Function apply

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Android 11; Mobile; rv:100.0) Gecko/100.0 Firefox/100.0

Browser/OS: Firefox Mobile 100 on Android

View result in a separate tab

Test name	Executions per second
Closure plus class check	39525.8 Ops/sec
Function apply	36903.6 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 provided benchmark and explain what's being tested, compared, and analyzed.

**Benchmark Overview**

The benchmark tests two approaches to invoke the `add` method on an instance of the `Bar` class:

1. **Closure plus class check**: This approach uses a closure (a function that has access to its own scope) and checks if the invoked object is an instance of the `Bar` class.
2. **Function apply**: This approach uses the `apply` method of the `Function` constructor to invoke the `add` method on the `bar` object.

**Comparison**

The benchmark compares the performance of these two approaches on different JavaScript engines, specifically Firefox Mobile 100.

**Pros and Cons**

1. **Closure plus class check**:
	* Pros: This approach provides strong type checking and ensures that only instances of the `Bar` class are invoked.
	* Cons: It may incur additional overhead due to the closure creation and instance checks.
2. **Function apply**:
	* Pros: This approach is simpler and more lightweight, as it relies on a built-in method ( `apply` ) to invoke the function.
	* Cons: It may lead to type errors if the wrong object is passed as an argument.

**Library and Syntax**

There are no external libraries used in this benchmark. The syntax is standard JavaScript, with no specific features or flags enabled.

**Other Considerations**

The benchmark does not consider other aspects that might affect performance, such as:

* Optimizations: Does the JavaScript engine apply any optimizations to the `apply` method?
* Cache effects: Are there cache effects when using the `closure plus class check` approach?

**Alternatives**

If you were to create a similar benchmark, you could also consider testing other approaches, such as:

* Using a different invocation method (e.g., `call`, `bind`)
* Adding additional type checking or validation
* Comparing performance with and without specific JavaScript features enabled (e.g., strict mode, modernize)

Keep in mind that the choice of approach depends on the specific requirements and constraints of your use case.

Related benchmarks:

Closure plus class check versus function apply (version: 0)

Comparing performance of: Closure plus class check vs Function apply

Created: 7 years ago by: Guest

Jump to the latest result

Closure plus class check

Function apply

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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