Benchmark: eval() vs new Function()

Tests:

eval
eval("2 * 3");
new Function
Function("return 2 * 3")();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
eval
new Function

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**What is tested on the provided JSON?**

The benchmark tests two different approaches to perform simple arithmetic operations in JavaScript:

1. `eval()`: The `eval()` function evaluates a string as a JavaScript expression and returns its result. In this case, it's used to calculate `2 * 3`.
2. `new Function()`: The `Function()` constructor creates a new JavaScript function and executes it when called.

**Options compared**

The benchmark compares the performance of these two approaches:

* `eval()`
* `new Function()`

**Pros and Cons of each approach:**

* **`eval()`**:
	+ Pros:
		- Simple to implement, as it's a built-in JavaScript function.
		- Can be used with any string expression.
	+ Cons:
		- Can pose security risks if the input is not sanitized, as it can execute arbitrary code.
		- May be slower than other approaches due to its dynamic compilation step.
* **`new Function()`**:
	+ Pros:
		- More secure than `eval()`, as it compiles the expression into an anonymous function before execution.
		- Can provide better performance, especially for complex expressions, since the compilation step is done ahead of time.
	+ Cons:
		- Requires more code to implement, which can be a disadvantage in terms of readability and maintainability.

**Library**

There is no external library used in this benchmark. Both `eval()` and `new Function()` are built-in JavaScript functions.

**Special JS feature or syntax**

None mentioned, but it's worth noting that the use of `eval()` and `Function()` can be considered a legacy approach in modern JavaScript development, as newer approaches like arrow functions (`() =>`) or template literals (`${expression}`) are generally recommended for simple expressions.

**Other alternatives**

If you're interested in exploring alternative approaches, here are some options:

* **Arrow functions**: `(x) => x * 3` (similar to `new Function()` but with improved syntax)
* **Template literals**: `x * 3`
* **Native arithmetic operators**: `2 * 3`

These alternatives may offer better performance or security benefits compared to the original `eval()` and `Function()` approaches. However, they may require changes to your code's implementation.

Please let me know if you have any further questions!

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 11_1_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36

Browser/OS: Chrome 88 on Mac OS X 11.1.0

View result in a separate tab

Test name	Executions per second
eval	2576884.5 Ops/sec
new Function	1383550.8 Ops/sec

Related benchmarks:

eval() vs new Function() (version: 0)

Comparing performance of: eval vs new Function

Created: 3 years ago by: Guest

Jump to the latest result

eval

new Function

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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