Menguasai Async/Await: Mengendalikan Rantaian Fungsi Asynchronous dalam JavaScript

Berurusan dengan Rantaian Fungsi Asynchronous dalam JavaScript

Operasi tak segerak ialah bahagian penting dalam pengaturcaraan JavaScript moden, membenarkan pelaksanaan tanpa sekatan dalam persekitaran seperti pelayar dan Node.js. Walau bagaimanapun, mengurus aliran fungsi tak segerak yang memanggil satu sama lain boleh menjadi rumit, terutamanya apabila anda mahu menunggu fungsi akhir dalam rantai tanpa menghentikan keseluruhan proses.

Dalam senario ini, kami sering bergantung pada JavaScript async/menunggu dan Janji untuk mengendalikan aliran tak segerak yang kompleks. Tetapi terdapat kes apabila menggunakan Janji atau menunggu setiap panggilan fungsi tidak sesuai, seperti apabila program mesti meneruskan pelaksanaan tanpa menunggu respons segera. Ini memperkenalkan cabaran baharu untuk pembangun.

Contoh yang anda berikan mempamerkan situasi biasa di mana beberapa fungsi dicetuskan secara tidak segerak dan kami memerlukan cara untuk mengesan apabila fungsi terakhir telah dipanggil. Menggunakan Janji tradisional di sini boleh mengehadkan kerana ia menghentikan fungsi panggilan, memaksanya menunggu keputusan dan bukannya meneruskan alirannya.

Dalam artikel ini, kami akan meneroka cara menyelesaikan masalah ini dengan JavaScript async/menunggu mekanisme. Kami akan melihat pendekatan praktikal untuk memastikan fungsi utama boleh diteruskan tanpa menunggu terus, sementara masih menangkap penyiapan fungsi terakhir dalam rantai.

Memahami Pengendalian Fungsi Asynchronous dengan Async/Await dan Panggilan Balik

Skrip pertama menggunakan async/menunggu untuk mengurus pelaksanaan fungsi tak segerak. The tak segerak kata kunci membolehkan fungsi mengembalikan janji, menjadikannya lebih mudah untuk mengendalikan operasi tak segerak secara berurutan. Dalam kes ini, functionFirst bertanggungjawab untuk memanggil functionSecond secara tak segerak menggunakan setTimeout. Walaupun functionFirst tidak menunggu functionSecond selesai, kami menggunakan tunggu dalam functionMain untuk memastikan bahawa utas utama menunggu untuk selesai semua operasi tak segerak sebelum meneruskan. Ini memberikan kawalan yang lebih baik ke atas aliran peristiwa tak segerak sambil mengekalkan tingkah laku tidak menyekat dalam JavaScript.

Kelebihan utama pendekatan ini ialah kita boleh mengendalikan aliran async yang kompleks tanpa menyekat pelaksanaan fungsi lain. Daripada memaksa program menunggu pada setiap panggilan fungsi, async/wait membenarkan kod untuk terus dilaksanakan sambil menunggu janji diselesaikan di latar belakang. Ini meningkatkan prestasi dan memastikan antara muka pengguna responsif dalam aplikasi bahagian hadapan. Kelewatan dalam setiap fungsi mensimulasikan tugas tak segerak yang sebenar, seperti permintaan pelayan atau pertanyaan pangkalan data. Mekanisme Janji diselesaikan apabila semua fungsi dalam rantaian dilaksanakan, memastikan penyata log akhir hanya muncul selepas semuanya selesai.

Dalam penyelesaian kedua, kami gunakan panggilan balik untuk mencapai aliran tak segerak tidak menyekat yang serupa. Apabila functionFirst dipanggil, ia menyalakan functionSecond dan segera kembali tanpa menunggu selesai. Fungsi panggil balik yang diluluskan sebagai hujah membantu dalam mengawal aliran dengan mencetuskan fungsi seterusnya dalam rantai apabila yang semasa selesai. Corak ini amat berguna dalam persekitaran yang memerlukan lebih banyak kawalan langsung ke atas susunan pelaksanaan tanpa menggunakan janji atau async/menunggu. Walau bagaimanapun, panggilan balik boleh membawa kepada "neraka panggil balik" apabila berurusan dengan rangkaian operasi async yang mendalam.

