Benchmark: Object spread vs new Map with complex data

Script Preparation code:

var data = new Array(1000000).fill(undefined).map((_,i) => i)
var obj = data.reduce((obj, idx) => {obj['idx' + Date.now()] = {name: 'Name: ' + Date.now(), age: idx}; return obj}, {});
var map = new Map(Object.entries(obj));

Tests:

Object spread
var copy = {...obj}
new Map
var copy = new Map(map)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object spread
new Map

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 dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided benchmark compares two approaches for creating a copy of an object: `Object spread` and `new Map`. The test case uses a complex data structure to create an object with a large number of properties, which is then copied using both methods.

**What are we testing?**

We're testing the performance of two different approaches:

1. **Object Spread (`var copy = {...obj}`)**: This method creates a new object by spreading the properties of the original `obj` object into a new object literal.
2. **new Map (`var copy = new Map(map)`)**: This method creates a new Map object from the entries in the original `map` object.

**Options compared**

The two approaches are compared in terms of their execution time, which is measured as the number of executions per second.

**Pros and Cons**

Here's a brief overview of each approach:

* **Object Spread (`var copy = {...obj}`)**:
	+ Pros: Easy to understand and implement. It creates a shallow copy of the object, which can be sufficient for many use cases.
	+ Cons: It only copies the top-level properties, not nested objects or arrays. It also has performance overhead due to object creation and property iteration.
* **new Map (`var copy = new Map(map)`)**:
	+ Pros: Creates a deep copy of the map, including nested objects and arrays. It's also more efficient than object spread for large datasets.
	+ Cons: Requires creating a new Map object, which has its own overhead. The `map` constructor also iterates over the entries, adding additional performance overhead.

**Library and Purpose**

In this benchmark, two libraries are used:

* **Map**: A built-in JavaScript library that provides a data structure for storing key-value pairs.
* **Array.prototype.fill()**: A method of the Array prototype that fills all elements in an array with a specified value.

The `map()` function is used to create a new map from the entries in the original object. The `fill()` method is used to create a large array of undefined values, which is then reduced and spread into the object.

**Special JS feature or syntax**

There are no special JavaScript features or syntax mentioned in this benchmark.

**Other alternatives**

If you're interested in exploring other approaches, here are some alternatives:

* **Lodash's `cloneDeep()` function**: A popular utility library that provides a deep clone function for objects and arrays.
* **JSON.parse(JSON.stringify(obj))**: This method creates a deep copy of an object using JSON serialization and parsing. However, it may not be suitable for all use cases due to potential issues with cyclic references.

Keep in mind that the choice of approach depends on your specific use case and requirements. Measuring performance is crucial to determine which approach best suits your needs.

Related benchmarks:

Object spread vs new Map with complex data (version: 0)

Comparing performance of: Object spread vs new Map

Created: 3 years ago by: Registered User

Jump to the latest result

Object spread

new Map

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):