Benchmark: variadics vs arrays

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

/*your preparation JavaScript code goes here
To execute async code during the script preparation, wrap it as function globalMeasureThatScriptPrepareFunction, example:*/
async function globalMeasureThatScriptPrepareFunction() {
    // This function is optional, feel free to remove it.
    // await someThing();
}

Tests:

variadic
function test(...args) { let finalRep = ''; for(const item of args) { finalRep = item.toString(); } return finalRep; } const frep = test('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y','z');
array
function test(args) { let finalRep = ''; for(const item of args) { finalRep = item.toString(); } return finalRep; } const frep = test(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y','z']);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
variadic
array

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
variadic	10713618.0 Ops/sec
array	11909563.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 16 days ago):

LLMs can make mistakes. Check important info.

This benchmark titled "variadics vs arrays" tests the performance differences between two ways of passing parameters to functions in JavaScript: using variadic parameters (`...args`) versus passing an array. Specifically, it examines whether the variadic syntax is faster or slower than traditional array argument passing when handling a set of string inputs.

### Options Compared

1. **Variadic Parameters (`...args`)**:
    - **Test Name**: "variadic"
    - **Benchmark Definition**:
      ```javascript
      function test(...args) {
          let finalRep = '';
          for (const item of args) {
              finalRep = item.toString();
          }
          return finalRep;
      }
      const frep = test('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z');
      ```
    - **Mechanism**: The function accepts any number of string arguments, stored in the `args` array-like structure. It converts each item to a string and keeps overwriting `finalRep` with the last string's value.

2. **Array as Argument**:
   - **Test Name**: "array"
   - **Benchmark Definition**:
      ```javascript
      function test(args) {
          let finalRep = '';
          for (const item of args) {
              finalRep = item.toString();
          }
          return finalRep;
      }
      const frep = test(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']);
      ```
   - **Mechanism**: This function takes a single array argument. It iterates through the array, converting each item to a string and overwriting `finalRep` similarly to the variadic version.

### Performance Results

The benchmark results show that:
- The function using the **array** approach executed at **11,909,563 executions per second**.
- The function using **variadic parameters** executed at **10,713,618 executions per second**.

### Pros and Cons

#### Variadic Parameters
- **Pros**:
  - More flexible, as you can pass a varying number of arguments without needing to wrap them in an array.
  - Can improve the readability of calls in certain scenarios.
  
- **Cons**:
  - Can incur a slightly higher overhead due to the creation of an array-like structure to hold arguments for each function call, which may result in slower performance.

#### Array as Argument
- **Pros**:
  - The approach can be more efficient for performance-sensitive applications, as it requires less overhead during argument preparation.
  - Easier to work with when you need to pass a predefined collection of items since they're already grouped in an array.

- **Cons**:
  - Requires you to create and potentially manage an array, which could be less intuitive when dealing with a dynamic number of arguments.

### Other Considerations
- The choice between these two methods doesn't just rest on performance; it also relates to code readability and maintainability depending on the specific use case at hand.
- For any performance-sensitive code, it's crucial to consider the potential overhead associated with the chosen method.

### Alternatives
- **Object Arguments**: Instead of using variadic parameters or arrays, an object can be used to encapsulate related data items. This approach can enhance clarity when many parameters are involved, though it may add some overhead in terms of object creation.
- **Rest Parameters in Combination with Arrays**: You can use a combination of array spread syntax (`...array`) and object destructuring to create even more flexible APIs.
  
These benchmarks help inform developers not only about performance but also guide them in choosing the right structure based on their specific use case.

Related benchmarks:

variadics vs arrays (version: 1)

testing wheter variadic params in functions are faster or slower than simply passing arrays as arguments

Comparing performance of: variadic vs array

Created: 16 days ago by: Guest

Jump to the latest result

variadic

array

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 16 days ago):