Benchmark: Function call with raw arguments vs Array expansion

Script Preparation code:

my = new Object();

my.doit = function(a, b, c) {
  return a + b + c;
}

Tests:

eval with ...
eval("my.doit(...[1, 2, 3])")
eval
eval("my.doit(1, 2, 3)")
parse
var message = JSON.parse('["doit", [1, 2, 3]]'); my[message[0]](...message[1])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
eval with ...
eval
parse

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

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

Browser/OS: Chrome 90 on Windows

View result in a separate tab

Test name	Executions per second
eval with ...	1455670.6 Ops/sec
eval	1533345.0 Ops/sec
parse	1093509.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 benchmark and its options.

**Benchmark Purpose**
The benchmark measures the performance of two approaches to call the `my.doit` function with different numbers of arguments:

1. Using raw arguments (`eval("my.doit(1, 2, 3)")`)
2. Expanding the argument list using the spread operator (`eval("my.doit(...[1, 2, 3])")`)

**Options Compared**

* **Raw Arguments**: This approach uses `eval()` to pass individual arguments to the function. It's a simple and straightforward way to call a function with multiple arguments.
* **Expanding Argument List using Spread Operator**: This approach uses the spread operator (`...`) to expand the argument list into separate function calls. It's a more modern and efficient way to call functions with multiple arguments.

**Pros and Cons of Each Approach**

* **Raw Arguments**
	+ Pros: Simple, easy to understand, and widely supported.
	+ Cons: Can lead to performance issues due to the overhead of `eval()`, and can be vulnerable to security risks if not used carefully.
* **Expanding Argument List using Spread Operator**
	+ Pros: More efficient, faster execution, and less vulnerable to security risks than raw arguments. Also, it's a more modern and idiomatic way to call functions with multiple arguments in JavaScript.
	+ Cons: Requires support for the spread operator (`...`) and might not work in older browsers or environments.

**Library and Syntax Used**
The benchmark uses the `JSON.parse()` function to parse the argument list as an array. This is used in the third test case (`"parse"`). The spread operator (`...`) is also used to expand the argument list in this test case.

The benchmark does not use any special JavaScript features or syntax, apart from using `eval()` for raw arguments, which is a built-in function.

**Alternative Approaches**
Other approaches that could be used to call functions with multiple arguments include:

* **Array unpacking**: Using an array of arguments and then destructuring them into individual variables. For example: `var args = [1, 2, 3]; var result = my.doit(...args);`
* **Function overloading**: Implementing the function with different signature versions for different numbers of arguments.

It's worth noting that the benchmark is designed to test the performance of using raw arguments versus expanding argument lists using the spread operator. The results can be useful in understanding which approach is more efficient and suitable for specific use cases.

Related benchmarks:

Function call with raw arguments vs Array expansion (version: 0)

Compare raw arguments vs ... expansion.

Comparing performance of: eval with ... vs eval vs parse

Created: 3 years ago by: Guest

Jump to the latest result

eval with ...

eval

parse

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