Benchmark: new Function vs Literal

Script Preparation code:

var func = new Function("return 2 * 3");

Tests:

new Function
func();
Literal
`${2*3}`

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new Function
Literal

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/87.0.4280.88 Safari/537.36

Browser/OS: Chrome 87 on Windows

View result in a separate tab

Test name	Executions per second
new Function	10528769.0 Ops/sec
Literal	1308291328.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark is comparing two approaches to create a simple function that returns the result of `2 * 3`. The two approaches are:

1. **new Function**: Creating a new function using the `new Function` constructor.
2. **Literal**: Using template literals (the syntax `${expression}`) to create an expression that evaluates to the desired result.

**Options Compared**

In this benchmark, we're comparing the performance of these two approaches:

* **new Function**: This approach creates a new function that takes no arguments and returns the result of evaluating the provided string as JavaScript code.
* **Literal**: This approach uses template literals (the syntax `${expression}`) to create an expression that evaluates to the desired result. In this case, `2 * 3` is evaluated directly in the expression.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **new Function**:
	* Pros:
		+ Allows for more flexibility in creating functions with multiple arguments.
		+ Can be used to create functions that don't have a specific name (e.g., anonymous functions).
	* Cons:
		+ Can lead to slower performance due to the overhead of creating and executing the function.
2. **Literal**:
	* Pros:
		+ Faster execution speed, as it doesn't involve creating an additional function object.
	* Cons:
		+ Limited flexibility, as it only allows for simple expressions.
		+ Requires the use of template literals (which may not be familiar to all developers).

**Library and Special JS Feature**

There are no libraries used in this benchmark.

**Special JS Features**

The benchmark uses a special JavaScript feature called **template literals** (`${expression}`), which was introduced in ECMAScript 2015. Template literals allow you to embed expressions directly within strings, making it easier to create string representations of values or expressions. This feature is supported by most modern browsers and JavaScript engines.

**Other Alternatives**

If you wanted to compare other approaches to creating simple functions, some alternatives might include:

* Using a `Function` constructor with arguments (e.g., `new Function("return 2 * 3")`)
* Using an arrow function (`(x) => x * 2`)
* Using a string expression with backticks (e.g., `let func = 'return 2 * 3';`)

Related benchmarks:

new Function vs Literal (version: 0)

Comparing performance of: new Function vs Literal

Created: 4 years ago by: Guest

Jump to the latest result

new Function

Literal

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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