Benchmark: eval vs new Function 2

Script Preparation code:




  var str = JSON.stringify({
   someArray: ['foo', 'bar', 123],
   someObject: {
    foo: 'bar',
    embedded: {
     eleet: 1337
    }
   },
   someString: '"Hi there!"',
   someNumber: 123,
   someBoolean: true
  });

Tests:

eval
JSON.parse(str)
new Function
new Function('return '+str)()

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Definition and Purpose**

The benchmark is designed to compare the performance of two approaches: `eval` and `new Function`. The purpose of this benchmark is to measure which approach is faster for parsing JSON data using `JSON.parse()` or equivalent methods.

**Options Compared**

There are only two options being compared:

1. **`eval`**: This is a built-in JavaScript function that evaluates a string as JavaScript code.
2. **`new Function`**: This creates a new anonymous function with the given source code, which can be used to execute a string as JavaScript code.

**Pros and Cons of Each Approach**

* `eval`:
	+ Pros: Simple to use, no need to define a separate function.
	+ Cons: Can pose security risks if not validated properly, can lead to performance issues due to the overhead of evaluating the entire expression.
* `new Function`:
	+ Pros: More secure than `eval`, as it allows for better control over the execution environment.
	+ Cons: Requires more code and setup, which can increase overhead.

**Library Used**

There is no specific library used in this benchmark. However, it's worth noting that some browsers may use their own optimized JSON parsing methods, such as WebKit's `JSON.Parse()` or V8's `JSON.parse()`.

**Special JS Feature or Syntax**

This benchmark uses the `JSON.stringify()` and `JSON.parse()` methods, which are standard JavaScript features for working with JSON data. No special syntax is used here; only standard JavaScript functions and data structures.

**Other Alternatives**

If you're looking for alternative approaches to this benchmark, you could consider:

* Using a dedicated library like `json-stringify-safe` or `json-parse-saf navigator` which provide more secure and efficient parsing of JSON data.
* Implementing your own custom parser using techniques like recursive descent parsing or an AST-based approach.
* Using a JIT compiler or interpreter, such as V8 or SpiderMonkey, to execute the code.

Keep in mind that these alternatives may require significant changes to your benchmarking framework and infrastructure.

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 8.0.0; FIG-LX3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.99 Mobile Safari/537.36

Browser/OS: Chrome Mobile 71 on Android 8.0.0

View result in a separate tab

Test name	Executions per second
eval	99652.5 Ops/sec
new Function	154901.6 Ops/sec

Related benchmarks:

eval vs new Function 2 (version: 0)

Comparing performance of: eval vs new Function

Created: 5 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 28 days ago):