panggilan balik nodejs terlalu dalam

Dalam pembangunan, kami sering menghadapi neraka panggilan balik, terutamanya apabila pengaturcaraan dengan Node.js. Neraka Panggilan Balik merujuk kepada berbilang lapisan fungsi panggil balik bersarang, menjadikan kod sukar untuk diselenggara, nyahpepijat dan ralat sukar untuk diselesaikan. Artikel ini akan menganalisis punca masalah neraka panggilan balik Node.js dan cara menyelesaikan situasi ini.

1. Mengapa masalah neraka panggil balik berlaku?

Node.js ialah model pengaturcaraan tak segerak dipacu peristiwa. Di bawah model ini, operasi I/O seperti permintaan rangkaian, membaca dan menulis fail, dan pertanyaan pangkalan data semuanya tidak disekat, iaitu, dilaksanakan secara tak segerak dan tidak akan mengganggu pelaksanaan proses utama. Ini boleh mengelakkan pembaziran masa menunggu operasi I/O dan meningkatkan prestasi program. Tetapi kelemahan pengaturcaraan tak segerak ialah ia terdedah kepada masalah neraka panggil balik.

Sebab utama masalah neraka panggil balik adalah seperti berikut:

(1) Node.js menggunakan model satu-benang, dan apabila melakukan beberapa operasi I/O, anda perlu menunggu untuk keputusan melalui pengembalian fungsi panggil balik. Memproses data dan logik dalam berbilang fungsi panggil balik bersarang meningkatkan kerumitan kod.

(2) Banyak modul dan perpustakaan Node.js direka bentuk berdasarkan fungsi panggil balik tak segerak, dan fungsi panggil balik ialah antara muka utama modul dan perpustakaan ini. Apabila kami menggunakan modul dan perpustakaan ini, panggilan bersarang kepada fungsi panggil balik juga mesti dibuat.

(3) Dalam model pengaturcaraan tak segerak, disebabkan oleh pelaksanaan tak segerak bagi operasi I/O, susunan pelaksanaan fungsi panggil balik bukanlah susunan yang kami jangkakan, mengakibatkan peningkatan dalam kerumitan logik kod .

2. Bagaimana untuk menyelesaikan masalah neraka panggilan balik?

Untuk menyelesaikan masalah neraka panggil balik, kita perlu memahami beberapa corak dan penyelesaian pengaturcaraan tak segerak.

(1) Gunakan Promise

Promise ialah model pengaturcaraan tak segerak yang boleh menghantar nilai antara fungsi panggil balik dan boleh dipanggil dalam rantai. Menggunakan Promise, berbilang fungsi panggil balik bersarang boleh digabungkan menjadi rantai Promise, menjadikan kod lebih ringkas dan boleh dibaca. Berikut ialah contoh kod yang difaktorkan semula menggunakan Promise:

const fs = require('fs');

function readFilePromise(filename) {
  return new Promise((resolve, reject) => {
    fs.readFile(filename, 'utf-8', (err, data) => {
      if(err) reject(err);
      else resolve(data);
    });
  });
}

readFilePromise('file1.txt')
.then(data => {
  console.log(data);
  return readFilePromise('file2.txt');
})
.then(data => {
  console.log(data);
  return readFilePromise('file3.txt');
})
.then(data => {
  console.log(data);
})
.catch(err => console.log(err));

Dalam kod di atas, Promise digunakan untuk membalut operasi tak segerak bagi membaca fail dan panggilan berantai digunakan untuk menyambungkan berbilang operasi bersama-sama, menjadikan kod tidak lagi Bersarang, mudah dibaca dan diselenggara.

(2) Gunakan async/wait

async/wait ialah penyelesaian pengaturcaraan tak segerak baharu dalam ES2017, yang dilaksanakan berdasarkan Promise. Fungsi async boleh menjadikan logik kod lebih jelas dan selaras dengan logik pemikiran manusia. Berikut ialah contoh kod yang difaktorkan semula menggunakan async/wait:

const fs = require('fs');

function readFilePromise(filename) {
  return new Promise((resolve, reject) => {
    fs.readFile(filename, 'utf-8', (err, data) => {
      if(err) reject(err);
      else resolve(data);
    });
  });
}

async function readFiles() {
  try {
    const data1 = await readFilePromise('file1.txt');
    console.log(data1);
    const data2 = await readFilePromise('file2.txt');
    console.log(data2);
    const data3 = await readFilePromise('file3.txt');
    console.log(data3);
  } catch(err) {
    console.log(err);
  }
}

readFiles();

Dalam kod di atas, async/wait digunakan untuk melaksanakan berbilang operasi tak segerak secara bersiri dan kata kunci await digunakan untuk menjeda kod sebelum setiap operasi tak segerak . Laksanakan dan tunggu objek Promise mengembalikan hasilnya.

(3) Gunakan modul async

async ialah perpustakaan kawalan proses yang menyediakan beberapa fungsi untuk menjadikan pengaturcaraan tak segerak lebih mudah dan lebih mudah. Pustaka async menyediakan berbilang fungsi aliran kawalan (seperti selari, air terjun, siri, dll.), yang boleh membenarkan berbilang operasi tak segerak dilaksanakan secara selari atau bersiri, dan hasilnya boleh dikembalikan kepada fungsi panggil balik. Berikut ialah contoh kod menggunakan modul async:

const async = require('async');
const fs = require('fs');

function readFile(filename, callback) {
  fs.readFile(filename, 'utf-8', (err, data) => {
    if(err) callback(err);
    else callback(null, data);
  });
}

async.series([
  function(callback) {
    readFile('file1.txt', callback);
  },
  function(callback) {
    readFile('file2.txt', callback);
  },
  function(callback) {
    readFile('file3.txt', callback);
  },
], function(err, results) {
  if(err) console.log(err);
  else console.log(results);
});

Dalam kod di atas, fungsi aliran kawalan async.series digunakan untuk melaksanakan berbilang operasi tak segerak dalam siri dan menghantar keputusan kepada fungsi panggil balik.

3. Ringkasan

Neraka panggilan balik ialah masalah biasa dalam pengaturcaraan Node.js, yang menjadikan kod sukar untuk diselenggara, nyahpepijat dan penyelesaian masalah ralat. Untuk masalah neraka panggil balik, kami boleh menggunakan pelbagai penyelesaian seperti Promise, modul async/wait dan async untuk mengoptimumkan pengaturcaraan tak segerak, menjadikan kod lebih ringkas dan boleh dibaca, serta meningkatkan kecekapan pembangunan dan kualiti kod.

Atas ialah kandungan terperinci panggilan balik nodejs terlalu dalam. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!