Bagaimana untuk Melaksanakan Urutan Janji secara serentak dalam JavaScript?

Bagaimana untuk Menyegerakkan Urutan Janji?

Dalam senario ini, kami mempunyai tatasusunan objek janji yang mesti diselesaikan dalam susunan tepat yang dinyatakan dalam tatasusunan. Selain itu, jika satu elemen ditolak, keseluruhan rantai harus menolak serta-merta, menghalang percubaan selanjutnya untuk menyelesaikan elemen berikutnya.

Lelaran Manual

Berikut ialah contoh yang mempamerkan lelaran manual untuk pelaksanaan janji berurutan:

function processArray(array, fn) {
  var index = 0;

  function next() {
    if (index < array.length) {
      fn(array[index++]).then(next);
    }
  }
  return next();
}

Fungsi ini mengambil tatasusunan dan fungsi pemulangan janji fn sebagai argumen. Ia melelar melalui tatasusunan, memanggil fn pada setiap elemen dan menghantar hasilnya kepada lelaran seterusnya.

Menggunakan .reduce() dengan Promise

function processArray(array, fn) {
  return array.reduce((p, item) => {
    return p.then(() => {
      return fn(item).then((data) => {
        results.push(data);
        return results;
      });
    });
  }, Promise.resolve());
}

Pendekatan ini menggunakan kaedah reduce() untuk mengumpul pelbagai hasil. Setiap item dalam tatasusunan diproses secara berurutan, dengan janji yang dikembalikan daripada fn digunakan untuk memajukan lelaran.

Menggunakan Pustaka Bluebird Promise

Pustaka janji Bluebird menyediakan kaedah yang mudah untuk mengendalikan operasi tak segerak, termasuk lelaran berjujukan.

Promise.mapSeries(arr, (item) => {
  // process each individual item here, return a promise
  return processItem(item);
}).then((results) => {
  // process final results here
}).catch((err) => {
  // process error here
});

Kaedah Promise.mapSeries() mengambil tatasusunan dan fungsi penghasil janji dan mengembalikan janji yang diselesaikan kepada tatasusunan hasil yang diselesaikan.

Menggunakan async/menunggu ES7

Dengan sintaks async/menunggu ES7, operasi async berurutan boleh ditulis dalam cara yang lebih ringkas dan boleh dibaca:

async function processArray(array, fn) {
  let results = [];
  for (let i = 0; i < array.length; i++) {
    let r = await fn(array[i]);
    results.push(r);
  }
  return results; // will be resolved value of promise
}

Dalam contoh ini, fungsi processArray berulang melalui tatasusunan, menggunakan await untuk menjeda gelung sehingga setiap janji yang dikembalikan daripada fn diselesaikan.

Memilih Pendekatan yang Tepat

Pendekatan terbaik untuk menyegerakkan urutan janji bergantung pada faktor seperti bilangan elemen dalam tatasusunan, kerumitan fungsi pemprosesan fn, dan tingkah laku pengendalian ralat yang diingini. Untuk tatasusunan yang lebih kecil dan fungsi pemprosesan mudah, lelaran manual atau menggunakan Bluebird's Promise.mapSeries() mungkin mencukupi. Untuk senario yang lebih kompleks, menggunakan async/menunggu atau penyelesaian tersuai seperti yang disediakan dalam jawapan akhir mungkin lebih sesuai.

Atas ialah kandungan terperinci Bagaimana untuk Melaksanakan Urutan Janji secara serentak dalam JavaScript?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!