Benchmark: Passing objects with raw values vs passing new objects with raw values vs passing just raw values vs array of values 2

Passing objects with raw values vs passing new objects with raw values vs passing just raw values vs array of values 2 (version: 0)

Updated to add 'Pass new object' & 'Pass re-created object', these reflect common real-world usage where the object contents are changing

Comparing performance of: Pass object vs Pass raw values vs Pass array vs Pass new object vs Pass re-created object

Created: 3 years ago by: Guest

Jump to the latest result

Script Preparation code:

var a = "Here's a string value";
var b = 5; // and a number
var c = false;

var object = {
  a, b, c
}

var array = [
  a, b, c
];

var passObject = (obj) => {
  return obj.a.length + obj.b * obj.c ? 2 : 1;
}

var passRawValues = (val_a, val_b, val_c) => {
  return val_a.length + val_b * val_c ? 2 : 1;
}

var passArray = (arr) => {
  return arr[0].length + arr[1] * arr[2] ? 2 : 1;
}


var x = 0;

Tests:

Pass object
x << 1; x ^= passObject(object);
Pass raw values
x << 1; x ^= passRawValues(a, b, c);
Pass array
x << 1; x ^= passArray(array);
Pass new object
x << 1; x ^= passObject({a, b, c});
Pass re-created object
object.a = a; object.b = b; object.c = c; x << 1; x ^= passObject(object);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Pass object
Pass raw values
Pass array
Pass new object
Pass re-created object

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.1:latest, generated one year ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its test cases.

**Benchmark Definition**

The benchmark compares the performance of passing objects with raw values, passing new objects with raw values, passing just raw values, and passing an array of values. This is done to determine which approach is the most efficient in terms of execution speed.

**Test Cases**

There are five test cases:

1. **Pass object**: Passes a pre-existing object (`object`) to the `passObject` function.
2. **Pass raw values**: Passes individual raw values (`a`, `b`, and `c`) to the `passRawValues` function.
3. **Pass array**: Passes an array of values (`array`) to the `passArray` function.
4. **Pass new object**: Creates a new object with raw values using object literal syntax (`{a, b, c}`) and passes it to the `passObject` function.
5. **Pass re-created object**: Re-creates an object by assigning individual raw values to an existing object (`object`) and then passing it to the `passObject` function.

**Library**

No external library is used in this benchmark.

**JavaScript Features/Syntax**

The following JavaScript features or syntax are used:

1. **Object literal syntax**: `{a, b, c}` creates a new object with properties `a`, `b`, and `c`.
2. **Arrow functions**: `(obj) => { ... }` defines an arrow function that takes an argument `obj`.

**Pros/Cons of Each Approach**

Here are some general pros and cons for each approach:

1. **Passing objects**:
	* Pros: Can be more readable and easier to maintain if the object structure is complex.
	* Cons: May incur performance overhead due to JavaScript's property lookup mechanism.
2. **Passing raw values**:
	* Pros: Can be faster than passing objects, especially for simple data structures.
	* Cons: May be less readable and more prone to errors if the number of arguments increases.
3. **Passing arrays**:
	* Pros: Can be faster than passing objects or raw values, especially for large datasets.
	* Cons: May require additional memory allocation and copying overhead.

**Other Considerations**

1. **Cache locality**: The performance difference between these approaches may vary depending on cache locality. If the data is mostly accessed in contiguous memory locations, passing arrays may perform better.
2. **Object creation overhead**: Creating a new object using `new` or an object literal syntax may incur additional overhead compared to re-creating an existing object.

**Alternatives**

Other alternatives for passing data between functions include:

1. **Passing JSON data**: Convert the data to JSON format and pass it as a string.
2. **Using callback functions**: Define a callback function that takes the required arguments and returns the result.
3. **Using message passing**: Use message passing mechanisms, such as Web Workers or SharedArrayBuffer, to transfer data between threads or processes.

Keep in mind that these alternatives may have their own trade-offs and performance implications.

Related benchmarks: