Benchmark: Merge+object.keys vs set vs for

Script Preparation code:

const a = { a: 1, b: 2 };
const b = { b: 3, c: 4 };

Tests:

Set
const s = new Set([ ...Object.keys(a), ...Object.keys(b), ]); const res = Array.from(s);
Merge
const c = { ...a, ...b }; const res = Object.keys(c);
For
const s = new Set(); for(const x in a) s.add(x); for(const x in b) s.add(x); const res = Array.from(s);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set
Merge
For

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

### Benchmark Overview

The benchmark titled "Merge+object.keys vs set vs for" evaluates three different methods for merging the keys from two JavaScript objects (`a` and `b`), specifically looking at how efficiently they can consolidate the unique keys. The benchmark compares the following approaches:

1. **Set**: Using the `Set` object combined with the spread operator to collect keys.
2. **Merge**: Using the object spread syntax to merge the objects directly and then retrieve the keys.
3. **For**: Utilizing traditional `for...in` loops to iterate over the objects and gather unique keys into a `Set`.

### Test Approaches

1. **Set**:
   - **Definition**: 
     ```javascript
     const s = new Set([...Object.keys(a), ...Object.keys(b)]);
     const res = Array.from(s);
     ```
   - **Pros**: 
     - Automatically handles duplicate keys due to the nature of `Set`, ensuring that each key is unique.
     - The spread operator (`...`) provides a concise way to combine arrays.
   - **Cons**: 
     - May have a performance overhead due to the creation of an intermediate array and then converting it back to an array with `Array.from`.
   - **Considerations**: The performance can vary broadly depending on object size but is generally effective for merging unique keys.

2. **Merge**:
   - **Definition**: 
     ```javascript
     const c = { ...a, ...b };
     const res = Object.keys(c);
     ```
   - **Pros**:
     - Simplicity and readability. The object spread syntax is very clear and easy to understand, merging objects seamlessly.
     - The final call to `Object.keys` produces a straightforward array of keys representing the merged object.
   - **Cons**: 
     - If `a` and `b` have large numbers of keys, this can lead to more memory usage since a new object is created.
   - **Considerations**: This syntax is well-optimized in modern JavaScript engines, making it typically very efficient.

3. **For**:
   - **Definition**: 
     ```javascript
     const s = new Set();
     for (const x in a) s.add(x);
     for (const x in b) s.add(x);
     const res = Array.from(s);
     ```
   - **Pros**:
     - Works well for environments that do not support the spread operator or object spread syntax, providing a backward-compatible solution.
     - No intermediate array is created directly in the merging process.
   - **Cons**: 
     - Slightly more verbose and less readable than the other methods.
     - The use of `for...in` can inadvertently include properties from the prototype chain unless safeguards are put in place (like checking `hasOwnProperty`).
   - **Considerations**: The performance could vary based on how many properties are added and whether prototype properties are involved.

### Benchmark Results

The benchmarking showed the following performance results (executions per second):

- **Merge**: 1,730,753.875
- **For**: 1,196,404.5
- **Set**: 761,872.0625

### Summary of Findings

- The **Merge** approach performed the best, indicating that the modern object spread syntax has been optimized in contemporary JavaScript engines for merging objects.
- The **For** loops were slower but still performed quite well, showcasing their reliability across different environments.
- The **Set** method, while clear and efficient in terms of deduplication, showed the slowest execution speed, likely influenced by the overhead of creating both a temporary array and the `Set`.

### Alternatives

Other alternatives to the methods evaluated can include:
- **Using `Array.prototype.filter`** combined with `concat` to filter out the unique keys which can be slower than the object spread:
  ```javascript
  const res = [...Object.keys(a).concat(Object.keys(b))]
    .filter((value, index, self) => self.indexOf(value) === index);
  ```
- **Using external libraries** like **Lodash**, which provides utility functions like `_.uniq` and `_.merge`:
  ```javascript
  const res = _.uniq([...Object.keys(a), ...Object.keys(b)]);
  ```
- **Immutable.js**: An additional option if working with a functional programming mindset that emphasizes immutability and persistent data structures.

These alternatives may offer different trade-offs in terms of readability, performance, and memory usage depending on the specific context of their implementation.

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 130 on Android

View result in a separate tab

Test name	Executions per second
Set	761872.1 Ops/sec
Merge	1730753.9 Ops/sec
For	1196404.5 Ops/sec

Related benchmarks:

Merge+object.keys vs set vs for (version: 2)

Comparing performance of: Set vs Merge vs For

Created: 17 days ago by: Registered User

Jump to the latest result

Set

Merge

For

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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