Benchmark: assphinxtersayswhatsuk

Script Preparation code:

var arr = [];
for (var i = 0; i < 12345; i++) {
  arr[i] = i;
}

function someFn(i) {
  return (i * 3 * 8 / 1200 * 0.002 / 40 * 0.2);
}

var sum = 0;

Tests:

forEach
arr.forEach(item => sum += someFn(item));
reduce
sumReduce = arr.reduce((lastValue, item) => { return sum += someFn(item); });
map
arr.map(item => (sum += someFn(item)));
filter
arr.filter(item => (sum += someFn(item)));
for
for (var j = 0; j < arr.length; j++) { sum += arr[j] + someFn(arr[j]); }
forOf
for (const num of arr) { sum += num + someFn(num); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
reduce
map
filter
for
forOf

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 Definition JSON**

The provided JSON represents a benchmark definition, which includes:

* `Script Preparation Code`: This is the code that prepares the test environment and initializes variables. In this case, it creates an array `arr` with 12345 elements, each containing an index value from 0 to 12344.
* `Html Preparation Code`: There is no HTML preparation code specified in this benchmark definition.

**Individual Test Cases**

The benchmark has six individual test cases:

1. **forEach**
2. **reduce**
3. **map**
4. **filter**
5. **for**
6. **forOf**

Each test case uses the `someFn` function, which is defined within the `Script Preparation Code`. The purpose of this function is not explicitly stated in the benchmark definition, but based on its implementation, it appears to be a simple mathematical calculation.

**Options Compared**

The different options compared in these test cases are:

* **forEach**: Iterates over the array using the `forEach` method and updates the sum variable.
* **reduce**: Accumulates the sum of elements in the array using the `reduce` method.
* **map**: Creates a new array with the results of applying the `someFn` function to each element, without modifying the original array.
* **filter**: Creates a new array containing only the elements for which the `someFn` function returns true, without modifying the original array.
* **for**: Iterates over the array using a traditional `for` loop and updates the sum variable.
* **forOf**: Iterates over the array using the `for...of` loop syntax and updates the sum variable.

**Pros and Cons of Each Approach**

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

* **forEach**:
	+ Pros: Simple to implement, easy to read.
	+ Cons: Can be slower due to function call overhead.
* **reduce**:
	+ Pros: Efficient for accumulating sums or performing aggregate operations.
	+ Cons: May have higher overhead due to array reduction algorithm.
* **map**:
	+ Pros: Creates a new array without modifying the original, which can be beneficial for certain use cases.
	+ Cons: Can be slower due to function call overhead and memory allocation.
* **filter**:
	+ Pros: Similar to `map`, creates a new array without modifying the original.
	+ Cons: May have higher overhead due to array filtering algorithm.
* **for**:
	+ Pros: Control over loop iterations, can optimize for specific use cases.
	+ Cons: More verbose and error-prone than other options.
* **forOf**:
	+ Pros: Concise syntax, easy to read.
	+ Cons: Limited support in older browsers or environments.

**Library Usage**

There is no explicit library usage mentioned in the benchmark definition. However, it's worth noting that some of these operations (e.g., `reduce`, `filter`) rely on built-in JavaScript methods or array implementations.

**Special JS Features/Syntax**

The benchmark uses the following special JavaScript features:

* Function expressions (e.g., `someFn = function(i) { ... }`)
* Arrow functions (e.g., `forEach(item => sum += someFn(item))`)
* Array operations (e.g., `arr.forEach`, `arr.map`, etc.)

**Alternatives**

If you're interested in exploring alternative approaches or optimizing these benchmarks, consider the following options:

* Using `let` and `const` instead of `var`
* Minimizing function call overhead
* Optimizing array iteration algorithms
* Leveraging modern JavaScript features like `Promise.all()` or web workers for concurrent execution

Keep in mind that the best approach will depend on your specific use case, performance requirements, and target environment.

Latest run results:

Run details: (Test run date: 10 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
forEach	648.6 Ops/sec
reduce	558.5 Ops/sec
map	523.0 Ops/sec
filter	435.0 Ops/sec
for	241.3 Ops/sec
forOf	337.8 Ops/sec

Related benchmarks:

assphinxtersayswhatsuk (version: 0)

Comparing performance of: forEach vs reduce vs map vs filter vs for vs forOf

Created: 10 months ago by: Guest

Jump to the latest result

forEach

reduce

map

filter

for

forOf

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):