Benchmark: Reduce vs map/join

Script Preparation code:

var strings = {};
for (var i=0; i<1000; i++) {
  strings[i] = ""+i+i;
}

Tests:

for in
var result = ""; for (var i in strings) { result += ' '+strings[i]; }
reduce
var result = Object.keys(strings).reduce(function(string, i) { return string+' '+strings[i]; }, "");
map
var result = Object.keys(strings).map(function(i) { return strings[i]; }).join(' ');
for of
var result = ""; for (var i of Object.values(strings)) { result += ' '+i; }
reduce vals
var result = Object.values(strings).reduce(function(string, i) { return string+' '+i; }, "");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for in
reduce
map
for of
reduce vals

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript benchmarks!

**Benchmark Definition**

The provided JSON represents a benchmarking test case created on MeasureThat.net. The benchmark measures the performance of three different approaches to concatenate strings:

1.  **`for in`**: This approach uses the `in` operator to iterate over the properties of an object (`strings`) and concatenates them to a result string.
2.  **`reduce`**: This approach uses the `reduce()` method on an array of keys from the `strings` object, concatenating each key's value to a result string.
3.  **`map`**: This approach uses the `map()` function on an array of keys from the `strings` object, transforming each key into its corresponding value and then joining them with spaces using the `join()` method.
4.  **`for of`**: This approach uses a `for...of` loop to iterate over the values of the `strings` object and concatenates them to a result string.

**Options Compared**

The benchmark compares the performance of these four approaches:

*   **`for in`**: Uses the `in` operator to iterate over properties.
*   **`reduce`**: Uses the `reduce()` method on an array of keys.
*   **`map`**: Uses the `map()` function on an array of keys.
*   **`for of`**: Uses a `for...of` loop to iterate over values.

**Pros and Cons**

Here's a brief overview of each approach:

*   **`for in`**:
    *   Pros: Simple, widely supported.
    *   Cons: Can be slower due to property lookup overhead.
*   **`reduce`**:
    *   Pros: Efficient for arrays, can reduce memory allocation.
    *   Cons: Requires the use of an accumulator function, can be less readable.
*   **`map`**:
    *   Pros: Convenient, efficient for creating new arrays.
    *   Cons: Creates a new array, can be slower than `for in`.
*   **`for of`**:
    *   Pros: Modern, efficient, and easy to read.
    *   Cons: Requires support for the `for...of` loop syntax.

**Library**

The benchmark uses an object called `strings`, which is not a standard JavaScript library. It appears to be a simple demonstration object with numeric keys and corresponding string values.

**Special JS Feature or Syntax**

None of the approaches in this benchmark utilize any special JavaScript features or syntax beyond the use of modern array methods (`reduce()`, `map()`) and loops.

**Alternatives**

If you were to write similar benchmarks, consider using more advanced techniques like:

*   Using `Set` for fast property iteration.
*   Utilizing WebAssembly (WASM) or other low-level optimization techniques for performance comparisons.
*   Experimenting with different data structures, such as sparse arrays or custom objects.

Keep in mind that the choice of approach ultimately depends on your specific use case and requirements.

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/108.0.0.0 Safari/537.36

Browser/OS: Chrome 108 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
for in	16467.4 Ops/sec
reduce	18608.5 Ops/sec
map	17378.9 Ops/sec
for of	87828.8 Ops/sec
reduce vals	136322.6 Ops/sec

Related benchmarks:

Reduce vs map/join (version: 0)

Comparing performance of: for in vs reduce vs map vs for of vs reduce vals

Created: 6 years ago by: Guest

Jump to the latest result

for in

reduce

map

for of

reduce vals

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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