Benchmark: Map copy vs irect copy

Script Preparation code:

var objects = []

for (let i = 0; i < 100; i++) {
  const obj = {};
  const map = new Map()
  for (let j = 0; j < 10; j++) {
    const propName = Math.random().toString(36).substr(2, 10); // Generate a random 10-character string
    const propValue = Math.floor(Math.random() * 1000); // Generate a random integer between 0 and 999

    obj[propName] = propValue;
  }

  objects.push(obj);
}

Tests:

Copy objects
const new_objects = objects.map( (obj) => { return {...obj} })
Copy maps
const new_objects = objects

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Copy objects
Copy maps

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.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark definition and its test cases to understand what is being tested.

**Benchmark Definition**

The benchmark measures the performance difference between two approaches: copying objects using the spread operator (`{...obj}`) and copying objects directly by referencing the original object (`const new_objects = objects`).

In JavaScript, when you assign an object to a new variable, it creates a shallow copy of the original object. This means that if the original object has properties that are themselves objects or arrays, these inner objects or arrays will also be copied, but any references to them in the original object will be preserved.

The two approaches being tested differ in this regard:

*   **Copy objects using spread operator (`{...obj}`)**: This approach creates a shallow copy of each object in the `objects` array. It uses the spread operator (`{...obj}`) to create a new object with the same properties as the original object, but without copying any nested objects or arrays.
*   **Copy objects directly by referencing the original object (`const new_objects = objects`)**: This approach creates a shallow copy of each object in the `objects` array by simply assigning the `objects` array to a new variable. Since JavaScript references are passed-by-value, this approach will not create a deep copy, meaning any nested objects or arrays will be preserved as references.

**Pros and Cons**

*   **Copy objects using spread operator (`{...obj}`)**:
    *   Pros: This approach creates a shallow copy of each object in the array, which can help prevent unexpected side effects when modifying the copied objects.
    *   Cons: It may incur additional overhead due to the creation of new objects and their properties.
*   **Copy objects directly by referencing the original object (`const new_objects = objects`)**:
    *   Pros: This approach is generally faster, as it doesn't involve creating new objects or copying their properties.
    *   Cons: It can lead to unexpected side effects if the copied objects are modified and still referenced in the original array.

**Library**

There are no external libraries used in this benchmark.

**Special JS Features/Syntax**

This benchmark uses JavaScript features such as:

*   **Spread operator (`{...obj}`)**: This feature was introduced in ECMAScript 2015 (ES6) and allows for creating a new object with the same properties as an existing object.
*   **Reference-by-value**: In JavaScript, when you assign an object to a new variable, it creates a shallow copy of the original object. Any references to objects or arrays within the original object are preserved in the copied object.

**Other Alternatives**

If you're looking for alternative approaches to copying objects, consider using libraries like `lodash.cloneDeep()` or `json-stringify-safe`. These libraries provide more advanced methods for creating deep copies of objects and arrays.

Here's a brief example of how you could use these libraries:

```javascript
const _ = require('lodash');

// Using lodash
const newObjectsUsingLodash = _.cloneDeep(objects);

const newObjectsUsingJsonStringifySafe = JSON.stringify(objects, null, 2);
```

Keep in mind that using external libraries may add overhead and depend on the specific requirements of your application.

Related benchmarks:

Map copy vs irect copy (version: 0)

Comparing performance of: Copy objects vs Copy maps

Created: 3 years ago by: Guest

Jump to the latest result

Copy objects

Copy maps

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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