Utilisation de l'attente… ou des itérables synchrones

MDN dit qu'il for await...of a deux cas d'utilisation:

L' for await...ofinstruction crée une boucle itérative sur des objets itérables asynchrones ainsi que sur des itérables de synchronisation, ...

J'étais auparavant au courant de l'ancien: les itérables asynchrones utilisant Symbol.asyncIterator. Mais je m'intéresse maintenant à ce dernier: les itérables synchrones.

Le code suivant itère sur un itérable synchrone - un tableau de promesses. Il semble bloquer le progrès sur la réalisation de chaque promesse.

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)

Le comportement semble être semblable à l'attente de chaque promesse tour à tour, selon la logique ci-dessous. Cette affirmation est-elle correcte?

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)

Je demande parce que ce modèle de code a un rejet implicite de fil piège-up Promise.allet Promise.allSettledéviter, et il me semble étrange que ce modèle serait soutenu explicitement par la langue.

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)

Oui, c'est étrange, et vous ne devriez pas faire ça. Ne parcourez pas les tableaux de promesses, cela conduit exactement au problème de rejet non géré que vous avez mentionné .

Alors pourquoi est-ce pris en charge dans la langue? Pour continuer avec la sémantique de la promesse bâclée.

Vous pouvez trouver le raisonnement exact dans ce commentaire de la question discutant cette partie de la proposition :

Je pense que nous devrions y revenir Symbol.iteratorparce que notre sémantique actuelle de Promise vise à permettre aux choses de synchronisation d'être utilisées comme des choses asynchrones. Vous pourriez appeler cela "négligence". Il suit la logique de @ groundwater ci - dessus , mais je veux juste préciser les parallèles plus en détail.

La sémantique de "chaînage" de .thentout cela. Vous pouvez renvoyer une promesse de .thenou une valeur scalaire; c'est tout pareil. Vous appelez Promise.resolvenon pas pour envelopper quelque chose dans une promesse, mais pour lancer quelque chose dans une promesse - obtenez une valeur asynchrone lorsque vous avez quelque chose ou autre.

La sémantique de asyncet awaitest tout aussi bâclée. Vous pouvez gifler awaitn'importe quelle expression non Promise dans une fonction asynchrone et tout fonctionne correctement, exactement de la même manière, sauf que vous cédez le contrôle à la file d'attente des travaux. De même, vous pouvez mettre "défensivement" async tout ce que vous voulez, tant que vous obtenez awaitle résultat. Si vous avez une fonction qui renvoie une promesse - peu importe! vous pouvez en faire une asyncfonction et, du point de vue de l'utilisateur, rien ne change (même si, techniquement, vous sortez un autre objet Promise).

Les itérateurs et générateurs asynchrones devraient fonctionner de la même manière. Tout comme vous pouvez attendre une valeur qui, accidentellement, n'était pas une promesse, un utilisateur raisonnable s'attendrait à pouvoir yield*synchroniser un itérateur dans un générateur asynchrone. for awaitles boucles devraient de la même façon «fonctionner correctement» si un utilisateur marque défensivement une boucle de cette façon, pensant qu'il pourrait peut-être obtenir un itérateur asynchrone.

Je pense que ce serait une grosse affaire de briser tous ces parallèles. Cela rendrait les itérateurs asynchrones moins ergonomiques. Discutons-en la prochaine fois que des générateurs / itérateurs asynchrones seront à l'ordre du jour du TC39.

La sadpromesse n'étant ed quand il échoue - que les besoins de code pour terminer en attente sur avant de pouvoir commencer à attendre . La promesse échoue avant d'être résolue. ( est un outil mieux adapté à ce cas d'utilisation)awaithappysadsadhappyPromise.all