Benchmark: eval vs Function() - variation 1

Script Preparation code:

const new_function = new Function("4 * 6"); 
window.new_function = new_function;

Tests:

eval
eval("window.new_function();");
Function()
new_function();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
eval
Function()

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/114.0

Browser/OS: Firefox 114 on Windows

View result in a separate tab

Test name	Executions per second
eval	1396903.4 Ops/sec
Function()	565857472.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 provided benchmark and its results.

**Benchmark Overview**

The benchmark compares two approaches: using `Function()` (also known as the "constructor function" method) versus using `eval()` to execute a JavaScript expression that calls another function, `new_function()`. The goal is to determine which approach is faster in terms of execution speed.

**Options Compared**

There are only two options being compared:

1. **Function()**: This method creates a new function by passing a string literal as the first argument to the `Function()` constructor. In this case, it's used to create a new function that takes no arguments and returns the result of evaluating the expression `"4 * 6"`.
2. **eval()**: This built-in JavaScript function executes a string as JavaScript code.

**Pros and Cons**

* **Function():**
	+ Pros: Can be more secure than `eval()` since it doesn't execute arbitrary code. It also provides a way to create functions with specific scoping and context.
	+ Cons: Requires creating a new function object, which can lead to slower execution times due to overhead from function creation and lookup.
* **eval():**
	+ Pros: Executes JavaScript code directly, making it fast and concise.
	+ Cons: Can be insecure since it executes arbitrary code, which can pose security risks. It also has performance overhead due to the need for parsing and executing the code.

**Library and Purpose**

In this benchmark, `new_function` is not a library in the classical sense, but rather a utility function created using the `Function()` method. Its purpose is to demonstrate the execution speed difference between `Function()` and `eval()` when calling another function.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax used in this benchmark beyond what's already mentioned: `Function()` and `eval()`. However, it's worth noting that using `new_function` as a function reference requires it to be defined before the `eval()` call, which can affect performance.

**Other Alternatives**

If you're looking for alternative approaches to execute JavaScript code or create functions, some options include:

* **Arrow Functions**: A more concise way of creating small anonymous functions.
* **Closures**: Creating functions that have access to their own scope and variables.
* **Template Literals**: Using template literals (e.g., `${expression}`) for string interpolation.

Keep in mind that these alternatives might not provide the same execution speed benefits as using native functions like `Function()` or `eval()`.

Related benchmarks:

eval vs Function() - variation 1 (version: 0)

Comparing performance of: eval vs Function()

Created: one year ago by: Registered User

Jump to the latest result

eval

Function()

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):