Benchmark: eval vs new Function proper

Script Preparation code:

var funcFunctionStr = "return 2 * 3";
var funcStr = "2 * 3";

Tests:

eval
eval(funcStr);
new Function
new Function(funcStr)();

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 25 days ago):

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this JavaScript microbenchmark.

**Benchmark Purpose:**
The benchmark is designed to compare the performance of two approaches for executing a simple arithmetic expression in JavaScript:

1. `eval` function
2. Creating a new `Function` object using the `new Function` syntax

**Comparison Options:**

* **eval**: This approach uses the built-in `eval()` function, which executes the provided string as JavaScript code.
* **new Function**: This approach creates a new `Function` object from the provided string and then calls it.

**Pros and Cons of Each Approach:**

* **eval**:
	+ Pros:
		- Easy to use, as it's a built-in function
		- Can be more convenient for simple expressions
	+ Cons:
		- Can pose security risks if used with untrusted input (e.g., `eval('...' + user_input)`), as it can execute arbitrary JavaScript code.
		- May have performance overhead due to the interpreter's state and caching mechanisms.
* **new Function**:
	+ Pros:
		- Provides more control over the execution environment, as it creates a new scope and context
		- Can be safer than `eval`, as it doesn't execute arbitrary code
	+ Cons:
		- Requires creating a new object and calling its method, which can add overhead.
		- May not be suitable for simple expressions, as it adds unnecessary complexity.

**Library/Language Features Used:**
None mentioned in this benchmark definition. The tests only use basic JavaScript syntax.

**Special JS Feature/Syntax:**
No special features or syntax are used in this benchmark. It's a straightforward comparison of two approaches.

**Alternative Approaches:**

* **String.prototype.parse()**: This method can be used to parse and execute simple arithmetic expressions, like `2 * 3`. However, it's not as widely supported as `eval` and may have performance implications.
* **Abstract Syntax Trees (ASTs)**: Some modern JavaScript engines, like V8, use ASTs to optimize and compile code. This approach can provide better performance but is more complex to implement.

In summary, this benchmark compares the performance of two approaches for executing simple arithmetic expressions in JavaScript: `eval` and creating a new `Function` object using the `new Function` syntax. The choice between these approaches depends on the trade-offs between convenience, security, and performance.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:76.0) Gecko/20100101 Firefox/76.0

Browser/OS: Firefox 76 on Ubuntu

View result in a separate tab

Test name	Executions per second
eval	2218694.2 Ops/sec
new Function	101048.4 Ops/sec

Related benchmarks:

eval vs new Function proper (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 25 days ago):