Menggunakan untuk menunggu ... dengan iterables sinkron

MDN mengatakan for await...of memiliki dua kasus penggunaan:

The for await...ofpernyataan menciptakan loop iterasi async iterable objek serta pada iterables sync, ...

Saya sebelumnya mengetahui yang pertama: async iterables using Symbol.asyncIterator. Tapi saya sekarang tertarik pada yang terakhir: iterables sinkron.

Kode berikut ini berulang di atas iterable sinkron - sebuah array janji. Tampaknya untuk memblokir proses pada pemenuhan setiap janji.

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)

Perilaku ini tampaknya sama dengan menunggu setiap janji pada gilirannya, sesuai dengan logika yang ditunjukkan di bawah ini. Apakah pernyataan ini benar?

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)

Saya bertanya karena pola kode ini memiliki jebakan penolakan tersirat Promise.alldan Promise.allSettledmenghindarinya, dan sepertinya aneh bagi saya bahwa pola ini akan didukung secara eksplisit oleh bahasa.

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)

Ya, ini aneh, dan Anda seharusnya tidak melakukan ini. Jangan mengulangi susunan janji, itu justru mengarah pada masalah penolakan-ditangani yang Anda sebutkan .

Jadi mengapa ini didukung dalam bahasa? Untuk melanjutkan semantik janji yang ceroboh.

Anda dapat menemukan alasan yang tepat dalam komentar tentang masalah yang membahas bagian proposal ini :

Saya pikir kita harus kembali ke Symbol.iteratorsemantik karena semantik Janji kita saat ini adalah tentang memungkinkan sinkronisasi hal-hal yang digunakan sebagai hal-hal async. Anda mungkin menyebutnya "kecerobohan". Ini mengikuti logika @ groundwater di atas , tapi saya hanya ingin menjelaskan paralelnya dengan lebih detail.

Semantik "rantai" .thensemua tentang ini. Anda dapat mengembalikan Janji .thenatau dari nilai skalar; semuanya sama. Anda menelepon Promise.resolveuntuk tidak membungkus sesuatu dalam Janji, tetapi untuk melemparkan sesuatu ke Janji - dapatkan nilai asinkron ketika Anda memiliki sesuatu-atau-yang lain.

Semantik asyncdan awaitsemua tentang menjadi ceroboh juga. Anda dapat menampar awaitekspresi non-Janji apa pun dalam fungsi async dan semuanya berfungsi dengan baik, persis dengan cara yang sama, kecuali bahwa Anda memberikan kontrol ke antrian pekerjaan. Demikian pula, Anda dapat "mempertahankan" menempatkan async apa pun yang Anda inginkan, selama Anda awaithasilnya. Jika Anda memiliki fungsi yang mengembalikan Janji - apa pun! Anda dapat menjadikannya asyncfungsi, dan, dari perspektif pengguna, tidak ada yang berubah (bahkan jika, secara teknis, Anda mendapatkan objek Janji yang berbeda).

Iterator dan generator Async harus bekerja dengan cara yang sama. Seperti halnya Anda dapat menunggu nilai yang, secara tidak sengaja, bukan Janji, pengguna yang wajar akan mengharapkan dapat yield*menyinkronkan iterator dalam generator async. for awaitloop juga harus "bekerja" jika pengguna secara defensif menandai loop dengan cara itu, berpikir bahwa mereka mungkin mendapatkan iterator async.

Saya pikir itu akan menjadi masalah besar untuk memecahkan semua persamaan ini. Itu akan membuat iterator async kurang ergonomis. Mari kita bahas ini lain kali ketika generator / iterator async muncul dalam agenda di TC39.

The sadjanji tidak menjadi awaited ketika gagal - bahwa kebutuhan kode untuk menyelesaikan menunggu happysebelum dapat mulai menunggu sad. The sadJanji gagal sebelum happyresolve. ( Promise.alladalah alat yang lebih cocok untuk kasus penggunaan ini)