Usando para esperar ... o con iterables sincrónicos

MDN dice que for await...of tiene dos casos de uso:

La for await...ofinstrucción crea un ciclo que itera sobre objetos iterables asíncronos, así como en iterables sincronizados, ...

Anteriormente estaba al tanto de lo anterior: los iterables asíncronos usando Symbol.asyncIterator. Pero ahora estoy interesado en lo último: iterables sincrónicos.

El siguiente código itera sobre un iterable síncrono: una serie de promesas. Parece bloquear el progreso en el cumplimiento de cada promesa.

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)

El comportamiento parece ser similar a esperar cada promesa por turno, según la lógica que se muestra a continuación. ¿Es correcta esta afirmación?

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)

Pregunto porque este patrón de código tiene un error implícito de rechazo de conexión Promise.ally Promise.allSettledevitarlo, y me parece extraño que este patrón sea respaldado explícitamente por el lenguaje.

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)

Sí, es extraño, y no debes hacer esto. No repita los arreglos de promesas, esto conduce exactamente al problema de rechazos no controlados que mencionó .

Entonces, ¿por qué se admite esto en el idioma? Para continuar con la promesa descuidada semántica.

Puede encontrar el razonamiento exacto en este comentario del tema que discute esta parte de la propuesta :

Creo que deberíamos recurrir Symbol.iteratorporque nuestra semántica actual de Promise se trata de permitir que las cosas de sincronización se usen como cosas asíncronas. Podrías llamar a esto "descuido". Sigue la lógica de @waterwater anterior , pero solo quiero explicar los paralelos con más detalle.

La semántica de "encadenamiento" .thentiene que ver con esto. Puede devolver una Promesa .theno un valor escalar; todo es lo mismo. Usted llama Promise.resolveno para envolver algo en una Promesa, sino para lanzar algo a una Promesa: obtenga un valor asincrónico cuando tenga algo u otro.

La semántica de asyncy awaitse trata de ser descuidado también. Puede aplicar awaitcualquier expresión que no sea Promesa en una función asíncrona y todo funciona bien, exactamente de la misma manera, excepto que cede el control a la cola de trabajos. Del mismo modo, puede "a la defensiva" poner async lo que quiera, siempre que obtenga awaitel resultado. Si tiene una función que devuelve una Promesa, ¡lo que sea! puede convertirlo en una asyncfunción y, desde la perspectiva del usuario, nada cambia (incluso si, técnicamente, obtiene un objeto Promise diferente).

Los iteradores y generadores asíncronos deberían funcionar de la misma manera. Al igual que puede esperar un valor que, accidentalmente, no era una Promesa, un usuario razonable esperaría poder yield*sincronizar un iterador dentro de un generador asíncrono. for awaitlos bucles deberían "funcionar" de manera similar si un usuario marca defensivamente un bucle de esa manera, pensando que tal vez podría estar obteniendo un iterador asíncrono.

Creo que sería un gran problema romper todos estos paralelos. Haría que los iteradores asíncronos fueran menos ergonómicos. Analicemos esto la próxima vez que los generadores / iteradores asíncronos aparezcan en la agenda de TC39.

La sadpromesa no está siendo awaited cuando falla - que las necesidades de código para terminar la espera de happyque pueda comenzar a esperar en sad. La sadpromesa está fallando antes de happyresolverse. ( Promise.alles una herramienta más adecuada para este caso de uso)