So synchronisieren Sie Rückruffunktionen in NodeJS

Node.js ist eine JavaScript-Laufzeitumgebung, die auf ereignisgesteuerter und nicht blockierender E/A basiert und die V8-Engine zum Parsen von JavaScript-Code verwendet. In Node.js sind Callback-Funktionen ein gängiges Programmiermodell zur asynchronen Verarbeitung von Aufgaben. Manchmal müssen wir jedoch nachfolgenden Code ausführen, nachdem die Rückruffunktion ausgeführt wurde, was bedeutet, dass wir die Rückruffunktion synchron ausführen müssen. In diesem Artikel wird erläutert, wie synchrone Rückruffunktionen in Node.js implementiert werden.

1. Callback-Funktion

Callback-Funktion ist ein gängiges Programmiermodell in JavaScript für asynchrone Verarbeitungsaufgaben. Eine große Anzahl von APIs in Node.js übernehmen dieses Modell. Beispielsweise erfordern Netzwerkanforderungen, Lesen und Schreiben von Dateien, Datenbankabfragen usw. die Verwendung von Rückruffunktionen. Das Folgende ist ein einfaches Beispiel:

const fs = require('fs');

fs.readFile('/path/to/file', function(err, data) {
  if (err) {
    console.error(err);
  } else {
    console.log(data);
  }
});

console.log('Hello, world!');

Im obigen Beispiel liest die Funktion fs.readFile() eine Datei. Wenn der Lesevorgang erfolgreich ist, wird der Dateiinhalt über die Callback-Funktion ausgegeben wird über die Callback-Funktion eine Fehlermeldung ausgegeben. Beim Aufruf der Funktion fs.readFile() ist der zweite Parameter eine Rückruffunktion, die ausgeführt wird, nachdem das Lesen der Datei abgeschlossen ist.

2. Probleme mit asynchronen Rückruffunktionen

In Node.js wird die Rückruffunktion asynchron ausgeführt, was bedeutet, dass sie die Aufgabe asynchron im Hintergrund verarbeitet und erst ausgeführt wird, wenn die Aufgabe abgeschlossen ist. Wenn wir mehrere asynchrone Aufgaben ausführen müssen, müssen wir mehrere Rückruffunktionen verschachteln. Dieses Programmiermodell verschachtelter Rückruffunktionen wird als „Rückrufhölle“ bezeichnet und kann das Lesen und Warten von Code erschweren.

const fs = require('fs');

fs.writeFile('/path/to/file', 'Hello, world!', function(err) {
  if (err) {
    console.error(err);
  } else {
    fs.readFile('/path/to/file', function(err, data) {
      if (err) {
        console.error(err);
      } else {
        console.log(data);
      }
    });
  }
});

Im obigen Beispiel schreiben wir Daten in eine Datei und lesen den Dateiinhalt, nachdem der Schreibvorgang abgeschlossen ist. Da fs.writeFile() und fs.readFile() beide asynchrone Funktionen sind, müssen wir zwei Rückruffunktionen verschachteln, um die Aufgabe abzuschließen. Diese Verschachtelung kann den Code komplizieren und die Wartung und das Testen erschweren.

3. Ereignisgesteuert

Um das Problem asynchroner Rückruffunktionen zu lösen, verwendet Node.js ein ereignisgesteuertes Programmiermodell. Ereignisgesteuert ist ein ereignisorientiertes Programmiermodell, das ein Programm als eine Sammlung von Ereignissen betrachtet, von denen jedes eine oder mehrere Reaktionen hervorrufen kann. In Node.js wird die Ereignissteuerung durch die EventEmitter-Klasse implementiert. Hier ist ein einfaches Beispiel:

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

myEmitter.on('event', function() {
  console.log('an event occurred!');
});

myEmitter.emit('event');

