Використання для очікування… із синхронними ітерабелями

MDN каже, for await...of що два випадки використання:

for await...ofОператор створює петлю ітерації асинхронної ітерації об'єктів, а також на ітеріруемих синхронізації, ...

Раніше я знав про колишнє: використання асинхронних ітерабелів Symbol.asyncIterator. Але мене зараз цікавить останнє: синхронні ітерабелі.

Наступний код повторюється над синхронним ітерабельним - масивом обіцянок. Схоже, блокують пророків щодо виконання кожної обіцянки.

async function asyncFunction() {
    try {
        const happy = new Promise((resolve)=>setTimeout(()=>resolve('happy'), 1000))
        const sad = new Promise((_,reject)=>setTimeout(()=>reject('sad')))
        const promises = [happy, sad]
        for await(const item of promises) {
            console.log(item)
        }
    } catch (err) {
        console.log(`an error occurred:`, err)
    }
}

asyncFunction() // "happy, an error occurred: sad" (printed in quick succession, after about 5 seconds)

Поведінка, схоже, сподівається на очікування кожної обіцянки по черзі, згідно логіки, показаної нижче. Чи правильно це твердження?

async function asyncFunction() {
    try {
        const happy = new Promise((resolve)=>setTimeout(()=>resolve('happy'), 1000))
        const sad = new Promise((_,reject)=>setTimeout(()=>reject('sad')))
        const promises = [happy, sad]
        for(let p of promises) {
            const item = await p
            console.log(item)
        }
    } catch (err) {
        console.log(`an error occurred:`, err)
    }
}

asyncFunction() // "happy, an error occurred: sad" (printed in quick succession, after about 5 seconds)

Я запитую, тому що цей шаблон коду має неявний провал відхилення, який Promise.allі Promise.allSettledуникати, і мені здається дивним, що цей шаблон явно підтримується мовою.

window.addEventListener('unhandledrejection', () => {
  console.log('unhandled rejection; `sad` was not being awaited at the time it rejected')
})

async function asyncFunction() {
    try {
        const happy = new Promise((resolve)=>setTimeout(()=>resolve('success'), 1000))
        const sad = new Promise((_,reject)=>setTimeout(()=>reject('failure')))
        const promises = [happy, sad]
        for(let p of promises) {
            const item = await p
            console.log(item)
        }
    } catch (err) {
        console.log(`an error occurred:`, err)
    }
}

asyncFunction() // "unhandled rejection; `sad` was not being awaited at the time it rejected" (after about zero seconds), and then "happy, an error occurred: sad" (printed in quick succession, after about 5 seconds)

Так, це дивно, і ти не повинен цього робити. Не повторюйте масиви обіцянок, це точно призводить до згаданої вами проблеми безвідмовного відхилення .

То чому це підтримується мовою? Продовжуйте неохайну семантику.

Точні міркування ви можете знайти в цьому коментарі питання, що обговорює цю частину пропозиції :

Я думаю, що ми повинні повернутися до цього, Symbol.iteratorоскільки наша поточна семантика Promise - це те, що дозволяє синхронізувати речі як асинхронні речі. Ви можете назвати це "неохайність". Звідси випливає логіка @ підземних вод , але я просто хочу детальніше прописати паралелі.

.thenВсе про це стосується "ланцюгова" семантика . Ви можете повернути Обіцянку від .thenабо скалярного значення; все одно. Ви закликаєте Promise.resolveне обертати щось у Обіцянні, а кинути щось на Обіцянку - отримайте асинхронне значення, коли у вас є щось або інше.

Семантика asyncі awaitвсе стосується того, щоб бути неохайними. Ви можете плескати awaitбудь-який непромітний вираз у функції асинхронізації, і все працює нормально, точно так само, за винятком того, що ви передаєте контроль черзі завдань. Так само ви можете «захисно» обкладати async все, що завгодно, доки ви отримаєте awaitрезультат. Якщо у вас є функція, яка повертає Обіцянку - що завгодно! ви можете зробити цю asyncфункцію, і, з точки зору користувача, нічого не зміниться (навіть якщо технічно ви отримаєте інший об'єкт Promise).

Асинхронізуючі ітератори та генератори повинні працювати однаково. Так само, як ви можете чекати значення, яке, випадково, не було Обіцянням, розумний користувач розраховував би на можливість yield*ітератора синхронізації в генераторі асинхронізації. for awaitциклі повинні аналогічно "просто працювати", якщо користувач захисно позначає цикл таким чином, думаючи, що, можливо, він може отримати асинхронний ітератор.

Я думаю, було б великою справою порушити всі ці паралелі. Це зробить ітератори асинхронізації менш ергономічними. Давайте обговоримо це наступного разу, коли генератори / ітератори асинхронізації з’являться на порядку денному в TC39.

sadОбіцянка НЕ бути під awaitред коли він зазнає невдачі - що потреби коду , щоб закінчити очікування , happyперш ніж він може почати чекати sad. sadОбіцянка не вдається , перш ніж happyвирішує. ( Promise.allчи інструмент краще підходить для цього випадку використання)