Benchmark: Constructed/Evaluated Function Test

Script Preparation code:

var dynamicFunction = new Function("a", "b", `
 	for(const value of new Array(a).keys())
    {
		if(value % b == 0) console.log(value);
    }
 `);

function realFunction(a, b)
{
 	for(const value of new Array(a).keys())
    {
		if(value % b == 0)
        {
          console.log(value);
        };
    }
}

Tests:

Real function
realFunction(10000, 7000);
Dynamic function
dynamicFunction(10000, 7000);
Evaluated function
const evalFunction = new Function("a", "b", ` for(const value of new Array(a).keys()) { if(value % b == 0) console.log(value); } `); evalFunction(10000, 7000);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Real function
Dynamic function
Evaluated function

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the JavaScript microbenchmark on MeasureThat.net.

**Benchmark Definition**

The benchmark is designed to test the performance of creating and running functions in JavaScript, specifically:

* Constructed functions (using `new Function` constructor)
* Evaluated functions (using `eval` function)

**Options Compared**

Three options are compared:

1. **Real function**: A pre-defined function `realFunction(a, b)` that performs a loop to check if values modulo `b` equals 0 and logs the result.
2. **Dynamic function**: A constructed function created using `new Function` constructor with the same logic as `realFunction`.
3. **Evaluated function**: An evaluated function created using `eval` function with the same logic as `realFunction`.

**Pros and Cons of Each Approach**

1. **Real function**:
	* Pros: Faster execution time since it's already defined and optimized.
	* Cons: Hardcoded implementation, limited flexibility.
2. **Dynamic function** (using `new Function` constructor):
	* Pros: More flexible, can be generated on the fly with user-provided parameters.
	* Cons: Performance overhead due to function creation and evaluation.
3. **Evaluated function** (using `eval` function):
	* Pros: Most flexible, can execute arbitrary JavaScript code.
	* Cons: Security risks if not sanitized, slower execution time due to parsing.

**Library and Purpose**

In this benchmark, no external libraries are used. However, the `Function` constructor is a built-in JavaScript feature that creates new functions dynamically.

**Special JS Feature/Syntax**

None mentioned in this specific benchmark.

**Other Considerations**

* **Function creation overhead**: Creating a function using `new Function` constructor can be slower than executing an existing function.
* **String interpolation**: The use of template literals (e.g., `\r\n \t`) for string interpolation is efficient and modern JavaScript's default behavior.

**Alternatives**

If you're looking to benchmark similar scenarios, consider the following alternatives:

1. Test creating and running functions with different parameters, such as using `new Function` constructor with varying number of arguments or complex expressions.
2. Compare performance of different function creation methods, like using `Function.prototype.toString()` or a library like `js-function-creator`.
3. Investigate the impact of optimization techniques, such as inlining or caching functions.

Please let me know if you have any further questions!

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/112.0.0.0 Safari/537.36 Edg/112.0.1722.39

Browser/OS: Chrome 112 on Windows

View result in a separate tab

Test name	Executions per second
Real function	23275.8 Ops/sec
Dynamic function	23533.9 Ops/sec
Evaluated function	22241.0 Ops/sec

Related benchmarks:

Constructed/Evaluated Function Test (version: 0)

You can create functions on the fly in Javascript through the new Function constructor (as an alternative to eval()). Are there any performance issues with that? Find out!

Comparing performance of: Real function vs Dynamic function vs Evaluated function

Created: one year ago by: Guest

Jump to the latest result

Real function

Dynamic function

Evaluated function

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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