Benchmark: new Function vs function

Script Preparation code:

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

Tests:

new Function
newFunc();
regular
regular()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new Function
regular

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 116 on Windows

View result in a separate tab

Test name	Executions per second
new Function	3513006.2 Ops/sec
regular	2350330.5 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 JSON data and explain what is being tested.

**Benchmark Definition**

The benchmark definition is comparing two approaches to creating a function in JavaScript:

1. **`new Function()`**: This approach creates a new function using the `Function` constructor, which takes a string argument containing the function body.
2. **`function(){...}`**: This approach creates an anonymous function using the `function` keyword followed by the function body.

**Options Compared**

The two approaches are being compared in terms of their performance, specifically the number of executions per second.

**Pros and Cons**

* **`new Function()`**:
	+ Pros: Can be useful when you need to create a function dynamically based on user input or external data.
	+ Cons: Can lead to security vulnerabilities if not sanitized properly (e.g., using user-provided input).
* **`function(){...}`**: This is the traditional and recommended way of creating functions in JavaScript. It's faster, more readable, and provides better support for features like closures and binding.

**Library and Purpose**

There doesn't appear to be any external library being used in this benchmark.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax mentioned in the benchmark definition or test cases. However, it's worth noting that the `Function` constructor has some interesting properties and behaviors that can affect performance, such as:

* **Caching**: The `Function` constructor caches the created function, which means that if you create multiple functions with the same code, they will share the same cache entry.
* **Evaluation**: When you call a function created using `new Function()`, it is evaluated immediately, whereas functions created using the `function` keyword are only evaluated when called.

**Other Alternatives**

Some alternative approaches to creating functions in JavaScript include:

* Using a library like `bind()` or `arrow functions` (introduced in ECMAScript 2015) to create functions with specific behavior.
* Using a templating engine or string manipulation library to generate function code dynamically.
* Implementing your own function factory pattern using a class or constructor function.

In summary, the benchmark is testing two fundamental approaches to creating functions in JavaScript: `new Function()` and the traditional `function(){...}` syntax. The results will likely show that the latter approach is faster and more efficient.

Related benchmarks:

new Function vs function (version: 0)

Comparing performance of: new Function vs regular

Created: one year ago by: Guest

Jump to the latest result

new Function

regular

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):