Akhir sekali, penyelesaian ketiga menggunakan Node.js EventEmitter untuk mengendalikan panggilan tak segerak dengan cara yang lebih canggih. Dengan memancarkan peristiwa tersuai selepas setiap fungsi tak segerak selesai, kami mendapat kawalan penuh ke atas masa untuk mencetuskan fungsi seterusnya. Pengaturcaraan dipacu acara amat berkesan dalam persekitaran bahagian belakang, kerana ia membolehkan kod yang lebih berskala dan boleh diselenggara apabila berurusan dengan berbilang operasi tak segerak. The memancarkan kaedah menghantar isyarat apabila peristiwa tertentu berlaku, dan pendengar mengendalikan peristiwa ini secara tidak segerak. Kaedah ini memastikan bahawa fungsi utama hanya diteruskan sebaik sahaja fungsi terakhir dalam rantaian telah dilaksanakan, menawarkan pendekatan yang lebih modular dan boleh digunakan semula untuk pengurusan tugas tak segerak.

// Solution 1: Using async/await with Promises in JavaScript
async function functionFirst() {
  console.log('First is called');
  setTimeout(functionSecond, 1000);
  console.log('First fired Second and does not wait for its execution');
  return new Promise(resolve => {
    setTimeout(resolve, 2000); // Set timeout for the entire chain to complete
  });
}

function functionSecond() {
  console.log('Second is called');
  setTimeout(functionLast, 1000);
}

function functionLast() {
  console.log('Last is called');
}

async function functionMain() {
  await functionFirst();
  console.log('called First and continue only after Last is done');
}

functionMain();

// Solution 2: Using Callbacks to Manage Asynchronous Flow Without Blocking
function functionFirst(callback) {
  console.log('First is called');
  setTimeout(() => {
    functionSecond(callback);
  }, 1000);
  console.log('First fired Second and does not wait for its execution');
}

function functionSecond(callback) {
  console.log('Second is called');
  setTimeout(() => {
    functionLast(callback);
  }, 1000);
}

function functionLast(callback) {
  console.log('Last is called');
  callback();
}

function functionMain() {
  functionFirst(() => {
    console.log('called First and continue only after Last is done');
  });
}

functionMain();

// Solution 3: Using Node.js EventEmitter to Handle Asynchronous Functions
const EventEmitter = require('events');
const eventEmitter = new EventEmitter();

function functionFirst() {
  console.log('First is called');
  setTimeout(() => {
    eventEmitter.emit('secondCalled');
  }, 1000);
  console.log('First fired Second and does not wait for its execution');
}

function functionSecond() {
  console.log('Second is called');
  setTimeout(() => {
    eventEmitter.emit('lastCalled');
  }, 1000);
}

function functionLast() {
  console.log('Last is called');
}

eventEmitter.on('secondCalled', functionSecond);
eventEmitter.on('lastCalled', functionLast);

function functionMain() {
  functionFirst();
  eventEmitter.on('lastCalled', () => {
    console.log('called First and continue only after Last is done');
  });
}

functionMain();

Teknik Lanjutan untuk Mengurus Perlaksanaan Fungsi Tak Segerak dalam JavaScript

Semasa menggunakan async/menunggu dan panggilan balik berkesan untuk mengendalikan aliran tak segerak dalam JavaScript, satu lagi alat berkuasa yang patut diberi perhatian ialah penggunaan JavaScript penjana digabungkan dengan fungsi async. Fungsi penjana membolehkan anda memberikan kawalan kembali kepada pemanggil, menjadikannya sempurna untuk mengendalikan proses berulang. Dengan menggandingkan penjana dengan Janji, anda boleh menjeda dan menyambung semula pelaksanaan dengan cara yang lebih terkawal, menawarkan satu lagi lapisan fleksibiliti untuk aliran kerja tak segerak.

Penjana boleh menjadi sangat berguna dalam senario di mana anda memerlukan kawalan yang lebih terperinci ke atas panggilan fungsi tak segerak. Ia berfungsi dengan membenarkan anda menghasilkan pelaksanaan pada titik tertentu dan menunggu isyarat luaran atau resolusi janji untuk disambung semula. Ini berguna dalam kes di mana anda mempunyai kebergantungan yang kompleks antara fungsi atau memerlukan operasi tidak menyekat merentas berbilang langkah. Walaupun async/menunggu selalunya lebih mudah, menggunakan penjana memberi anda keupayaan untuk mengawal aliran tak segerak dengan cara yang lebih disesuaikan.

Satu lagi pertimbangan penting ialah pengendalian ralat dalam kod tak segerak. Tidak seperti operasi segerak, ralat dalam fungsi async mesti ditangkap cuba/tangkap blok atau dengan mengendalikan janji yang ditolak. Adalah penting untuk sentiasa memasukkan pengendalian ralat yang betul dalam aliran kerja async anda, kerana ini memastikan bahawa jika satu fungsi dalam rantai gagal, ia tidak memecahkan keseluruhan aplikasi. Menambah mekanisme pengelogan pada operasi async anda juga akan membolehkan anda menjejak prestasi dan mendiagnosis isu dalam aliran async yang kompleks.