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

jAg's comparison of unzipping, possibly modifying, and rezipping objects with 31 fields (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 = 31;
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)

74K/s

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

67K/s

Object.entries -> reduce (temporary objects)

49K/s

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

46K/s

Object.entries -> map -> Object.fromEntries

19K/s

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

13K/s

View exact numbers

Test name	Executions per second
✓ Object.entries -> reduce (single object)	74,208 Ops/sec
Object.entries -> map -> reduce (single object)	67,067 Ops/sec
Object.entries -> reduce (temporary objects)	48,937 Ops/sec
Object.entries -> map -> reduce (temporary objects)	45,801 Ops/sec
Object.entries -> map -> Object.fromEntries	19,192 Ops/sec
new map -> loop over object.entries -> Object.fromEntries	12,691 Ops/sec

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!

**Benchmark Overview**

The provided benchmark tests different approaches to iterating through an object and modifying its properties based on certain conditions. The object in question has 31 fields, which are randomly assigned values.

**Options Compared**

There are four main options compared:

1. **`Object.entries -> reduce (single object)`**: This approach uses the `reduce()` method to iterate through the object's entries and modify the corresponding property.
2. **`Object.entries -> map -> reduce (single object)`**: This approach first maps over the object's entries, then applies the `reduce()` method to create a new object with modified properties.
3. **`Object.entries -> reduce (temporary objects)`**: Similar to option 1, but instead of using an empty object as the accumulator, a temporary object is created and updated on each iteration.
4. **`new map -> loop over object.entries -> Object.fromEntries`**: This approach uses a `Map` to store modified values and then converts it back to an object using `Object.fromEntries()`.

**Pros and Cons**

1. **`Object.entries -> reduce (single object)`**:
	* Pros: Simple, efficient, and easy to understand.
	* Cons: May not be suitable for objects with a large number of entries, as the accumulator can become too large.
2. **`Object.entries -> map -> reduce (single object)`**:
	* Pros: Can handle larger objects by mapping over each entry individually.
	* Cons: Adds an extra step, which may introduce overhead.
3. **`Object.entries -> reduce (temporary objects)`**:
	* Pros: Similar to option 1 but avoids creating a large accumulator object.
	* Cons: Still uses an accumulator object, which can lead to memory issues for very large inputs.
4. **`new map -> loop over object.entries -> Object.fromEntries`**:
	* Pros: Can handle large objects without creating an accumulator or temporary objects.
	* Cons: May be slower due to the use of `Map` and `Object.fromEntries()`.

**Libraries Used**

None, as this benchmark is built into MeasureThat.net's framework.

**Special JavaScript Features/Syntax**

None mentioned in the provided code. However, some benchmark options might rely on specific browser features or implementations, which could affect performance.

**Alternatives**

If you're interested in exploring alternative approaches, consider the following:

1. Using `for...of` loops instead of `reduce()` or `map()`.
2. Utilizing libraries like Lodash or Underscore.js for more complex iteration patterns.
3. Investigating other data structure options, such as a stack or queue, for iterative processing.

Keep in mind that these alternatives might introduce additional overhead or complexity, so it's essential to carefully evaluate their performance impact in your specific use case.