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

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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!

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: 3 years ago by: Guest

Jump to the latest result

Real function

Dynamic function

Evaluated function

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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