Benchmark: Rest parameters vs array parameter with empty parameters

Script Preparation code:

fr = (a, ...b) => a.concat(b.map(String))
fa = (a,    b) => a.concat(b.map(String))

af = [1, 2, 3, 4, 5];
ae = [];

Tests:

Rest
const r = fr([0], 1, 2, 3, 4, 5);
Array
const r = fa([0], [1, 2, 3, 4, 5]);
Rest Empty
const r = fr([0]);
Array Empty
const r = fa([0], []);
Array Predefined
const r = fa([0], af);
Array Empty Predefined
const r = fa([0], ae);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Rest
Array
Rest Empty
Array Empty
Array Predefined
Array Empty Predefined

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.1 Safari/605.1.15

Browser/OS: Safari 15 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Rest	3946815.0 Ops/sec
Array	3711217.5 Ops/sec
Rest Empty	5080134.5 Ops/sec
Array Empty	4930416.5 Ops/sec
Array Predefined	3038471.5 Ops/sec
Array Empty Predefined	4024380.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The provided JSON defines a benchmark named "Rest parameters vs array parameter with empty parameters". This benchmark tests two different approaches to handling rest parameters (the dots `...` in function arguments) versus using an array as a parameter.

**Options Compared**

Two options are compared:

1. **Rest Parameters**: Using the syntax `fr = (a, ...b) => a.concat(b.map(String))`. This approach uses the rest parameter syntax to capture any additional arguments passed to the function.
2. **Array Parameter with Empty Parameters**: Using the syntax `fa = (a, b) => a.concat(b.map(String))` and calling it with an array `[0]`, which represents an empty set of parameters.

**Pros and Cons**

* **Rest Parameters**:
	+ Pros: More concise and expressive way to handle variable-length function arguments.
	+ Cons: May have performance implications due to the need for `map()` on the rest parameter, which can be slower than using a traditional array.
* **Array Parameter with Empty Parameters**:
	+ Pros: Can provide a more predictable performance profile, as the number of operations is fixed.
	+ Cons: Less concise and less expressive than rest parameters.

**Library**

The benchmark uses the `String` function to concatenate strings. This is likely due to the fact that JavaScript's built-in string concatenation operator (`+`) has some issues with Unicode characters, whereas `String()` ensures a consistent behavior across different platforms.

**Special JS Feature/Syntax**

This benchmark does not use any special or experimental JavaScript features. It only uses standard language syntax and built-in functions.

**Other Alternatives**

If you're looking for alternative approaches to handling rest parameters, you could consider:

* Using `apply()` or `call()` to pass an array of arguments to a function.
* Implementing your own custom rest parameter parser.
* Using a library like `restify` that provides a more robust and expressive way to handle rest parameters.

Keep in mind that the choice of approach depends on your specific use case, performance requirements, and personal preference.

Related benchmarks:

Rest parameters vs array parameter with empty parameters (version: 0)

Comparing performance of: Rest vs Array vs Rest Empty vs Array Empty vs Array Predefined vs Array Empty Predefined

Created: 3 years ago by: Guest

Jump to the latest result

Rest

Array

Rest Empty

Array Empty

Array Predefined

Array Empty Predefined

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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