Benchmark: Function vs dynamic function vs strict dynamic function

Script Preparation code:

function funcPN() {
  let r = Math.random().toString(36).substring(7).includes('x');
}
function funcPS() {
  "use strict";
  let r = Math.random().toString(36).substring(7).includes('x');
}
var funcAN = () => {
  let r = Math.random().toString(36).substring(7).includes('x');
}
var funcAS = () => {
  "use strict";
  let r = Math.random().toString(36).substring(7).includes('x');
}
var funcDN = new Function("let r = Math.random().toString(36).substring(7).includes('x');");
var funcDS = new Function("\"use strict\";let r = Math.random().toString(36).substring(7).includes('x');");

Tests:

Normal function (non-strict)
funcPN();
Normal function (strict)
funcPS();
Arrow function (non-strict)
funcAN();
Arrow function (strict)
funcAS();
Dynamic function (non-strict)
funcDN();
Dynamic function (strict)
funcDS();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Normal function (non-strict)
Normal function (strict)
Arrow function (non-strict)
Arrow function (strict)
Dynamic function (non-strict)
Dynamic function (strict)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36

Browser/OS: Chrome 132 on Windows

View result in a separate tab

Test name	Executions per second
Normal function (non-strict)	2140606.8 Ops/sec
Normal function (strict)	2923250.8 Ops/sec
Arrow function (non-strict)	4107050.2 Ops/sec
Arrow function (strict)	4358634.5 Ops/sec
Dynamic function (non-strict)	4046234.8 Ops/sec
Dynamic function (strict)	2080259.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition JSON**

The provided JSON defines two benchmark definitions:

1. A script preparation code that defines four different functions:
	* `funcPN`: a normal function (non-strict)
	* `funcPS`: a normal function with strict mode enabled
	* `funcAN`: an arrow function (non-strict)
	* `funcAS`: an arrow function with strict mode enabled
2. An array of individual test cases, each defining a specific function call:
	* `funcPN()`
	* `funcPS()`
	* `funcAN()`
	* `funcAS()`
	* `funcDN()`
	* `funcDS()` (dynamic functions)

**Options Compared**

The benchmark compares the execution performance of four different function types:

1. Normal functions (non-strict)
2. Normal functions with strict mode enabled
3. Arrow functions (non-strict)
4. Arrow functions with strict mode enabled

These options are compared to determine which one is the fastest.

**Pros and Cons**

Here's a brief summary of the pros and cons of each option:

1. **Normal functions (non-strict)**:
	* Pros: easy to understand, widely supported
	* Cons: slower due to function overhead
2. **Normal functions with strict mode enabled**:
	* Pros: improved security features, faster execution in some cases
	* Cons: may introduce additional complexity and error-prone code
3. **Arrow functions (non-strict)**:
	* Pros: concise syntax, faster execution compared to normal functions
	* Cons: less intuitive for complex logic, may not support all features
4. **Arrow functions with strict mode enabled**:
	* Pros: improved security features and better error handling, similar performance to normal functions
	* Cons: additional complexity and potential incompatibility issues

**Dynamic Functions**

The benchmark also includes dynamic function definitions (`funcDN` and `funcDS`) using the `Function()` constructor. These functions are created at runtime, which can impact performance due to overhead.

**Pros and Cons**

1. **Dynamic functions (non-strict)**:
	* Pros: flexible, can be used in complex scenarios
	* Cons: slower execution compared to static function definitions
2. **Dynamic functions (strict)**:
	* Pros: improved security features, similar performance to static functions
	* Cons: more overhead due to dynamic creation at runtime

**Other Considerations**

1. **Context and State**: The benchmark does not consider the context in which these functions are used, such as variables, closures, or side effects.
2. **Browser Support**: The benchmark only runs on Chrome 119, so results may vary across other browsers.

**Alternatives**

If you're looking for alternatives to measure JavaScript performance, consider:

1. V8 Profiler (Chrome DevTools): provides detailed information about function call overhead and optimization opportunities.
2. Benchmark.js: a lightweight library for running benchmarks in Node.js and browser environments.
3. JSPerf: a dedicated benchmarking platform for testing JavaScript performance.

In summary, the provided benchmark helps determine which function type is the fastest in terms of execution time, while considering various aspects such as syntax, security features, and overhead.

Related benchmarks:

Function vs dynamic function vs strict dynamic function (version: 0)

Comparing performance of: Normal function (non-strict) vs Normal function (strict) vs Arrow function (non-strict) vs Arrow function (strict) vs Dynamic function (non-strict) vs Dynamic function (strict)

Created: one year ago by: Guest

Jump to the latest result

Normal function (non-strict)

Normal function (strict)

Arrow function (non-strict)

Arrow function (strict)

Dynamic function (non-strict)

Dynamic function (strict)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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