Benchmark: Rest parameters vs array parameter

Tests:

Rest
const f = (a, ...b) => a.concat(b.map(String)) const r = f([0], 1, 2, 3, 4, 5);
Array
const f = (a, b) => a.concat(b.map(String)) const r = f([0], [1, 2, 3, 4, 5]);

Historical Performance Data aggregated from 29 community runs

Desktop Results:

Chrome 24 runs

Array

5.6M/s

Rest

5.5M/s

View exact numbers

✓ Array: 5,640,258 ops/sec
• Rest: 5,451,710 ops/sec

Firefox 5 runs

Array

9.0M/s

Rest

8.8M/s

View exact numbers

✓ Array: 8,990,575 ops/sec
• Rest: 8,757,485 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Rest
Array

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 9 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:152.0) Gecko/20100101 Firefox/152.0

Browser/OS: Firefox 152 on Windows

View result in a separate tab

Array

7.1M/s

Rest

7.0M/s

View exact numbers

Test name	Executions per second
✓ Array	7,057,207 Ops/sec
Rest	7,038,016 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**What is tested?**

The provided benchmark tests two approaches to passing multiple arguments to a function: using rest parameters (e.g., `...b`) and using an array as a parameter (e.g., `[1, 2, 3, 4, 5]`).

**Options compared**

Two options are being compared:

1. **Rest parameters**: This approach uses the `...` syntax to capture all remaining arguments into an array-like object called the "rest" parameter.
2. **Array parameter**: This approach passes the argument as a separate array.

**Pros and Cons of each approach**

**Rest Parameters:**

Pros:

* More concise and expressive code
* Avoids the need for explicit `concat` or array manipulation

Cons:

* Can be slower due to the overhead of creating an object with dynamic properties
* May have performance issues if used excessively, as it can lead to a lot of temporary objects being created

**Array Parameter:**

Pros:

* Faster execution speed, as arrays are typically more efficient than objects
* Less memory allocation, as arrays do not create temporary objects

Cons:

* Requires more code and is less concise
* May be more error-prone if the wrong type of argument is passed (e.g., an array instead of a variable number of arguments)

**Library usage**

There doesn't appear to be any libraries being used in this benchmark.

**Special JS features or syntax**

The `map` function is used to transform each element in the array, which is a common pattern in JavaScript. The `String` function is used as the mapping function, but it's not relevant to the rest parameters vs. array parameter comparison.

**Benchmark preparation code and HTML Preparation Code**

The provided benchmark definition includes script preparation code that defines two functions: `f` with rest parameters and `f` with an array parameter. There is no corresponding HTML preparation code.

**Other alternatives**

There are a few other ways to pass multiple arguments to a function in JavaScript:

* Using the spread operator (`...`): This can be used in combination with the rest parameter syntax or as an alternative to using arrays.
* Using `arguments`: This is an array-like object that contains all arguments passed to the function.
* Using destructuring: This can be used to extract specific values from the argument list, but it's not relevant to this benchmark.

Overall, the provided benchmark tests the performance difference between two approaches to passing multiple arguments to a JavaScript function.

Rest parameters vs array parameter (version: 0)

Comparing performance of: `Rest vs Array`

Created: 4 years ago by: Guest

Go to the latest result

Rest

Array

Historical Performance Data aggregated from 29 community runs

Desktop Results:

Chrome 24 runs

Firefox 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Rest parameters vs array parameter (version: 0)

Comparing performance of: Rest vs Array

Created: 4 years ago by: Guest

Go to the latest result

Rest

Array

Historical Performance Data aggregated from 29 community runs

Desktop Results:

Chrome 24 runs

Firefox 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `Rest vs Array`