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

jAg's comparison of unzipping, possibly modifying, and rezipping objects with 250 fields (version: 0)

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: 8 months ago by: Guest

Jump to the latest result

Script Preparation code:

data = {};
const ITERATIONS = 250;
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

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The benchmark measures the performance of different approaches for iterating through an object, modifying its values, and creating a new object from it. The input data is a large object with 250 fields, each initialized with a random value between 0 and 1.

**Approach Comparison**

There are four main approaches compared in this benchmark:

1. **Object.entries -> reduce (single object)**: Uses `reduce` to iterate through the object's entries, modifying the values and creating a new object.
2. **Object.entries -> map -> reduce (single object)**: Uses `map` to transform the entries, then uses `reduce` to create a new object.
3. **Object.entries -> map -> reduce (temporary objects)**: Similar to the previous approach, but creates temporary objects during the iteration process.
4. **new Map -> loop over object.entries -> Object.fromEntries**: Creates a `Map` from the object's entries and then loops through it, modifying values and creating a new object.

**Pros and Cons of Each Approach**

Here are some general pros and cons for each approach:

* **Object.entries -> reduce (single object)**:
	+ Pros: Simple and efficient.
	+ Cons: May not be as readable or maintainable due to the use of `reduce`.
* **Object.entries -> map -> reduce (single object)**:
	+ Pros: Can be more readable than the previous approach, but may introduce additional overhead due to the use of `map` and `reduce`.
	+ Cons: May not be as efficient as a single-pass solution.
* **Object.entries -> map -> reduce (temporary objects)**:
	+ Pros: Can take advantage of temporary object creation during iteration, potentially improving performance.
	+ Cons: May introduce additional overhead due to the use of temporary objects and more complex logic.
* **new Map -> loop over object.entries -> Object.fromEntries**:
	+ Pros: Can be a simple and efficient solution, but may require more memory allocation due to the use of `Map`.
	+ Cons: May not be as readable or maintainable due to the use of `Map` and looping.

**Library Usage**

None of the approaches rely on any specific JavaScript libraries. However, some approaches may utilize built-in methods like `Object.entries`, `map()`, and `reduce()`.

**Special JS Features/Syntax**

There are no special JS features or syntax used in this benchmark. The code only uses standard JavaScript features like loops, conditionals, and object iteration.

**Alternative Approaches**

Some alternative approaches that could be considered for this benchmark include:

* Using a library like Lodash or Ramda to provide a more concise and readable solution.
* Using a different data structure, such as an array, instead of an object.
* Optimizing the approach using techniques like caching or memoization.

Overall, this benchmark provides a good starting point for understanding the performance characteristics of different JavaScript approaches for iterating through objects and creating new objects.

Latest run results:

Run details: (Test run date: 8 months 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

Test name	Executions per second
Object.entries -> map -> Object.fromEntries	1960.4 Ops/sec
Object.entries -> reduce (single object)	11012.0 Ops/sec
Object.entries -> map -> reduce (single object)	10919.3 Ops/sec
Object.entries -> reduce (temporary objects)	5931.0 Ops/sec
Object.entries -> map -> reduce (temporary objects)	5628.8 Ops/sec
new map -> loop over object.entries -> Object.fromEntries	1693.9 Ops/sec

Related benchmarks:

jAg's comparison of unzipping, possibly modifying, and rezipping objects with 250 fields (version: 0)

Created: 8 months ago by: Guest

Jump to the latest 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

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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