Bagaimana Mengelakkan Perangkap Biasa Apabila Mengendalikan Proses Asynchronous Di Dalam JavaScript Untuk Gelung?

Mengendalikan Proses Tak Segerak dalam JavaScript Untuk Gelung

Dalam JavaScript, proses tak segerak selalunya dikendalikan menggunakan panggilan balik atau janji. Walau bagaimanapun, apabila menjalankan proses tak segerak dalam gelung for, adalah penting untuk mempertimbangkan potensi isu yang boleh timbul.

Satu isu sedemikian berlaku apabila operasi tak segerak selesai selepas gelung berulang beberapa kali. Ini boleh membawa kepada keputusan yang salah atau tidak dijangka, kerana pembolehubah gelung mungkin tidak lagi memegang nilai yang dijangkakan.

Untuk menyelesaikan isu ini, terdapat beberapa pendekatan yang disyorkan:

Menggunakan .forEach () dengan Penutupan Fungsi

Kaedah .forEach() mencipta penutupan berasingan untuk setiap lelaran gelung, memastikan pembolehubah indeks adalah unik dan boleh diakses oleh panggilan balik tak segerak. Contohnya:

someArray.forEach((item, i) => {
  asynchronousProcess(callbackFunction(() => {
    alert(i);
  }));
});

Mencipta Penutupan Fungsi menggunakan IIFE (Ekspresi Fungsi Segera Dipanggil)

Pendekatan lain ialah mencipta penutupan fungsi menggunakan IIFE, yang boleh dipanggil dengan pembolehubah indeks yang dikehendaki. Contohnya:

for (var i = 0; i < j; i++) {
  (function(cntr) {
    asynchronousProcess(callbackFunction(() => {
      alert(cntr);
    }));
  })(i);
}

Menggunakan Fungsi Luaran dengan Indeks Lulus

Jika proses tak segerak boleh diubah suai, pembolehubah indeks boleh dilalui sebagai hujah . Fungsi itu kemudiannya boleh mengembalikan indeks kembali ke panggilan balik. Contohnya:

for (var i = 0; i < j; i++) {
  asynchronousProcess(i, callbackFunction(cntr => {
    alert(cntr);
  }));
}

Menggunakan ES6 let

Dalam ES6, kata kunci let boleh digunakan untuk mencipta pembolehubah unik bagi setiap lelaran gelung, menghapuskan potensi konflik. Contohnya:

const j = 10;
for (let i = 0; i < j; i++) {
  asynchronousProcess(callbackFunction(() => {
    alert(i);
  }));
}

Mensiri Operasi Async dengan Janji dan Async/Await

Jika fungsi tak segerak mengembalikan janji dan anda ingin menjalankannya secara berurutan, anda boleh menggunakan async/menunggu dalam persekitaran moden. Contohnya:

async function someFunction() {
  const j = 10;
  for (let i = 0; i < j; i++) {
    await asynchronousProcess();
    alert(i);
  }
}

Menjalankan Operasi Tak segerak secara Selari dan Mengumpul Hasil dengan Promise.all()

Untuk menjalankan berbilang operasi tak segerak secara selari dan mengumpulkan keputusannya dalam pesanan, anda boleh menggunakan Promise.all(). Contohnya:

function someFunction() {
  const promises = [];
  for (let i = 0; i < 10; i++) {
    promises.push(asynchronousProcess());
  }

  return Promise.all(promises);
}

Dengan mengikut pendekatan ini, anda boleh mengendalikan proses tak segerak dalam JavaScript untuk gelung dengan berkesan, memastikan hasil yang tepat dan boleh diramal.

Atas ialah kandungan terperinci Bagaimana Mengelakkan Perangkap Biasa Apabila Mengendalikan Proses Asynchronous Di Dalam JavaScript Untuk Gelung?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!