Benchmark: Build vs copy object

Script Preparation code:

keys = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
values = [1, 2, 3, 4, 5, 6, 7, 9, 10];
templateObj = Object.fromEntries(keys.map(k => [k, undefined]));
pairs = keys.map((k, i) => [k, values[i]]);

Tests:

Build up object
const obj = {}; for (const [k, v] of pairs) { obj[k] = v; }
Use fromEntries
Object.fromEntries(pairs)
Copy and fill
const obj = {...templateObj}; for (const [k, v] of pairs) { obj[k] = v; }
Assign and fill
const obj = {}; Object.assign(obj, templateObj); for (const [k, v] of pairs) { obj[k] = v; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Build up object
Use fromEntries
Copy and fill
Assign and fill

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; rv:123.0) Gecko/20100101 Firefox/123.0

Browser/OS: Firefox 123 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
Build up object	10228327.0 Ops/sec
Use fromEntries	3587368.0 Ops/sec
Copy and fill	5112843.0 Ops/sec
Assign and fill	8851860.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided benchmark measures the performance of different approaches to add properties to an object in JavaScript. The test case consists of four variations:

1. **Build up object**: This approach iterates over an array of key-value pairs and adds each pair as an individual property to the object.
2. **Use fromEntries**: This approach uses the `Object.fromEntries()` method, which creates a new object from an array of key-value pairs.
3. **Copy and fill**: This approach creates a copy of an existing object using `const obj = {...templateObj};` and then iterates over an array of key-value pairs to add each pair as a property to the copied object.
4. **Assign and fill**: This approach uses `Object.assign()` to assign all properties from an object (`templateObj`) to a new object, followed by iterating over an array of key-value pairs to add each pair as a property to the resulting object.

**Comparison of Options**

| Approach | Pros | Cons |
| --- | --- | --- |
| Build up object | Simple, easy to understand, no overhead from creating an object | Can be slow for large datasets due to individual property assignments |
| Use fromEntries | Efficient and fast, eliminates need to iterate over properties individually | May not work in older browsers or with specific data types |
| Copy and fill | Fast and efficient, creates a copy of the original object | Requires extra memory allocation |
| Assign and fill | Easy to implement, leverages built-in `Object.assign()` method | Can be slower than other approaches due to string concatenation |

**Library and Special JS Feature**

The test case uses **Object.fromEntries()**, which is a modern JavaScript feature introduced in ECMAScript 2015 (ES6). It allows creating an object from an array of key-value pairs.

**Other Considerations**

* The benchmark measures the performance of each approach on a Desktop platform, running Firefox 123.
* The test case uses an object with 10 properties and corresponding values.
* The benchmark is designed to measure the execution time per second (ExecutionsPerSecond).

**Alternatives**

If you're interested in exploring alternative approaches or testing different JavaScript engines or browsers, here are some options:

* Use a different JavaScript engine like V8 (Chrome) or SpiderMonkey (Firefox)
* Test on different platforms (e.g., Mobile, WebAssembly)
* Experiment with other object creation methods, such as using `Object.create()` or `Array.prototype.map()`
* Try benchmarking other object-related operations, like property lookup or deletion

Related benchmarks:

Build vs copy object (version: 0)

Is it faster to add properties to an object one by one, or create an object with all of them and set values one by one?

Comparing performance of: Build up object vs Use fromEntries vs Copy and fill vs Assign and fill

Created: 2 years ago by: Guest

Jump to the latest result

Build up object

Use fromEntries

Copy and fill

Assign and fill

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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