Benchmark: eval vs Function vs lodash.template

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var model = {type: {test: "a"}, action: "show", first: "eval", second: "Function"};
var func = new Function("model", "return model.type");

Tests:

eval
eval('model.type')
Function
func(model);
lodash.template
_.template('${type}')(model);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
eval
Function
lodash.template

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:148.0) Gecko/20100101 Firefox/148.0

Browser/OS: Firefox 148 on Windows

View result in a separate tab

Test name	Executions per second
eval	4432798.0 Ops/sec
Function	2503586816.0 Ops/sec
lodash.template	49266.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

The test is comparing three different approaches to evaluate or manipulate data: `eval`, `Function`, and `lodash.template`. The goal is to determine which approach is the fastest, but we'll also discuss the pros and cons of each approach.

**1. eval**

`eval` is a built-in JavaScript function that executes a string as JavaScript code. In this case, the string contains an expression: `model.type`. When you use `eval`, it essentially "evaluates" the string at runtime, which can lead to security issues if not handled properly (e.g., using user-provided input).

Pros:

* Easy to implement, as it's a built-in function.
* Can be fast, but its performance depends on the complexity of the expression.

Cons:

* Security risks due to code injection vulnerabilities.
* Performance can degrade if the expression is complex or involves multiple operations.

**2. Function**

`Function` is another built-in JavaScript function that creates a new function object. In this case, we create a function that takes `model` as an argument and returns `model.type`. This approach uses a more explicit, function-calling mechanism.

Pros:

* More secure than `eval`, as it avoids code injection vulnerabilities.
* Can be just as fast as or faster than `eval`, depending on the complexity of the expression.

Cons:

* Requires manual creation of a function object, which can add overhead.

**3. lodash.template**

`lodash.template` is a utility function from the Lodash library that allows you to create a template engine for generating strings. In this case, it's used to generate a string with the value of `model.type` inserted into it using a template syntax (`${type}`). The resulting string can then be executed as code.

Pros:

* Provides a flexible and expressive way to manipulate data.
* Can be faster than using functions or `eval`, especially for complex expressions.

Cons:

* Requires additional setup and configuration (e.g., defining the template syntax).
* May have a higher overhead due to the creation of a new template engine object.

In the provided benchmark, we see that the execution times are:

1. `Function` (6,768,656 ms/second)
2. `eval` (233,768,949 ms/second)
3. `lodash.template` (325,62,796 ms/second)

Based on these results, it appears that `Function` is the fastest approach.

Keep in mind that these results are specific to this particular benchmark and might not generalize across all use cases or scenarios. Additionally, while performance is an important consideration, security and maintainability should also be taken into account when choosing a programming approach.

As for other alternatives, you could consider using:

* `toString()` and `eval()`: This approach uses the `toString()` method to convert the expression to a string and then evaluates it using `eval()`. While not as secure as `Function`, this approach can still be faster than `eval`.
* `String.prototype.replace()`: This approach uses regular expressions to replace placeholders in the template with actual values. While more readable, this approach might be slower due to the overhead of regular expression processing.
* Custom implementation using a parser or AST: Creating a custom parser or abstract syntax tree (AST) for your specific use case can provide optimal performance and control over the evaluation process.

Remember that each approach has its trade-offs, and the best choice depends on the specific requirements of your project.

Related benchmarks:

eval vs Function vs lodash.template (version: 0)

Comparing performance of: eval vs Function vs lodash.template

Created: 4 years ago by: Guest

Jump to the latest result

eval

Function

lodash.template

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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