Usando for wait ... di con iterables sincroni

MDN dice che for await...of ha due casi d'uso:

L' for await...ofistruzione crea un ciclo che scorre su oggetti iterabili asincroni e su iterabili di sincronizzazione, ...

In precedenza ero a conoscenza del primo: async iterables using Symbol.asyncIterator. Ma ora sono interessato a quest'ultimo: iterables sincroni.

Il seguente codice scorre su un iterabile sincrono - una serie di promesse. Sembra bloccare il progresso sull'adempimento di ogni 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)

Il comportamento sembra essere simile ad attendere ogni promessa a turno, secondo la logica mostrata di seguito. Questa affermazione è corretta?

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)

Lo chiedo perché questo schema di codice ha una trappola implicita di rifiuto che lo evita Promise.alled Promise.allSettledevita, e mi sembra strano che questo schema sia esplicitamente supportato dal linguaggio.

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ì, è strano e non dovresti farlo. Non ripetete le matrici di promesse, ciò porta esattamente al problema dei rifiuti non gestiti che lei ha citato .

Quindi perché questo è supportato nella lingua? Per continuare con la semantica promessa sciatta.

Puoi trovare il ragionamento esatto in questo commento del problema che discute questa parte della proposta :

Penso che dovremmo ricorrere a Symbol.iteratorperché la nostra semantica Promise attuale consiste nel permettere alle cose di sincronizzazione di essere usate come cose asincrone. Potresti chiamare questa "sciattezza". Segue la logica di @ acque sotterranee sopra , ma voglio solo precisare i parallelismi in modo più dettagliato.

La semantica "concatenata" di .thentutto questo. Puoi restituire una Promessa da .theno un valore scalare; è tutto uguale. Chiami Promise.resolvenon per avvolgere qualcosa in una Promessa, ma per lanciare qualcosa in una Promessa: ottieni un valore asincrono quando hai qualcosa o altro.

La semantica asynce awaitriguarda anche l'essere sciatti. È possibile dare uno schiaffo awaita qualsiasi espressione non promessa in una funzione asincrona e tutto funziona perfettamente, esattamente allo stesso modo, tranne che si dà il controllo alla coda dei lavori. Allo stesso modo, puoi "difensivamente" mettere async tutto ciò che vuoi, purché tu sia awaitil risultato. Se hai una funzione che restituisce una Promessa - qualunque cosa! puoi farne una asyncfunzione e, dal punto di vista dell'utente, nulla cambia (anche se, tecnicamente, ottieni un altro oggetto Promise).

Gli iteratori e i generatori asincroni dovrebbero funzionare allo stesso modo. Proprio come puoi aspettare un valore che, per sbaglio, non era una Promessa, un utente ragionevole si aspetterebbe di essere in grado di yield*sincronizzare un iteratore all'interno di un generatore asincrono. for awaiti loop dovrebbero allo stesso modo "funzionare" se un utente in modo difensivo contrassegna un loop in quel modo, pensando che forse potrebbero ottenere un iteratore asincrono.

Penso che sarebbe un grosso problema rompere tutti questi parallelismi. Renderebbe gli iteratori asincroni meno ergonomici. Discutiamolo la prossima volta che generatori / iteratori asincroni verranno inseriti nell'agenda del TC39.

La sadpromessa non è essendo awaitndr quando non riesce - che le esigenze di codice per finire in attesa di happyprima che possa cominciare ad aspettare sad. La sadpromessa non riesce prima di happyrisolversi. ( Promise.allÈ uno strumento più adatto a questo caso d'uso)