Benchmark: rest args vs arguments, spread vs apply

Script Preparation code:

let c1 = 0;
function f1() {
  	'use strict';
	c1++;
}

let c2 = 0;
function f2() {
  	'use strict';
	c2++;
}

let c3 = 0;
function f3() {
  	'use strict';
	c3++;
}

let c4 = 0;
function f4() {
  	'use strict';
	c4++;
}

function testRestArgsSpread(...args) {
  	f1(...args);
}

function testRestArgsApply(...args) {
  	f2.apply(undefined, args);
}

function testArgumentsSpread(...args) {
  	f3(...arguments);
}

function testArgumentsApply(...args) {
  	f4.apply(undefined, arguments);
}

Tests:

rest args spread
testRestArgsSpread('a', 1, 'b', 2, 'c', 3);
rest args apply
testRestArgsApply('a', 1, 'b', 2, 'c', 3);
arguments spread
testArgumentsSpread('a', 1, 'b', 2, 'c', 3);
arguments apply
testArgumentsApply('a', 1, 'b', 2, 'c', 3);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
rest args spread
rest args apply
arguments spread
arguments apply

Fastest: N/A

Slowest: N/A

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/125.0.0.0 Safari/537.36

Browser/OS: Chrome 125 on Windows

View result in a separate tab

Test name	Executions per second
rest args spread	5085720.5 Ops/sec
rest args apply	2951917.0 Ops/sec
arguments spread	5207289.5 Ops/sec
arguments apply	2937542.8 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided benchmark measures the performance difference between three ways of handling variable arguments in JavaScript: rest parameters (`...args`), spread operators (`...`), and the `apply()` method.

Let's break down each approach:

1. **Rest Parameters**: The syntax `function testRestArgsSpread(...args) {...}` allows the function to accept a variable number of arguments, which are collected into an array called `args`. This approach is concise and easy to read.
2. **Spread Operators**: The syntax `function testArgumentsSpread(...args) {...}` also allows the function to accept a variable number of arguments. However, instead of collecting them into an array, they are spread across multiple parameters, making it less readable than rest parameters.
3. **Apply Method**: The syntax `function testArgumentsApply(...args) {...}` uses the `apply()` method to call another function with a given this value and arguments. This approach is not as concise or readable as rest parameters.

**Pros and Cons**

*   Rest Parameters:
    *   Pros: concise, easy to read, flexible.
    *   Cons: less familiar to older JavaScript developers.
*   Spread Operators:
    *   Pros: allows for more explicit parameter names, can be useful in certain situations.
    *   Cons: less readable than rest parameters, not as common.
*   Apply Method:
    *   Pros: flexible, can be used with any function.
    *   Cons: less concise and readable than rest parameters.

**Library Usage**

In the benchmark script, the `strict` mode is used, which is a built-in JavaScript feature that helps prevent common errors. There is no external library usage in this benchmark.

**JavaScript Features**

The benchmark uses some special JavaScript features:

*   **Rest Parameters**: Introduced in ECMAScript 2015 (ES6), rest parameters allow functions to accept a variable number of arguments.
*   **Spread Operators**: Also introduced in ES6, spread operators provide a concise way to expand arrays or objects into multiple parameters.

**Alternatives**

If you're interested in exploring other alternatives for handling variable arguments:

*   **Arrow Functions with Rest Parameters**: You can use arrow functions to simplify the syntax of rest parameter-based functions.
*   **Rest Parameter Arrays**: Instead of using rest parameters, you can create an array from the function's arguments.

Example: `let testRestArgsSpread = (...args) => { ... };`

Overall, this benchmark helps users understand the performance difference between different approaches to handling variable arguments in JavaScript.

Related benchmarks:

rest args vs arguments, spread vs apply (version: 0)

Comparing performance of: rest args spread vs rest args apply vs arguments spread vs arguments apply

Created: 2 years ago by: Guest

Jump to the latest result

rest args spread

rest args apply

arguments spread

arguments apply

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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