Benchmark: eval vs new Functionxx

Script Preparation code:

var f = 'function(a) { return a + 1}'

Tests:

eval
eval(f);
new Function
new Function('return ' + f)

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: 6 years ago)

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

Browser/OS: Chrome 70 on Mac OS X 10.13.6

View result in a separate tab

Test name	Executions per second
eval	0.0 Ops/sec
new Function	939202.9 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 definition and test cases to understand what is being tested.

**What is being tested?**

The main goal of this benchmark is to compare the performance of two approaches: `eval()` and `new Function()`. Both methods are used to create a new function with a given string representation. The benchmark aims to determine which approach is faster, more efficient, or both.

**Options compared:**

Two options are being compared:

1. **`eval()`**: This method executes the provided code as JavaScript expression.
2. **`new Function()`**: This method creates a new function object from a given string representation of a function.

**Pros and Cons:**

* `eval()`: Pros:
	+ Easy to use, straightforward syntax.
	+ Can be used for simple functions with minimal overhead.
Cons:
	+ Can pose security risks if the input string is not sanitized or validated.
	+ May incur performance overhead due to dynamic compilation and execution.
* `new Function()` : Pros:
	+ More secure than `eval()`, as it compiles the code at runtime and cannot execute arbitrary JavaScript code.
	+ May be faster than `eval()` for complex functions, as it avoids dynamic compilation and interpretation.

However, the `new Function()` approach also has some overhead due to the creation of a new function object, which can lead to additional memory allocation and garbage collection.

**Library usage:**

In this benchmark, there is no explicit library mentioned. However, if we consider modern JavaScript engines like V8 (used by Chrome), SpiderMonkey (used by Firefox), or other JavaScript engines, they likely provide optimizations for both `eval()` and `new Function()`. These optimizations might include inlining, caching, or specialized execution paths that can improve performance.

**Special JS features or syntax:**

This benchmark does not mention any special JavaScript features or syntax. It focuses on the comparison of two fundamental methods for creating functions from string representations.

**Other alternatives:**

Besides `eval()` and `new Function()`, there are other ways to create functions in JavaScript, such as:

* Using function literals (e.g., `function(a) { return a + 1; }`)
* Using arrow functions (e.g., `(a) => a + 1`)
* Using the `Function` constructor with an anonymous function (e.g., `new Function('return ' + f)`)

These alternatives might not be directly comparable to `eval()` and `new Function()`, as they may have different performance characteristics or security implications.

Related benchmarks:

eval vs new Functionxx (version: 0)

Comparing performance of: eval vs new Function

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