Benchmark: eval vs string - MeasureThat.net

HTML Preparation code:


<div id=''></div>

Script Preparation code:

data = JSON.stringify({
    str  : 'string',
    num  : 0,
    arr  : [1, 2, 3],
    bool : true,
    nil  : null,
});

dataEval = '{"str":"string","num":0,"arr":[1,2,3],"bool":true,"nil":null}';

Tests:

plain json
JSON.parse(data);
eval
eval('(' + dataEval + ')');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
plain json
eval

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 86 on Windows

View result in a separate tab

Test name	Executions per second
plain json	746397.0 Ops/sec
eval	1300324.8 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 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.

**Benchmark Definition**

The benchmark definition represents a JavaScript code snippet that is executed repeatedly to measure its performance. In this case, there are two benchmark definitions:

1. `JSON.parse(data);`
2. `eval('(' + dataEval + ')');`

These two definitions are compared in the individual test cases.

**Options being compared**

In the first benchmark definition, `JSON.parse(data);`, a string is parsed into a JavaScript object using the `JSON` method. In the second benchmark definition, `eval('(' + dataEval + ')');`, a string is evaluated as JavaScript code using the `eval()` function.

**Pros and Cons of each approach**

1. **JSON.parse(data);**
	* Pros:
		+ Faster execution time due to optimized parsing algorithm.
		+ Less memory usage since it doesn't create a new scope or function call stack.
	* Cons:
		+ Requires the input data to be a valid JSON string, which may not always be the case.
2. **eval('(' + dataEval + ')');**
	* Pros:
		+ Can evaluate arbitrary JavaScript code, making it more flexible.
	* Cons:
		+ Slower execution time due to the overhead of creating a new scope and function call stack.
		+ More memory usage since it creates a new scope and function call stack.

**Library: JSON**

The `JSON` library is used in the first benchmark definition to parse the input string into a JavaScript object. The `JSON.parse()` method is a built-in JavaScript method that parses a JSON string into a JavaScript object.

**Special JS feature or syntax (not applicable in this case)**

There are no special JavaScript features or syntax used in these benchmark definitions.

Now, let's analyze the individual test cases:

1. **plain json**
	* This test case compares the execution time of parsing a JSON string using `JSON.parse(data);` to executing the same code using `eval('(' + dataEval + ')');`.
2. **eval**
	* This test case compares the execution time of evaluating a JavaScript string using `eval('(' + dataEval + ')');` to executing the same code using `JSON.parse(data);`.

**Other alternatives**

Some alternative approaches that could be used instead of `JSON.parse()` and `eval()` are:

1. **Parsing with a custom parser**: Instead of using the built-in `JSON.parse()` method, you could implement a custom parser to parse the JSON string.
2. **Using a different evaluation function**: You could use a different evaluation function, such as `Function(dataEval)` or `new Function(dataEval)`, instead of `eval('(' + dataEval + ')')`.

However, these alternatives are not typically used in practice due to their potential performance overhead and complexity.

I hope this explanation helps!

Related benchmarks:

eval vs string (version: 0)

Comparing performance of: plain json vs eval

Created: 4 years ago by: Guest

Jump to the latest result

plain json

eval

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):