Benchmark: async for vs promise.all vs promise.allSettled

Script Preparation code:

async function asyncFor(){
    for (const x of [1, 2, 3]) {
        await new Promise(resolve => resolve(x > 0));
    }
}

async function asyncPromiseAll() {
    await Promise.all([1, 2, 3].map(x =>
        new Promise(resolve => resolve(x > 0))
    ));
}

async function asyncPromiseAllSettled() {
    await Promise.allSettled([1, 2, 3].map(x =>
        new Promise(resolve => resolve(x > 0))
    ));
}

Tests:

asyncFor
asyncFor()
asyncPromiseAll
asyncPromiseAll()
promiseAllSettled
asyncPromiseAllSettled()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
asyncFor
asyncPromiseAll
promiseAllSettled

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 microbenchmarks!

**Benchmark Overview**

The provided benchmark compares three asynchronous programming approaches: `async for`, `Promise.all`, and `Promise.allSettled`. The goal is to determine which approach has the best performance.

**Benchmark Definition**

The benchmark definition is a JSON object that contains information about the test cases. Let's break it down:

* **`Name`**: The name of the benchmark, which is "async for vs promise.all vs promise.allSettled".
* **`Script Preparation Code`**: This code defines three asynchronous functions:
	+ `asyncFor`: A loop that iterates over an array using a `for...of` loop with `await` to wait for each iteration.
	+ `asyncPromiseAll`: Uses `Promise.all` to execute an array of promises in parallel, where each promise resolves when its corresponding value is greater than 0.
	+ `asyncPromiseAllSettled`: Similar to `asyncPromiseAll`, but uses `Promise.allSettled` instead. This approach returns a promise that resolves when all the promises in the input array have either resolved or rejected.
* **`Html Preparation Code`**: This field is empty, indicating that no HTML code needs to be prepared for this benchmark.

**Individual Test Cases**

The individual test cases are defined as an array of objects, each containing:

* **`Benchmark Definition`**: The name of the asynchronous function to test (either `asyncFor`, `asyncPromiseAll`, or `asyncPromiseAllSettled`).
* **`Test Name`**: A human-readable name for the test case.

**Latest Benchmark Results**

The latest benchmark results are provided as an array of objects, each containing information about a single execution:

* **`RawUAString`**: The raw UAs string from the browser.
* **`Browser`**: The browser version used.
* **`DevicePlatform`**: The device platform (Desktop or Mobile).
* **`OperatingSystem`**: The operating system version.
* **`ExecutionsPerSecond`**: The number of executions per second for this test case.

**Comparison Options**

The three options being compared are:

1. **`async for`**: Uses a `for...of` loop with `await` to iterate over the array and wait for each iteration.
2. **`Promise.all`**: Executes an array of promises in parallel using `Promise.all`, where each promise resolves when its corresponding value is greater than 0.
3. **`Promise.allSettled`**: Similar to `Promise.all`, but returns a promise that resolves when all the promises in the input array have either resolved or rejected.

**Pros and Cons**

Here are some pros and cons of each approach:

* **`async for`**:
	+ Pros: Can be more efficient in terms of memory usage, as it doesn't require creating multiple promises.
	+ Cons: May not be suitable for large arrays due to the overhead of waiting for each iteration.
* **`Promise.all`**:
	+ Pros: Allows executing multiple promises in parallel and can be faster for large arrays.
	+ Cons: Creates multiple promises, which may consume more memory and have slower startup times.
* **`Promise.allSettled`**:
	+ Pros: Returns a promise that resolves when all promises have either resolved or rejected, making it suitable for cases where some promises may fail.
	+ Cons: May be slower than `Promise.all` due to the additional overhead of checking each promise's status.

**Library and Syntax**

* **`Promise`**: This is a built-in JavaScript library that provides a way to work with asynchronous operations. It allows creating promises, which can be used to execute functions asynchronously.
* **`async/await`**: This syntax extension (introduced in ECMAScript 2017) simplifies writing asynchronous code by allowing the use of `await` inside async functions.

**Other Alternatives**

Some other alternatives for asynchronous programming in JavaScript include:

* **Callbacks**: A traditional way to handle asynchronous operations, where a function is executed after an operation is complete.
* **Promises Chaining**: Combining multiple promises using the `.then()` method or chaining multiple `Promise.resolve()` calls together.

Keep in mind that this benchmark only compares these three specific approaches and doesn't account for other factors like caching, optimization, or parallelization.

Latest run results:

Run details: (Test run date: 2 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:132.0) Gecko/20100101 Firefox/132.0

Browser/OS: Firefox 132 on Windows

View result in a separate tab

Test name	Executions per second
asyncFor	381706.1 Ops/sec
asyncPromiseAll	103134.9 Ops/sec
promiseAllSettled	111585.4 Ops/sec

Related benchmarks:

async for vs promise.all vs promise.allSettled (version: 0)

Comparing performance of: asyncFor vs asyncPromiseAll vs promiseAllSettled

Created: one year ago by: Guest

Jump to the latest result

asyncFor

asyncPromiseAll

promiseAllSettled

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