Benchmark: teette - MeasureThat.net

Script Preparation code:

var posts = [];
for(let i = 0; i < 1000000; i++) {
  posts.push({
    upVotes: i,
  });
}

Tests:

reduce
let sum = 0; sum = posts.reduce((s, p) => s += p.upVotes, 0);
for loop
let sum = 0; for (let i = 0; i < posts.length; i++) { sum += posts[i].upVotes; }
for each
let sum = 0; posts.forEach(element => { sum += element.upVotes; });
for of
let sum = 0; for(const post of posts) { sum += post.upVotes; }
map
let sum = 0; posts.map(post => { sum += post.upVotes; return post; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
for loop
for each
for of
map

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 years ago)

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

Browser/OS: Chrome 80 on Mac OS X 10.15.4

View result in a separate tab

Test name	Executions per second
reduce	43.4 Ops/sec
for loop	6.0 Ops/sec
for each	43.9 Ops/sec
for of	535.0 Ops/sec
map	34.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down what's being tested in the provided benchmark and explain the pros and cons of each approach.

**Benchmark Overview**

The benchmark measures the performance of four different methods to calculate the sum of `upVotes` for an array of objects: `reduce`, `for loop`, `for each`, and `map`.

**Script Preparation Code**

The script preparation code creates an array `posts` with 1 million objects, each containing an `upVotes` property. This code is executed only once before running the benchmark.

**Html Preparation Code**

There is no HTML preparation code provided.

**Test Cases**

Each test case consists of a `Benchmark Definition` string that defines a specific method to calculate the sum of `upVotes`. The methods are:

1. **reduce**: Uses the `reduce()` method to iterate over the array and sum up the values.
2. **for loop**: Uses a traditional `for` loop to iterate over the array and sum up the values.
3. **for each**: Uses the `forEach()` method to iterate over the array and sum up the values.
4. **map**: Uses the `map()` method to create a new array with the same elements, but returns an array of sums instead.

**Library Used**

The `reduce()`, `forEach()`, and `map()` methods are all part of the JavaScript standard library. They are used for functional programming and are commonly employed in modern web development.

**Special JS Feature/Syntax**

None of the test cases use any special or experimental JavaScript features, such as async/await, generators, or decorators.

**Pros and Cons of Each Approach**

Here's a brief summary of each approach:

1. **reduce**: Pros: concise and expressive; can be used for more complex aggregations. Cons: can be slower due to the overhead of function calls.
2. **for loop**: Pros: well-known and widely supported; easy to understand for beginners. Cons: less concise and less expressive than other methods.
3. **forEach**: Pros: simple and easy to use; suitable for iterating over arrays. Cons: returns `undefined` if no callback is provided, and can be slower due to the overhead of function calls.
4. **map**: Pros: creates a new array with transformed values; suitable for creating multiple outputs. Cons: can be slower due to the overhead of function calls and memory allocation.

**Other Alternatives**

Some alternative methods that could have been used in this benchmark include:

* `every()`, `some()`: These methods are also part of the standard library, but they are designed for more specific use cases (e.g., checking if all elements pass a test).
* Closures: Instead of using functions like `reduce()` or `forEach()`, developers could have used closures to create their own iterative algorithms.
* Loops with caching: This approach would involve iterating over the array and caching intermediate results, which can improve performance in some cases.

It's worth noting that the best approach will depend on the specific use case and requirements of the application. The provided benchmark provides a useful comparison of different methods, but it may not cover all possible scenarios or optimizations.

Related benchmarks:

teette (version: 0)

Comparing performance of: reduce vs for loop vs for each vs for of vs map

Created: 4 years ago by: Registered User

Jump to the latest result

reduce

for loop

for each

for of

map

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