NodeJS-Rückruf zu tief

In der Entwicklung erleben wir oft die Callback-Hölle, insbesondere beim Programmieren mit Node.js. Callback Hell bezieht sich auf mehrere Ebenen verschachtelter Callback-Funktionen, was es schwierig macht, den Code zu warten, zu debuggen und Fehler zu beheben. In diesem Artikel werden die Ursachen des Callback-Hell-Problems von Node.j analysiert und wie diese Situation gelöst werden kann.

1. Warum tritt das Problem mit der Rückrufhölle auf?

Node.js ist ein ereignisgesteuertes asynchrones Programmiermodell. Bei diesem Modell sind E/A-Vorgänge wie Netzwerkanforderungen, Lesen und Schreiben von Dateien sowie Datenbankabfragen alle nicht blockierend, d. h. sie werden asynchron ausgeführt und unterbrechen die Ausführung des Hauptprozesses nicht. Dadurch kann Zeitverschwendung beim Warten auf E/A-Vorgänge vermieden und die Programmleistung verbessert werden. Der Nachteil der asynchronen Programmierung besteht jedoch darin, dass sie anfällig für Callback-Höllenprobleme ist.

Die Hauptgründe für das Problem der Callback-Hölle sind folgende:

(1) Node.js verwendet ein Single-Thread-Modell. Wenn Sie mehrere E/A-Vorgänge ausführen, müssen Sie warten, bis das Ergebnis über a zurückgegeben wird Rückruffunktion. Die Verarbeitung von Daten und Logik in mehreren verschachtelten Rückruffunktionen erhöht die Komplexität des Codes.

(2) Viele Node.js-Module und -Bibliotheken basieren auf asynchronen Rückruffunktionen, und die Rückruffunktion ist die Hauptschnittstelle dieser Module und Bibliotheken. Wenn wir diese Module und Bibliotheken verwenden, müssen auch verschachtelte Aufrufe von Callback-Funktionen erfolgen.

(3) Im asynchronen Programmiermodell entspricht die Ausführungsreihenfolge der Rückruffunktionen aufgrund der asynchronen Ausführung von E/A-Operationen nicht der von uns erwarteten Reihenfolge, was zu einer Erhöhung der Komplexität der Codelogik führt.

2. Wie löst man das Callback-Höllenproblem?

Um das Problem der Callback-Hölle zu lösen, müssen wir einige asynchrone Programmiermuster und -lösungen verstehen.

(1) Verwenden Sie Promise

Promise ist ein asynchrones Programmiermodell, das Werte zwischen Rückruffunktionen übergeben und in einer Kette aufgerufen werden kann. Mit Promise können mehrere verschachtelte Rückruffunktionen zu einer Promise-Kette kombiniert werden, wodurch der Code prägnanter und lesbarer wird. Das Folgende ist ein mit Promise umgestaltetes Codebeispiel:

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));

Im obigen Code wird Promise verwendet, um den asynchronen Vorgang des Lesens von Dateien zu umschließen, und Kettenaufrufe werden verwendet, um mehrere Vorgänge miteinander zu verbinden, sodass der Code nicht mehr verschachtelt ist einfach zu lesen und zu pflegen.

(2) Async/await verwenden

async/await ist eine neue asynchrone Programmierlösung in ES2017, die auf Basis von Promise implementiert wird. Die asynchrone Funktion kann die Logik des Codes klarer machen und mit der Logik des menschlichen Denkens in Einklang bringen. Das Folgende ist ein mit async/await umgestaltetes Codebeispiel:

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();

Im obigen Code wird async/await verwendet, um mehrere asynchrone Vorgänge seriell auszuführen, und das Schlüsselwort „await“ wird vor jedem asynchronen Vorgang verwendet, um die Codeausführung anzuhalten und zu warten Versprechen Das Objekt gibt das Ergebnis zurück.

(3) Async-Modul verwenden

async ist eine Prozesssteuerungsbibliothek, die einige Funktionen bereitstellt, um die asynchrone Programmierung einfacher und bequemer zu machen. Die asynchrone Bibliothek bietet mehrere Kontrollflussfunktionen (z. B. parallel, Wasserfall, seriell usw.), die die parallele oder serielle Ausführung mehrerer asynchroner Vorgänge ermöglichen und die Ergebnisse an die Rückruffunktion zurückgeben können. Das Folgende ist ein Codebeispiel unter Verwendung des Async-Moduls:

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);
});

Im obigen Code wird die Kontrollflussfunktion async.series verwendet, um mehrere asynchrone Vorgänge nacheinander auszuführen und die Ergebnisse an die Rückruffunktion zu übergeben.

3. Zusammenfassung

Die Callback-Hölle ist ein häufiges Problem bei der Node.js-Programmierung, das die Wartung, das Debuggen und die Fehlerbehebung des Codes erschwert. Für das Callback-Hell-Problem können wir verschiedene Lösungen wie Promise-, Async/Await- und Async-Module verwenden, um die asynchrone Programmierung zu optimieren, den Code prägnanter und lesbarer zu machen und die Entwicklungseffizienz und Codequalität zu verbessern.

Das obige ist der detaillierte Inhalt vonNodeJS-Rückruf zu tief. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!