Benchmark: jAg's comparison of unzipping, possibly modifying, and rezipping objects

jAg's comparison of unzipping, possibly modifying, and rezipping objects (version: 0) Benchmark.js

You've got an object with a bunch of fields. You want to iterate through each field and if it matches a certain set of values/state, you want to modify it, and then get the final updated object (ie not just the updated values, but all the unchanged values too. The only thing that doesn't matter is the original value).

Comparing performance of: `Object.entries -> map -> Object.fromEntries vs Object.entries -> reduce (single object) vs Object.entries -> map -> reduce (single object) vs Object.entries -> reduce (temporary objects) vs Object.entries -> map -> reduce (temporary objects) vs new map -> loop over object.entries -> Object.fromEntries`

Created: 2 years ago by: Guest

Go to the latest result

Script Preparation code:

data = {};
const ITERATIONS = 1_000;
for (i = 0; i < ITERATIONS; ++i) {
  data[i] = Math.random();
}

function switcher(i) {
  return i < 0.5 ? i : i.toString();
}

Tests:

Object.entries -> map -> Object.fromEntries
Object.fromEntries(Object.entries(data).map((key, value) => [key, switcher(value)]));
Object.entries -> reduce (single object)
Object.entries(data).reduce((acc, [k, v]) => { acc[k] = switcher(v) return acc; }, {});
Object.entries -> map -> reduce (single object)
Object.entries(data).map(([k, v]) => [k, switcher(v)]).reduce((acc, [k, v]) => { acc[k] = v return acc; }, {});
Object.entries -> reduce (temporary objects)
Object.entries(data).reduce((acc, [k, v]) => ({ ...acc, [k]: switcher(v) }), {});
Object.entries -> map -> reduce (temporary objects)
Object.entries(data).map(([k, v]) => [k, switcher(v)]).reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {});
new map -> loop over object.entries -> Object.fromEntries
m = new Map(Object.entries(data)) for([k, v] of Object.entries(data)) { const newV = switcher(v); if (newV !== v) { m.set(k, newV); } } Object.fromEntries(m)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.entries -> map -> Object.fromEntries
Object.entries -> reduce (single object)
Object.entries -> map -> reduce (single object)
Object.entries -> reduce (temporary objects)
Object.entries -> map -> reduce (temporary objects)
new map -> loop over object.entries -> Object.fromEntries

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36

Browser/OS: Chrome 122 on Linux

View result in a separate tab

Object.entries -> reduce (single object)

3K/s

Object.entries -> map -> reduce (single object)

3K/s

Object.entries -> map -> reduce (temporary objects)

875/s

Object.entries -> reduce (temporary objects)

818/s

Object.entries -> map -> Object.fromEntries

425/s

new map -> loop over object.entries -> Object.fromEntries

388/s

View exact numbers

Test name	Executions per second
✓ Object.entries -> reduce (single object)	3,069 Ops/sec
Object.entries -> map -> reduce (single object)	2,601 Ops/sec
Object.entries -> map -> reduce (temporary objects)	875 Ops/sec
Object.entries -> reduce (temporary objects)	818 Ops/sec
Object.entries -> map -> Object.fromEntries	425 Ops/sec
new map -> loop over object.entries -> Object.fromEntries	388 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what is being tested in the provided JSON benchmark.

**Benchmark Overview**

The test aims to compare four different approaches for iterating through an object and modifying its values:

1. **`Object.entries -> reduce (single object)`**: Using `Object.entries()` to get an array of key-value pairs, then reducing it using the spread operator (`...`) to create a new object.
2. **`Object.entries -> map -> reduce (single object)`**: Similar to the first approach, but after mapping the values, it reduces them again using the spread operator.
3. **`Object.entries -> map -> reduce (temporary objects)`**: The same as the second approach, but instead of reducing the mapped values directly, it creates temporary objects and then merges them into a single object.
4. **`new map -> loop over object.entries -> Object.fromEntries`**: Using `Map()` to create an iterable mapping of key-value pairs from `object.entries()`, looping through it, modifying the values if necessary, and finally converting it back to an object using `Object.fromEntries()`.

**Library/Functionality Used**

* `Object.entries()`: Returns an array of a given object's own enumerable string-keyed property [key, value] pairs.
* `Map()`: Creates a new Map data structure that can store mappings (key-value pairs).
* Spread operator (`...`): Used to create a new object by spreading the properties of another object.

**Special JS Feature/Syntax**

The benchmark uses the spread operator (`...`) and destructuring assignment (`[k, v] = ...`). These are built-in JavaScript features that allow for concise code. The use of `Object.entries()` is also a modern JavaScript feature introduced in ES6.

**Pros and Cons of Each Approach**

Here's a brief summary:

1. **`Object.entries -> reduce (single object)`**: Pros: Most efficient, as it only involves two operations. Cons: May not be as readable or maintainable for complex objects.
2. **`Object.entries -> map -> reduce (single object)`**: Pros: Similar to the first approach but with an extra step of mapping. Cons: Additional overhead from mapping and reducing.
3. **`Object.entries -> map -> reduce (temporary objects)`**: Pros: More readable than the second approach, as it breaks down the operations into smaller steps. Cons: Creates temporary objects, which can lead to memory allocation issues for large datasets.
4. **`new map -> loop over object.entries -> Object.fromEntries`**: Pros: Can be more efficient when dealing with large datasets, as it avoids creating intermediate objects. Cons: More complex code and may require additional imports or setup.

**Other Alternatives**

Some alternative approaches to consider:

* Using `forEach()` instead of reducing a single object.
* Using `for...of` loop for iterating over the object's entries.
* Using `Object.fromEntries()` with an array of key-value pairs instead of creating an intermediate object.
* Using a library like Lodash, which provides more functional programming-inspired utilities for working with objects.

Keep in mind that each approach has its trade-offs and may be more or less suitable depending on the specific use case and performance requirements.