Usando para aguardar ... de com iterables síncronos

O MDN diz que for await...of tem dois casos de uso:

A for await...ofinstrução cria um loop que itera sobre objetos iteráveis ​​assíncronos, bem como sobre iteráveis ​​de sincronização, ...

Eu já tinha conhecimento do primeiro: async iterables usando Symbol.asyncIterator. Mas agora estou interessado no último: iterables síncronos.

O código a seguir itera sobre uma iterável síncrona - uma matriz de promessas. Parece bloquear o progresso no cumprimento de cada promessa.

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)

O comportamento parece ser semelhante a aguardar cada promessa por sua vez, de acordo com a lógica mostrada abaixo. Esta afirmação está correta?

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)

Eu pergunto porque esse padrão de código tem uma armadilha fio-up rejeição implícita de que Promise.alle Promise.allSettledevitar, e parece estranho para mim que esse padrão seria explicitamente suportada pelo idioma.

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)

Sim, é estranho, e você não deve fazer isso. Não itere séries de promessas, pois isso leva exatamente ao problema de rejeições não tratadas que você mencionou .

Então, por que isso é suportado no idioma? Para continuar com a semântica da promessa desleixada.

Você pode encontrar o raciocínio exato neste comentário da questão que discute esta parte da proposta :

Acho que deveríamos Symbol.iteratorrecorrer porque nossa semântica atual do Promise visa permitir que coisas de sincronização sejam usadas como coisas assíncronas. Você pode chamar isso de "negligência". Segue a lógica da água subterrânea acima , mas eu só quero detalhar os paralelos com mais detalhes.

A semântica do "encadeamento" .thené sobre isso. Você pode retornar uma promessa .thenou um valor escalar; é tudo a mesma coisa. Você chama Promise.resolvenão para agrupar algo em uma promessa, mas para converter algo em uma promessa - obtenha um valor assíncrono quando tiver uma coisa ou outra.

A semântica de asynce awaité tudo sobre ser desleixado também. Você pode dar awaitum tapa em qualquer expressão que não seja Promise em uma função assíncrona e tudo funcionará bem, exatamente da mesma maneira, exceto que você gera controle para a fila de trabalhos. Da mesma forma, você pode "defender" async o que quiser, contanto que você awaitobtenha o resultado. Se você tem uma função que retorna uma promessa - tanto faz! você pode transformar isso em uma asyncfunção e, da perspectiva do usuário, nada muda (mesmo que, tecnicamente, você obtenha um objeto Promise diferente).

Os iteradores e geradores assíncronos devem funcionar da mesma maneira. Assim como você pode esperar um valor que, acidentalmente, não era uma Promessa, um usuário razoável esperaria poder yield*sincronizar um iterador dentro de um gerador assíncrono. for awaitos loops da mesma forma "simplesmente funcionam" se um usuário marcar defensivamente um loop dessa maneira, pensando que talvez esteja recebendo um iterador assíncrono.

Eu acho que seria muito importante quebrar todos esses paralelos. Isso tornaria os iteradores assíncronos menos ergonômicos. Vamos discutir isso na próxima vez que geradores / iteradores assíncronos aparecerem na agenda do TC39.

A sadpromessa não está sendo cumprida awaitquando falha - esse código precisa terminar a espera happyantes que possa começar a esperar sad. A sadpromessa está falhando antes de happyresolver. ( Promise.allé uma ferramenta mais adequada para este caso de uso)