So führen Sie verschachtelte Rückrufe in NodeJS durch

Node.js ist eine serverseitige Programmiersprache, die auf einem ereignisgesteuerten, nicht blockierenden I/O-Modell basiert und asynchrone Rückrufmechanismen unterstützt. Bei der Durchführung asynchroner Vorgänge in Node.js verwenden wir normalerweise Rückruffunktionen. Verschachtelte Rückrufe sind eine besondere Art, Rückruffunktionen aufzurufen.

Verschachtelte Rückrufe können eine andere Rückruffunktion innerhalb der Rückruffunktion verschachteln. Diese verschachtelte Struktur sieht sehr kompliziert aus, wird aber tatsächlich häufig in Node.js verwendet, insbesondere wenn es um mehrere asynchrone Vorgänge geht.

Das Folgende ist ein einfaches Beispiel, das zeigt, wie verschachtelte Rückrufe ausgeführt werden:

// 读取文件1
fs.readFile('file1.txt', function (err, content1) {
  if (err) throw err;
  // 读取文件2
  fs.readFile('file2.txt', function (err, content2) {
    if (err) throw err;
    // 执行一些操作
    console.log('文件1的内容是：' + content1);
    console.log('文件2的内容是：' + content2);
  });
});

Im obigen Beispiel lesen wir zuerst die Datei file1.txt, und wenn der Lesevorgang abgeschlossen ist, wird die Rückruffunktion ausgeführt. In der Callback-Funktion wird eine weitere Datei file2.txt gelesen. Nach Abschluss des Lesevorgangs wird eine verschachtelte Callback-Funktion ausgeführt und der Inhalt der beiden Dateien ausgegeben.

Wenn Sie für die obige verschachtelte Rückruffunktionsstruktur die Verschachtelung weiter erhöhen, wird der Code aus der horizontalen Richtung erweitert, wie folgt:

fs.readFile('file1.txt', function (err, content1) {
  if (err) throw err;
  fs.readFile('file2.txt', function (err, content2) {
    if (err) throw err;
    fs.readFile('file3.txt', function (err, content3) {
      if (err) throw err;
      // 更多嵌套回调函数
    });
  });
});

Solcher Code ist schwer zu verstehen und zu warten, und die Logik ist leicht zu verwechseln. und es ist auch leicht, eine Rückruf-Höllenfrage zu verursachen. Um dieses Problem zu vermeiden, können wir Promise, Async/Await und andere Methoden zur Optimierung verwenden.

Der mit Promise optimierte Code lautet wie folgt:

new Promise((resolve, reject) => {
  fs.readFile('file1.txt', (err, content) => {
    if (err) reject(err);
    else resolve(content);
  });
})
.then(content => {
  return new Promise((resolve, reject) => {
    fs.readFile('file2.txt', (err, content) => {
      if (err) reject(err);
      else resolve(content);
    });
  });
})
.then(content => {
  console.log(content);
})
.catch(err => {
  console.error(err);
});

Der mit async/await optimierte Code lautet wie folgt:

async function readFile() {
  try {
    const content1 = await promisify(fs.readFile)('file1.txt');
    const content2 = await promisify(fs.readFile)('file2.txt');
    console.log(content1);
    console.log(content2);
  } catch (err) {
    console.error(err);
  }
}

Es ist ersichtlich, dass der Code nach der Optimierung mit Promise oder async/await ohne klarer und lesbarer aussieht Das Phänomen der zu tiefen Verschachtelung oder der Rückrufhölle tritt auf.

Zusammenfassend lässt sich sagen, dass verschachtelte Rückruffunktionen zwar kompliziert erscheinen, es sich jedoch um einen häufigen asynchronen Rückrufmechanismus in Node.js handelt. Wir können verschachtelte Rückrufe optimieren, indem wir Promise oder async/await verwenden, um den Code prägnanter und leichter verständlich zu machen.

Das obige ist der detaillierte Inhalt vonSo führen Sie verschachtelte Rückrufe in NodeJS durch. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!