Mehrere Anfragen von nodejs sorgen für Ordnung

Node.js ist eine ereignisgesteuerte JavaScript-Laufzeitumgebung, die häufig zur Entwicklung leistungsstarker, skalierbarer Netzwerkanwendungen verwendet wird. In vielen Szenarien müssen wir mehrere Anfragen an verschiedene APIs oder Datenquellen senden und die Reihenfolge dieser Anfragen muss garantiert sein. In diesem Artikel werden drei Möglichkeiten vorgestellt, um die Reihenfolge für mehrere Anfragen aufrechtzuerhalten.

1. Callback-Funktionen verwenden

In Node.js sind Callback-Funktionen der Kern der asynchronen Programmierung. Bei mehreren Anfragen können wir die Rückruffunktion einer Anfrage als Rückruffunktion einer anderen Anfrage verwenden, um deren Reihenfolge sicherzustellen.

Zum Beispiel möchten wir drei HTTP-Anfragen senden, nämlich Benutzerinformationen, Benutzerbestellungen und Benutzeradressen abzurufen. Diese drei Anfragen müssen der Reihe nach ausgeführt werden, da nachfolgende Anfragen auf den Daten der vorherigen Anfrage basieren müssen.

getUserInfo(userId, function(err, userInfo) {
  if (err) throw err;

  getUserOrder(userId, function(err, userOrder) {
    if (err) throw err;

    getUserAddress(userId, function(err, userAddress) {
      if (err) throw err;

      // 处理获取到的用户信息、订单和地址
      console.log(userInfo, userOrder, userAddress);
    });
  });
});

Im obigen Code sind getUserInfo, getUserOrder und getUserAddress alle asynchrone HTTP-Anfragen, und ihre Rückruffunktion dient als Rückruffunktion einer anderen Anfrage. Auf diese Weise können wir die Reihenfolge der Anfragen gewährleisten und die entsprechenden Daten nach Abschluss jeder Anfrage verarbeiten.

2. Verwenden Sie async/await

Im ES2017-Standard führte JavaScript die asynchrone/await-Syntax ein, eine asynchrone Programmiermethode, die auf Promise basiert. Durch die Verwendung von async/await können wir asynchronen Code wie synchronen Code aussehen lassen, wodurch es einfacher wird, die Reihenfolge mehrerer asynchroner Anforderungen zu verwalten.

async function getUserInfo(userId) {
  const response = await fetch(`/api/user/${userId}/info`);
  const userInfo = await response.json();
  return userInfo;
}

async function getUserOrder(userId) {
  const response = await fetch(`/api/user/${userId}/order`);
  const userOrder = await response.json();
  return userOrder;
}

async function getUserAddress(userId) {
  const response = await fetch(`/api/user/${userId}/address`);
  const userAddress = await response.json();
  return userAddress;
}

async function getUserData(userId) {
  const userInfo = await getUserInfo(userId);
  const userOrder = await getUserOrder(userId);
  const userAddress = await getUserAddress(userId);
  return { userInfo, userOrder, userAddress };
}

getUserData(userId)
  .then(data => {
    // 处理获取到的用户信息、订单和地址
    console.log(data.userInfo, data.userOrder, data.userAddress);
  })
  .catch(error => {
    console.error(error);
  });

Im obigen Code sind getUserInfo, getUserOrder und getUserAddress alles asynchrone Anfragen, die Promise zurückgeben. Durch die Verwendung von async/await können wir ihre Reihenfolge garantieren, indem wir den Code einfach nacheinander schreiben. Die getUserData-Funktion ist eine High-Level-Funktion, die drei asynchrone Anforderungen enthält. Sie ruft Benutzerdaten ab und gibt ein Objekt zurück, das Benutzerinformationen, Bestellung und Adresse enthält. Die then-Methode des Promise-Objekts wird zur Verarbeitung der zurückgegebenen Daten und die Catch-Methode zur Fehlerbehandlung verwendet.

3. Verwenden Sie Promise.all und die Array-Destrukturierungssyntax

Die Promise.all-Methode ist eine von der Promise-API bereitgestellte Möglichkeit, mit der mehrere asynchrone Anforderungen parallel ausgeführt werden können , und Ergebnisse werden zurückgegeben, wenn sie abgeschlossen sind. In Verbindung mit async/await können wir die Array-Destrukturierungssyntax verwenden, um das zurückgegebene Ergebnis in ein Array zu dekonstruieren, wodurch die Verarbeitung der Ergebnisse mehrerer Anforderungen einfacher wird.

const userInfoPromise = fetch(`/api/user/${userId}/info`).then(response => response.json());
const userOrderPromise = fetch(`/api/user/${userId}/order`).then(response => response.json());
const userAddressPromise = fetch(`/api/user/${userId}/address`).then(response => response.json());

Promise.all([userInfoPromise, userOrderPromise, userAddressPromise])
  .then(([userInfo, userOrder, userAddress]) => {
    // 处理获取到的用户信息、订单和地址
    console.log(userInfo, userOrder, userAddress);
  })
  .catch(error => {
    console.error(error);
  });

Im obigen Code verwenden wir die Fetch-Funktion, um Benutzerinformationen, Bestellungen und Adressen abzurufen und diese jeweils in ein Promise-Objekt zu kapseln. Anschließend verwenden wir die Promise.all-Methode, um diese drei Promises parallel auszuführen und ihre Ergebnisse in ein Array zu zerlegen. Wie bei der obigen Methode wird die then-Methode des Promise-Objekts zur Verarbeitung der zurückgegebenen Daten und die Catch-Methode zur Fehlerbehandlung verwendet.

Durch die Verwendung von Callback-Funktionen, async/await und Promise.all können wir die Reihenfolge mehrerer asynchroner Anfragen einfach verwalten und deren Ergebnisse verarbeiten. Je nach Szenario und Bedarf können wir die am besten geeignete Methode zum Schreiben von Node.js-Code auswählen.

Das obige ist der detaillierte Inhalt vonMehrere Anfragen von nodejs sorgen für Ordnung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!