Benchmark: eval vs new Function - The correct way

Tests:

eval
eval("2 * 3");
new Function
new 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

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36

Browser/OS: Chrome 115 on Linux

View result in a separate tab

Test name	Executions per second
eval	6589168.0 Ops/sec
new Function	2603334.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmarking scenario.

**Benchmark Test**

The test is designed to compare two approaches: `eval()` and `new Function()`. Both methods are used to execute JavaScript code that calculates the product of 2 and 3.

**What is being tested?**

In this case, we're not just testing the execution speed of these two methods. We're also comparing their performance in terms of:

* Memory usage (how much memory does each method use?)
* Overhead (does one method introduce additional overhead compared to the other?)

However, based on the provided test cases and results, it seems that the primary focus is on the execution speed.

**Options Compared**

The two options being compared are:

1. `eval()`: The built-in JavaScript function that executes a string as JavaScript code.
2. `new Function()` (also known as "Function Constructor"): A way to create a new function object from a string of JavaScript code.

**Pros and Cons**

### eval()

Pros:

* Shorter syntax
* Easier to read

Cons:

* Can be slower due to the overhead of parsing and executing the code
* Less memory-efficient, as it creates an intermediate scope
* Vulnerable to code injection attacks (e.g., eval("1 + 2"); becomes "1+2" in a string)

### new Function()

Pros:

* More memory-efficient, as it doesn't create an intermediate scope
* Can be faster due to the caching of compiled functions

Cons:

* Longer syntax
* Less readable

**Library and Purpose**

There are no external libraries being used in this benchmark. The `eval()` and `new Function()` methods are built-in JavaScript features.

**Special JS Features or Syntax**

The benchmark does not use any special JavaScript features or syntax that would require additional explanation.

**Other Alternatives**

If we were to test alternative approaches, we might consider:

1. Using a Just-In-Time (JIT) compiler like SpiderMonkey (used in Firefox) or V8 (used in Chrome).
2. Comparing the performance of other function creation methods, such as `Function.create()` (a deprecated method) or a third-party library.
3. Adding more test cases to compare the performance of these methods with different inputs or edge cases.

However, for this specific benchmark, the comparison between `eval()` and `new Function()` provides valuable insights into their relative performance characteristics.

Related benchmarks:

eval vs new Function - The correct way (version: 0)

Comparing performance of: eval vs new Function

Created: one year 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):