Benchmark: test reduce with rest vs from entries vs reduce without new object2

Script Preparation code:

function generateTestData(size) {
  const testData = [];
  for (let i = 0; i < size; i++) {
    const key = `key_${i}`;
    const values = [];
    for (let j = 0; j < size; j++) {
      values.push(`value_${i}_${j}`);
    }
    testData.push({ key, values });
  }
  return testData;
}

var testData = generateTestData(1000);

Tests:

reduce with new object
const result = testData.reduce((res, { key, values }) => ({ ...res, [key]: values }), {});
fromEntries
const result = Object.fromEntries(testData.map(({ key, values }) => [key, values]));
reduce without new object
const result = testData.reduce((res, { key, values }) => { res[key] = values; return res; }, {});
forEach
const results = {} testData.forEach(({ key, values }) => { results[key] = values; });
for
const result = {}; for (let i = 0; i < testData.length; i++) { const { key, values } = testData[i]; result[key] = values; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce with new object
fromEntries
reduce without new object
forEach
for

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The provided benchmark is designed to compare the performance of different approaches for iterating over and manipulating data in JavaScript. The test cases are designed to simulate common use cases, such as reducing an array of objects or creating a new object from an array of key-value pairs.

**Options Compared**

The benchmark compares four different options:

1. **`reduce()` with a new object**: This approach uses the `reduce()` method with a callback function that creates a new object by adding properties to it.
2. **`Object.fromEntries()`**: This approach uses the `fromEntries()` method, which is available in ECMAScript 2019 and later versions.
3. **`reduce()` without creating a new object**: This approach uses the `reduce()` method with a callback function that modifies an existing object.
4. **`forEach()` loop**: This approach uses a traditional `forEach()` loop to iterate over the data.

**Pros and Cons of Each Approach**

1. **`reduce()` with a new object**:
	* Pros: Easy to implement, can be more memory-efficient if the resulting object is large.
	* Cons: May not be as efficient as other approaches for very large datasets.
2. **`Object.fromEntries()`**:
	* Pros: Efficient and concise, widely supported in modern browsers.
	* Cons: Only available in ECMAScript 2019 and later versions, may require transpilation for older browsers.
3. **`reduce()` without creating a new object**:
	* Pros: Can be more efficient than the first approach, as it avoids creating an extra object.
	* Cons: May be less readable or maintainable due to the need to modify an existing object.
4. **`forEach()` loop**:
	* Pros: Widely supported and easily understood by developers familiar with traditional loops.
	* Cons: Can be slower than other approaches, especially for large datasets.

**Library/Utility Used**

In this benchmark, no specific library or utility is used beyond the built-in `reduce()`, `Object.fromEntries()`, and `forEach()` methods. However, it's worth noting that some libraries (e.g., Lodash) may provide optimized versions of these functions or additional utility functions for similar use cases.

**Special JavaScript Features**

The benchmark does not explicitly test any special JavaScript features beyond the standard language syntax. However, it's worth noting that other benchmarks may test specific features like `async/await`, `promises`, or experimental APIs like WebAssembly.

**Alternatives**

If you're interested in exploring alternative approaches for similar use cases, consider the following:

1. **`Array.prototype.reduce()`**: This method is widely supported and provides a concise way to iterate over arrays.
2. **`Array.prototype.forEach()`**: A traditional loop-based approach that can be useful when working with older browsers or specific use cases.
3. **`Map` data structure**: In some cases, using a `Map` object can provide an efficient alternative to iterating over key-value pairs.
4. **Third-party libraries**: Depending on your specific requirements, you may find optimized solutions in libraries like Lodash or other utility belts.

When choosing the best approach for your use case, consider factors like performance, readability, and maintainability, as well as any specific requirements or constraints you may have (e.g., browser support, memory constraints).

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
reduce with new object	10.2 Ops/sec
fromEntries	2744.8 Ops/sec
reduce without new object	4109.1 Ops/sec
forEach	4166.8 Ops/sec
for	2730.1 Ops/sec

Related benchmarks:

test reduce with rest vs from entries vs reduce without new object2 (version: 9)

Comparing performance of: reduce with new object vs fromEntries vs reduce without new object vs forEach vs for

Created: one year ago by: Registered User

Jump to the latest result

reduce with new object

fromEntries

reduce without new object

forEach

for

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):