Benchmark: foreach for vs promise.all for big arrays

Script Preparation code:

const quantity = 1000;

const array = Array(quantity)
    .fill({
        teste: true
    })
    .map((value, index) => ({
        id: index + 1,
        ...value
    }));

async function all() {
    return Promise.all(
        array.map(async (ar) => {
            const value = ar.index * Math.ceil(Math.random, quantity);
            return {
                ...ar,
                value
            };
        })
    );
};

async function each() {
    return array.map((ar) => {
        const value = ar.index * Math.ceil(Math.random, quantity);
        return {
            ...ar,
            value
        };
    });
};

Tests:

all
all()
each
each()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
all
each

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to help explain the benchmark and its test cases.

**Overview of MeasureThat.net**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks, which are small pieces of code designed to measure the performance of specific parts of an application. The goal of these benchmarks is to determine the optimal way to implement a particular piece of functionality in JavaScript.

**Benchmark Definition JSON**

The benchmark definition JSON contains information about the test case being run. In this case, we have two test cases:

1. `foreach for vs promise.all for big arrays`
2. `all()` and `each()` individually

**Test Case 1: foreach for vs promise.all for big arrays**

This test case compares the performance of using a traditional `forEach` loop versus using `Promise.all` to iterate over an array.

* **Pros of using `forEach`**: Simple and straightforward approach, easy to understand and maintain.
* **Cons of using `forEach`**: May have poor performance for large arrays due to the need to create a promise for each element.
* **Pros of using `Promise.all`**: Can be faster than traditional `forEach` for large arrays by leveraging parallel processing.

**Test Case 2: all() and each() individually**

These two test cases measure the performance of the `all()` and `each()` functions individually. These functions are used to perform some calculation on an array of objects, returning a promise that resolves when all calculations are complete.

* **Pros of using `all()`**: Can be faster than traditional `forEach` due to parallel processing.
* **Cons of using `all()`**: May have higher memory usage due to the need to create promises for each element.
* **Pros of using `each()`**: Can be simpler and more straightforward than using `Promise.all`, but may not be as efficient.

**Library: Promise**

The `Promise` library is used extensively in these test cases. A promise is a result object that is used to handle asynchronous operations, such as reading from a file or making an HTTP request. In this case, promises are used to create parallel processing for the array calculations.

* **Purpose**: To enable parallel processing and improve performance by leveraging async/await syntax.

**Special JS Feature: Async/Await**

The `async` keyword is used with the `all()` function to indicate that it returns a promise. The `await` keyword is used inside this function to pause execution until the promises are resolved, ensuring that all calculations are complete before returning the result.

* **Purpose**: To simplify the writing of asynchronous code and make it easier to understand.

**Other Alternatives**

Some other alternatives for iterating over arrays in JavaScript include:

1. `for` loop
2. `map()` function with a callback function
3. `reduce()` function

Each of these alternatives has its own trade-offs, such as performance, simplicity, and memory usage.

In summary, the benchmark compares the performance of traditional `forEach` loops versus using `Promise.all` and the `each()` function for iterating over large arrays. The choice of approach depends on the specific requirements of the application, including factors such as performance, simplicity, and memory usage.

Latest run results:

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

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

Browser/OS: Chrome 122 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
all	3502.0 Ops/sec
each	4864.1 Ops/sec

Related benchmarks:

foreach for vs promise.all for big arrays (version: 0)

Comparing performance of: all vs each

Created: one year ago by: Guest

Jump to the latest result

all

each

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