Benchmark: Adding fields to functions

Tests:

eval-set-name
var f; var sum = 0; for(var i = 0; i <= 100000; i += 1) { f = eval("{(function(j) { return j; })}") f.$name = "f" + i; sum += f(i); } console.log(f.$name);
eval-native-name
var f; var sum = 0; for(var i = 0; i <= 100000; i += 1) { f = eval("{(function f" + i + "(j) { return j; })}"); sum += f(i); } console.log(f.name);
no-eval-set-name
var f; var sum = 0; for(var i = 0; i <= 100000; i += 1) { f = function(j) { return j; }; f.$name = "f" + i; sum += f(i); } console.log(f.$name);
no-eval-native-name
var f; var sum = 0; for(var i = 0; i <= 100000; i += 1) { f = function f(j) { return j; }; sum += f(i); } console.log(f.name);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
eval-set-name
eval-native-name
no-eval-set-name
no-eval-native-name

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The benchmark consists of four test cases that measure the performance of assigning names to functions using different approaches: `eval-set-name`, `no-eval-native-name`, `no-eval-set-name`, and `eval-native-name`. These tests aim to evaluate how efficient it is to assign a name to a function created with `eval` versus not using `eval` at all.

**Options Compared**

The benchmark compares four approaches:

1. **`eval-set-name`**: This approach uses `eval` to create a new function and then assigns a name to it using the `$name` property.
2. **`no-eval-native-name`**: In this case, a named function is created without using `eval`, which allows for faster execution and more efficient use of the JavaScript engine's caching mechanisms.
3. **`no-eval-set-name`**: Similar to the first approach, but instead of assigning a name to the function created with `eval`, it creates an anonymous function (i.e., one without a declared name) using the `function` keyword.
4. **`eval-native-name`**: This approach uses `eval` to create a named function, which might seem similar to `eval-set-name`. However, this is where things get interesting: in some older browsers, `eval` behaves like a native function call, allowing for faster execution.

**Pros and Cons of Each Approach**

Here's a brief summary:

* **`eval-set-name`**: Pros: Simple to implement. Cons: Slow due to the use of `eval`.
* **`no-eval-native-name`**: Pros: Faster execution in modern browsers due to native function call behavior. Cons: Requires specific browser support.
* **`no-eval-set-name`**: Pros: Fast and efficient, similar to `no-eval-native-name`. Cons: Less readable code due to the absence of a declared name.
* **`eval-native-name`**: Pros: Can take advantage of native function call behavior in older browsers. Cons: Still uses `eval`, which is generally slower.

**Library Used**

None are explicitly mentioned in the benchmark definition, but `eval` is used throughout the tests.

**Special JS Feature or Syntax**

The use of `$name` and `eval` might seem unfamiliar to some readers. `$name` is a convention used by MeasureThat.net to store additional metadata about the test case, while `eval` is a built-in JavaScript function that allows dynamic code execution.

**Other Considerations**

When interpreting these results, keep in mind that:

* The benchmark measures the performance of assigning names to functions using different approaches. It does not account for other aspects like memory allocation or garbage collection.
* Modern browsers have implemented various optimizations and caching mechanisms to improve performance. Results may vary across different versions and configurations.

**Alternatives**

If you're interested in running similar benchmarks or exploring alternative JavaScript engines, some options include:

1. V8 (Node.js): A popular JavaScript engine for server-side applications.
2. SpiderMonkey (Firefox): The default JavaScript engine used by the Firefox browser.
3. Chakra (Internet Explorer): A custom JavaScript engine developed by Microsoft.
4. JavaScript engines like Nashorn or GraalVM, which provide just-in-time compilation and caching.

In summary, this benchmark evaluates the performance of assigning names to functions using different approaches in modern browsers. The results highlight the benefits of using native function call behavior and avoiding `eval` for better performance.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2923.0 Safari/537.36

Browser/OS: Chrome 56 on Mac OS X 10.12.1

View result in a separate tab

Test name	Executions per second
eval-set-name	13.2 Ops/sec
eval-native-name	0.4 Ops/sec
no-eval-set-name	59.3 Ops/sec
no-eval-native-name	228.7 Ops/sec

Related benchmarks:

Adding fields to functions (version: 0)

Comparing performance of: eval-set-name vs eval-native-name vs no-eval-set-name vs no-eval-native-name

Created: 7 years ago by: Guest

Jump to the latest result

eval-set-name

eval-native-name

no-eval-set-name

no-eval-native-name

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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