Побег из ада async/await

Мой друзья! Лучше использовать инструменты наподобие map библиотеки Bluebird, которые позволяют управлять количеством одновременно запущенных промисов:

Bluebird.map(
    array, item => doSomethingAsync(item), {concurrency: LIMIT}
)

Это защитит память приложения от переполнения при обработке огромных массивов и предотвратит возникновение блокировок.

Перевод моего комментария к этой статье.

// Задачу можно решить так, как показано выше, но я предпочитаю следующий метод (async () => { Promise.all([selectPizza(), selectDrink()]).then(orderItems) // асинхронный вызов })()

Разве здесь не нужен await (или убрать фигурные скобки вокруг тела функции)?

Статья как по мне спорная. Не увидел особого "ада", в основном, начальные примеры показывают, что бывает, если не понимаешь, как работает async/await.

Как по мне, разобраться с этим уж точно не сложнее, чем с промисами. А код получается на порядки читабельнее.

const promiseSomeWhat = someWhat();
const promiseAnother = another();
const someData = await promiseSomeWhat;
const anotherData = await promiseAnother;

const promises = items.map(async (item) => {
	await sendRequest(item);
});
await Promise.all(promises);

async function selectPizza() {
    let pizzaData = await getPizzaData();    // асинхронный запрос
    let chosenPizza = choosePizza();    // синхронный вызов
    await addPizzaToCart(chosenPizza);    // асинхронный вызов
}

async function selectDrink() {
    let drinkData = await getDrinkData();    // асинхронный запрос
    let chosenDrink = chooseDrink();    // синхронный вызов
    await addDrinkToCart(chosenDrink);    // асинхронный вызов
}

async function orderItems() {
    let items = await getCartItems();    // Товары в корзине
    let promises = items.map(sendRequest); // Получен массив горячих промисов
    await Promise.whenAll(promises);
}

let promises = [selectPizza(), selectDrink()];
await Promise.whenAll(promises);

await orderItems();   // асинхронный вызов

class AggregateError extends Error {
    constructor(errors, message) {
        super(message);
        this.errors = errors && errors[Symbol.iterator] ? [...errors] : [];
    }
}

/**
 * Аналог черновика Promise.allSettled(). Не полностью соответствует Task.WhenAll()
 * Возвращаемый промис будет завершен, когда все из последовательности промисов будут завершены. 
 * Возвращаемый промис всегда будет завершаться в состоянии resolved, в отличие от Task.WhenAll()  
 * Это справедливо, даже если завершенные промисы будут находиться в состоянии rejected.
 * 
 * @returns {Array} Массив объектов {value, reason, status: "fulfilled" или "rejected"}
 * Свойства value или reason могут отсутствовать.
 */
if (!Promise.allSettled) {
    Promise.allSettled = promises => new Promise((resolve, reject) => {
        let inputTasks = Array.from(promises);
        let array = [],
            count = 0,
            len = inputTasks.length;
        for (let i = 0; i < len; ++i) {
            inputTasks[i].then(
                value => {
                    array[i] = { status: "fulfilled", value: value };
                    if (++count === len) resolve(array);
                },
                reason => {
                    array[i] = { status: "rejected", reason: reason };
                    if (++count === len) resolve(array);
                }
            );
        }
    });
}

/**
 * Создать промис, который будет завершен, когда все из последовательности 
 * промисов будут завершены. 
 * Возвращаемый промис будет успешно завершен, если все промисы успешно завершены.
 * Результатом будет массив значений промисов.
 * Возвращаемый промис будет неуспешно завершен, если любой из промисов 
 * завершен неуспешно. 
 * Возвращенной ошибкой будет AggregateError c  массивом ошибок промисов.
 */
Promise.whenAll = promises => new Promise((resolve, reject) => {
    Promise.allSettled(promises).then(
        array => {
            let errors = array
                .filter(e => e.status === "rejected")
                .map(e => e.reason);
            if (errors.length)
                reject(new AggregateError(errors));
            else
                resolve(array.map(e => e.value));
        },
        error => { reject(error); }
    );
});