Benchmark: window.eval vs new Function

Script Preparation code:

var func = new Function("return 2 * 3");

Tests:

eval
window.eval("2 * 3");
new Function
func();

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

Latest run results:

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

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

Browser/OS: Chrome 114 on Windows

View result in a separate tab

Test name	Executions per second
eval	1856233.9 Ops/sec
new Function	10229897.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 explain what's being tested.

**What is being tested?**

The benchmark is comparing two approaches to perform arithmetic operations in JavaScript: `window.eval` and creating a new function using the `new Function()` syntax.

**Options compared:**

* **Window.eval**: This method evaluates a string as JavaScript code and returns the result.
	+ Pros:
		- Simple and easy to use, especially for ad-hoc calculations or data processing.
		- Does not require creating a new scope or binding variables.
	+ Cons:
		- Security risks if used with untrusted input, as it can execute arbitrary JavaScript code.
		- Performance may be slower due to the overhead of evaluating user-inputted code.
* **new Function**: This method creates a new function by specifying the code as a string and returning an object that represents the function.
	+ Pros:
		- Provides better security than `window.eval`, as it does not execute arbitrary code.
		- Can be faster for repeated executions, as the function is cached in memory once created.
	+ Cons:
		- Requires creating a new scope and binding variables, which can lead to issues with variable scoping and lifetime.

**Pros and Cons:**

In general, `new Function` is recommended over `window.eval` when performing arithmetic operations or other calculations where security and performance are important. However, if you need to execute user-inputted code for simple ad-hoc calculations, `window.eval` might be sufficient.

**Library:**

There is no explicit library mentioned in the benchmark definition or test cases. The `new Function()` syntax is a built-in JavaScript feature that allows creating new functions without requiring external libraries.

**Special JS feature or syntax:**

The `new Function()` syntax uses a feature called "arrow function expressions" (introduced in ECMAScript 2015) under the hood, which allows for concise and readable code. However, this is not explicitly mentioned in the benchmark definition.

**Other alternatives:**

If you need to perform arithmetic operations or calculations, other alternatives to `window.eval` and `new Function` include:

* **Mathematical functions**: JavaScript provides a range of built-in mathematical functions (e.g., `Math.pow()`, `Math.sqrt()`) that can be used for arithmetic operations.
* **Library functions**: Depending on the specific use case, you might need to use specialized libraries or frameworks (e.g., MathJS) that provide optimized and secure arithmetic operations.
* **Native implementations**: For high-performance arithmetic operations, you might consider using native implementations, such as WebAssembly (WASM), which allows running compiled code in the browser.

Keep in mind that these alternatives may have different trade-offs in terms of security, performance, and ease of use, depending on your specific requirements.

Related benchmarks:

window.eval vs new Function (version: 0)

Comparing performance of: eval vs new Function

Created: 2 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 2 months ago):