Benchmark: JS multiple parameters vs parameter object two functions

Script Preparation code:

var data = {
    a: 1,
    b: 2,
    c: 3,
    d: 4,
    e: 5,
    f: 6,
    g: 7
}

function f1(a, b, c, d, e, f, g) {
    return a + b + c + d + e + f + g;
}

function f2({
    a,
    b,
    c,
    d,
    e,
    f,
    g
}) {
    return a + b + c + d + e + f + g;
}

Tests:

Multiple parameters
f1(data.a, data.b, data.c, data.d, data.e, data.f, Math.random())
Existing parameter object
data.g = Math.random(); f2(data)
Parameter object with spreading
f2({ ...data, g: Math.random() })
New parameter object
f2({ a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: Math.random() })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Multiple parameters
Existing parameter object
Parameter object with spreading
New parameter object

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/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

Browser/OS: Chrome 120 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Multiple parameters	3902959.0 Ops/sec
Existing parameter object	6951874.0 Ops/sec
Parameter object with spreading	7182855.5 Ops/sec
New parameter object	11536934.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript benchmark test case on the MeasureThat.net website. The test compares the execution performance of two functions, `f1` and `f2`, which are designed to calculate the sum of multiple parameters.

**Function `f1`**

Function `f1` takes seven separate arguments: `a`, `b`, `c`, `d`, `e`, `f`, and `g`. The function returns their sum.

```javascript
function f1(a, b, c, d, e, f, g) {
    return a + b + c + d + e + f + g;
}
```

**Function `f2`**

Function `f2` takes an object with six properties: `a`, `b`, `c`, `d`, `e`, and `f`. The function returns the sum of these properties.

```javascript
function f2({ a, b, c, d, e, f }) {
    return a + b + c + d + e + f;
}
```

**Options being compared**

The benchmark test compares four different scenarios:

1. **Multiple parameters (`f1`)**: Calling `f1` with seven separate arguments.
2. **Existing parameter object (`f2`)**: Passing an existing object `data` to `f2`.
3. **Parameter object with spreading (`f2`)**: Creating a new object by spreading `data` and adding a new property `g`.
4. **New parameter object (`f2`)**: Passing a new object with all six properties explicitly set.

**Pros and cons of each approach**

1. **Multiple parameters (`f1`)**:
	* Pros: Simple and straightforward.
	* Cons: May require more memory allocation for the arguments, as they are passed separately.
2. **Existing parameter object (`f2`)**:
	* Pros: More efficient than passing separate arguments, as it reuses the existing object.
	* Cons: The function signature is less explicit, as it relies on the `data` object being available.
3. **Parameter object with spreading (`f2`)**:
	* Pros: Creates a new object, which can be useful for immutability or encapsulation.
	* Cons: May incur additional overhead due to object creation and property addition.
4. **New parameter object (`f2`)**:
	* Pros: Most explicit and controlled way of passing parameters.
	* Cons: May result in more memory allocation and potential performance hits.

**Library usage**

Function `f1` does not use any libraries explicitly, but it relies on the JavaScript language itself for execution.

Functions `f2`, however, implicitly rely on the `Object` type and its methods (e.g., `{ a, b, c, d, e, f }`). The spread operator (`{ ...data, g: Math.random() }`) used in the "Parameter object with spreading" test case is also part of the JavaScript language.

**Special JS feature or syntax**

The benchmark uses the `Math.random()` function to generate a random value for some tests. This is a built-in JavaScript function that returns a pseudo-random number between 0 (inclusive) and 1 (exclusive).

Overall, this benchmark provides a fair comparison of different approaches to passing parameters to functions in JavaScript, highlighting the trade-offs between simplicity, efficiency, and explicitness.

Related benchmarks:

JS multiple parameters vs parameter object two functions (version: 0)

Comparing performance of: Multiple parameters vs Existing parameter object vs Parameter object with spreading vs New parameter object

Created: 2 years ago by: Guest

Jump to the latest result

Multiple parameters

Existing parameter object

Parameter object with spreading

New parameter object

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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