Benchmark: eval vs new Function vs function(Sample JS Functions) 2

Script Preparation code:

var newFunc = new Function("let r = Math.random().toString(36).substring(7).includes('x');");
var regular = function(){
let r = Math.random().toString(36).substring(7).includes('x');;
}

Tests:

eval
eval("let r = Math.random().toString(36).substring(7).includes('x');");
new Function
newFunc();
regular
regular()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
eval
new Function
regular

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 28 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36

Browser/OS: Chrome 134 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
eval	3811502.0 Ops/sec
new Function	5454155.5 Ops/sec
regular	5533500.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 28 days ago):

LLMs can make mistakes. Check important info.

The benchmark you're examining compares three different methods of executing JavaScript code: `eval`, `new Function`, and a regular function. It aims to assess the performance of these methods in the context of executing a specific operation: checking if a randomly generated string contains the character 'x'. Here’s a breakdown of the methods tested and their respective pros and cons:

### Options Compared

1. **eval**:
   - **Code**: `eval("let r = Math.random().toString(36).substring(7).includes('x');");`
   - **Description**: `eval` is a built-in JavaScript function that takes a string of JavaScript code and executes it. This can be useful for dynamic code execution but comes with performance implications and security risks.

2. **new Function**:
   - **Code**: `newFunc();` (where `newFunc` is defined using `var newFunc = new Function(...)`)
   - **Description**: The `new Function` constructor creates a new function from a string of code. It's similar to `eval` but does not share the local scope, which can isolate the executed code.

3. **Regular Function**:
   - **Code**: `regular()` (where `regular` is the standard function defined)
   - **Description**: This method wraps the code in a regular JavaScript function. It maintains the local scope and is typically faster than the previous two methods because it is compiled and optimized by the JavaScript engine.

### Performance Results

From the benchmark results:

- **Regular Function**: 5,533,500 executions per second
- **new Function**: 5,454,155.5 executions per second
- **eval**: 3,811,502 executions per second

### Pros and Cons

**1. eval**
   - **Pros**:
     - Dynamic execution of code as a string allows for flexible code generation.
   - **Cons**:
     - Significantly slower than other methods due to parsing and execution overhead.
     - Introduces security risks, such as code injection if the input is not properly sanitized.
     - Can lead to difficult-to-debug code and hinder optimization efforts by the JS engine.

**2. new Function**
   - **Pros**:
     - Avoids scope issues associated with `eval`, making it safer with respect to variable access.
     - Allows for dynamic code generation without polluting the current scope.
   - **Cons**:
     - Still slower compared to regular functions due to the inherent overhead in creating functions from strings.
     - Also poses potential security risks similar to `eval` if not used with caution.

**3. Regular Function**
   - **Pros**:
     - Fastest execution speed among the three, benefiting from compiler optimizations.
     - More readable and maintainable code as it adheres to best practices.
     - Secure since it doesn't execute strings of code that may be risky.
   - **Cons**:
     - Limited to static code, which means there is no dynamic execution capability without programmatically creating functions.

### Alternatives

Other alternatives to these methods for executing JavaScript code include:

- **Anonymous Functions**: Similar to regular functions, but defined inline. They retain the local scope and are usually optimized well by the engine.
- **Arrow Functions**: A more concise syntax for writing functions that also maintain the `this` context, providing a modern approach to defining functions.
- **Web Workers**: For heavy computations, using Web Workers can offload the execution to a separate thread, avoiding UI thread blocking while executing concurrent tasks.

In summary, while `eval` and `new Function` provide dynamic code execution capabilities, they come with notable performance and security drawbacks compared to regular functions. Understanding the nature of these methods allows developers to choose the appropriate approach based on their specific context and requirements.

Related benchmarks:

eval vs new Function vs function(Sample JS Functions) 2 (version: 1)

Comparing performance of: eval vs new Function vs regular

Created: 28 days ago by: Guest

Jump to the latest result

eval

new Function

regular

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 28 days ago):