Verwenden für for await… von mit synchronen iterables

Laut MDN gibt for await...of es zwei Anwendungsfälle:

Die for await...ofAnweisung erstellt eine Schleife, die sowohl über asynchrone iterierbare Objekte als auch über synchronisierte iterierbare Objekte iteriert.

Ersteres war mir vorher bekannt: asynchrone iterables using Symbol.asyncIterator. Aber ich interessiere mich jetzt für Letzteres: synchrone Iterables.

Der folgende Code iteriert über eine synchrone Iterable - eine Reihe von Versprechungen. Es scheint den Fortschritt bei der Erfüllung jedes Versprechens zu blockieren.

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)

Das Verhalten scheint so zu sein, als würde man nach der unten gezeigten Logik nacheinander auf jedes Versprechen warten. Ist diese Behauptung richtig?

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)

Ich frage , weil dieses Muster von Code eine implizite Ablehnung Draht-up pitfall hat , dass Promise.allund zu Promise.allSettledvermeiden, und es scheint mir seltsam , dass dieses Muster explizit von der Sprache unterstützt werden würde.

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)

Ja, es ist seltsam und du solltest das nicht tun. Wiederholen Sie keine Arrays von Versprechungen, es führt genau zu dem von Ihnen erwähnten Problem der unbehandelten Ablehnung .

Warum wird dies in der Sprache unterstützt? Fortsetzung der schlampigen Versprechenssemantik.

Die genaue Begründung finden Sie in diesem Kommentar zu diesem Thema des Vorschlags :

Ich denke, wir sollten darauf zurückgreifen, Symbol.iteratorweil es in unserer aktuellen Promise-Semantik darum geht, Synchronisierungssachen als asynchrone Objekte zu verwenden. Man könnte das "Schlamperei" nennen. Es folgt der obigen Logik von @ Grundwasser , aber ich möchte nur die Parallelen genauer darlegen.

Die "Verkettungs" -Semantik von dreht .thensich alles darum. Sie können ein Versprechen von .thenoder einen Skalarwert zurückgeben. Es ist alles das Gleiche. Sie rufen an, Promise.resolvenicht etwas in ein Versprechen zu verpacken, sondern etwas in ein Versprechen umzuwandeln - erhalten Sie einen asynchronen Wert, wenn Sie etwas oder etwas anderes haben.

In der Semantik von asyncund geht awaites auch darum, schlampig zu sein. Sie können awaitin einer asynchronen Funktion auf jeden Nicht-Promise-Ausdruck klatschen, und alles funktioniert einwandfrei, genauso wie Sie die Jobwarteschlange steuern. Ebenso können Sie "defensiv" herumstellen, async was Sie wollen, solange Sie awaitdas Ergebnis haben. Wenn Sie eine Funktion haben, die ein Versprechen zurückgibt - was auch immer! Sie können dies zu einer asyncFunktion machen, und aus Benutzersicht ändert sich nichts (auch wenn Sie technisch gesehen ein anderes Promise-Objekt herausbringen).

Asynchrone Iteratoren und Generatoren sollten auf die gleiche Weise funktionieren. So wie Sie auf einen Wert warten können, der aus Versehen kein Versprechen war, würde ein vernünftiger Benutzer erwarten, dass er yield*einen Synchronisationsiterator in einem asynchronen Generator verwenden kann. for awaitSchleifen sollten in ähnlicher Weise "nur funktionieren", wenn ein Benutzer eine Schleife auf diese Weise defensiv markiert und denkt, dass er möglicherweise einen asynchronen Iterator erhält.

Ich denke, es wäre eine große Sache, all diese Parallelen zu brechen. Dies würde asynchrone Iteratoren weniger ergonomisch machen. Lassen Sie uns dies das nächste Mal diskutieren, wenn asynchrone Generatoren / Iteratoren auf der Tagesordnung von TC39 stehen.

Das sadVersprechen wird nicht sein awaited , wenn es ausfällt - das Code Bedürfnis wartet auf beenden , happybevor sie beginnen können , auf warten sad. Das sadVersprechen scheitert, bevor es happygelöst wird. ( Promise.allist ein Tool, das für diesen Anwendungsfall besser geeignet ist)