Im obigen Beispiel haben wir eine MyEmitter-Klasse erstellt und die Ereignissteuerung implementiert, indem wir die EventEmitter-Klasse geerbt haben. Wir registrieren eine Ereignisbehandlungsfunktion über die Methode on(), und die Methode emit() löst das Ereignis aus und ruft die Ereignisbehandlungsfunktion auf. Wenn ein Ereignis ausgelöst wird, wird die Event-Handler-Funktion aufgerufen und führt die entsprechende Operation aus.

4. Synchronisierte Rückruffunktion

In Node.js können wir synchrone Rückruffunktionen verwenden, um das Problem der Rückrufhölle zu vermeiden. Die synchrone Rückruffunktion wird unmittelbar nach Abschluss der asynchronen Aufgabe ausgeführt, anstatt vor der Ausführung auf den Abschluss der asynchronen Aufgabe zu warten. Node.js bietet zwei Möglichkeiten zum Implementieren synchroner Rückruffunktionen: Promise und async/await.

4.1 Promise

Promise ist eine Lösung für die asynchrone Programmierung, die asynchrone Vorgänge zur Verarbeitung in Kettenaufrufe umwandelt. Versprechen hat drei Zustände: Ausstehend, Erfüllt und Abgelehnt. Nachdem der asynchrone Vorgang abgeschlossen ist, übergibt Promise das Ergebnis der Rückruffunktion an die nachfolgende Kettenfunktion.

Das Folgende ist ein Beispiel für die Verwendung von Promise zum Implementieren einer synchronen Rückruffunktion:

const fs = require('fs').promises;

const readAndWrite = async function() {
  try {
    await fs.writeFile('/path/to/file', 'Hello, world!');
    const data = await fs.readFile('/path/to/file');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
};

readAndWrite();

Im obigen Beispiel verwenden wir die Promise-Methode, die vom Modul fs.promises bereitgestellt wird, um Dateien zu lesen und zu schreiben. Wir verwenden async/await, um die Funktion der synchronen Ausführung von Rückruffunktionen zu implementieren. Da async/await in asynchronen Funktionen verwendet werden muss, müssen wir eine asynchrone Funktion verwenden, um asynchrone Vorgänge zu kapseln.

4.2 async/await

async/await ist eine Lösung für die asynchrone Programmierung. Sie verarbeitet asynchrone Vorgänge in Synchronisation und macht den Code prägnanter und lesbarer.

Das Folgende ist ein Beispiel für die Verwendung von async/await zum Implementieren einer synchronen Rückruffunktion:

const fs = require('fs').promises;

const readAndWrite = async function() {
  try {
    await fs.writeFile('/path/to/file', 'Hello, world!');
    const data = await fs.readFile('/path/to/file');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
};

readAndWrite();

Im obigen Beispiel verwenden wir die Promise-Methode, die vom fs.promises-Modul bereitgestellt wird, um Dateien zu lesen und zu schreiben. Wir verwenden async/await, um die Funktion der synchronen Ausführung von Rückruffunktionen zu implementieren. Da async/await in asynchronen Funktionen verwendet werden muss, müssen wir eine asynchrone Funktion verwenden, um asynchrone Vorgänge zu kapseln.

5. Zusammenfassung

Die Callback-Funktion ist ein gängiges Programmiermodell in Node.js für die asynchrone Verarbeitung von Aufgaben. Da Rückruffunktionen jedoch naturgemäß asynchron ausgeführt werden, kann dies zu Komplexität und Unlesbarkeit im Code führen. Um dieses Problem zu lösen, können wir ein ereignisgesteuertes Programmiermodell verwenden oder Promise und async/await verwenden, um synchrone Rückruffunktionen zu implementieren. Im eigentlichen Programmierprozess müssen wir geeignete Programmiermodelle und technische Lösungen basierend auf spezifischen Geschäftsanforderungen und -szenarien auswählen.

Das obige ist der detaillierte Inhalt vonSo synchronisieren Sie Rückruffunktionen in NodeJS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!