Benchmark: Basic Array processing benchmark

Script Preparation code:

var arr = Array(10_000).fill(0)

Tests:

reduce with new array
arr.reduce((acc, x) => [...acc, x, x], [])
reduce with array mutation
arr.reduce((acc, x) => { acc.push(x); return acc; }, [])
flatMap
arr.flatMap(x => [x, x])
for
const newArray = []; for (let i = 0; arr.length > i; i++) { newArray.push(arr[i]); }
for-of
const newArray = []; for (let x of arr) { newArray.push(x); }
map
arr.map(x => x);
forEach
const newArray = []; arr.forEach(x => newArray.push(x));
values (iterates over for-of)
const newArray = []; for (let x of arr.values()) { newArray.push(x); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce with new array
reduce with array mutation
flatMap
for
for-of
map
forEach
values (iterates over for-of)

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 117 on Linux

View result in a separate tab

Test name	Executions per second
reduce with new array	7.1 Ops/sec
reduce with array mutation	19090.0 Ops/sec
flatMap	330.6 Ops/sec
for	781.8 Ops/sec
for-of	23622.9 Ops/sec
map	27197.0 Ops/sec
forEach	19834.1 Ops/sec
values (iterates over for-of)	24433.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the benchmark.

**Benchmark Overview**

The provided benchmark, "Basic Array processing benchmark", tests various array operations in JavaScript on a desktop Linux system with Chrome 117 browser.

**Tested Operations**

The benchmark compares six different array operations:

1. `arr.map(x => x)` - maps each element to itself
2. `arr.values().forEach(x => newArray.push(x))` - iterates over the array using `values()` and pushes elements to a new array
3. `for (let x of arr) { newArray.push(x); }` - uses a for-of loop to iterate over the array and push elements to a new array
4. `arr.reduce((acc, x) => [...acc, x, x], [])` - reduces the array using the spread operator (`[...acc, x, x]`)
5. `arr.reduce((acc, x) => { acc.push(x); return acc; }, [])` - reduces the array by pushing elements to an accumulator array
6. `const newArray = []; for (let i = 0; arr.length > i; i++) { newArray.push(arr[i]); }` - uses a traditional for loop to iterate over the array and push elements to a new array

**Options Compared**

Each test case compares two or more options:

* For maps, `arr.map()` vs. no operation
* For iterates-over-for-of, `arr.values().forEach()` vs. `for (let x of arr) { ... }`
* For reduce, different mutation strategies (`newArray.push(x)` vs. `return acc`)

**Pros and Cons**

Here's a brief summary of the pros and cons for each operation:

1. `arr.map(x => x)`:
	* Pros: simple, straightforward
	* Cons: creates a new array, potentially memory-intensive
2. `arr.values().forEach()` vs. `for (let x of arr) { ... }`:
	* Both have similar performance characteristics, but `values()` is more concise and easier to read.
	* `values()` may have better cache locality due to the iterator's nature.
3. `arr.reduce((acc, x) => [...acc, x, x], [])` vs. `arr.reduce((acc, x) => { acc.push(x); return acc; }, [])`:
	* Both achieve similar performance results, but the first one is more concise and easier to read.
	* The second one may be slightly faster due to the lack of unnecessary array creation.
4. Traditional for loop (`const newArray = []; for (let i = 0; arr.length > i; i++) { ... }`):
	* Pros: no memory allocation, potentially better cache locality
	* Cons: more verbose, error-prone

**Library and Special Features**

There are no explicitly mentioned libraries in the benchmark. However, it's worth noting that `values()` is a part of the Iterators API, which provides a way to iterate over iterable objects.

**Other Alternatives**

Some possible alternatives for array operations include:

* Using built-in functions like `every()`, `some()`, or `filter()` instead of `map()`.
* Utilizing libraries like Lodash for array manipulation.
* Considering parallel processing or multi-threading for performance-critical applications.

Keep in mind that the choice of operation often depends on the specific requirements and constraints of the project.

Related benchmarks:

Basic Array processing benchmark (version: 0)

Quick benchmark

Comparing performance of: reduce with new array vs reduce with array mutation vs flatMap vs for vs for-of vs map vs forEach vs values (iterates over for-of)

Created: 2 years ago by: Guest

Jump to the latest result

reduce with new array

reduce with array mutation

flatMap

for

for-of

map

forEach

values (iterates over for-of)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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