nodejs plusieurs requêtes maintiennent l'ordre

Node.js est un environnement d'exécution JavaScript basé sur des événements, couramment utilisé pour développer des applications réseau hautes performances et évolutives. Dans de nombreux scénarios, nous devons envoyer plusieurs requêtes à différentes API ou sources de données, et l'ordre de ces requêtes doit être garanti. Cet article présente trois façons de maintenir l'ordre pour plusieurs demandes.

1. Utiliser les fonctions de rappel

Dans Node.js, les fonctions de rappel sont au cœur de la programmation asynchrone. Dans plusieurs requêtes, nous pouvons utiliser la fonction de rappel d'une requête comme fonction de rappel d'une autre requête pour assurer leur commande.

Par exemple, nous souhaitons envoyer trois requêtes HTTP, à savoir pour obtenir des informations sur l'utilisateur, obtenir la commande de l'utilisateur et obtenir l'adresse de l'utilisateur. Ces trois requêtes doivent être exécutées dans l'ordre car les requêtes suivantes doivent s'appuyer sur les données de la requête précédente.

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

Dans le code ci-dessus, getUserInfo, getUserOrder et getUserAddress sont toutes des requêtes HTTP asynchrones et leurs fonctions de rappel servent de fonctions de rappel pour une autre requête. De cette manière, nous pouvons garantir l’ordre des demandes et traiter les données correspondantes une fois chaque demande terminée.

2. Utiliser async/await

Dans la norme ES2017, JavaScript a introduit la syntaxe async/await, qui est une méthode de programmation asynchrone basée sur Promise. En utilisant async/await, nous pouvons faire ressembler le code asynchrone à du code synchrone, ce qui facilite la gestion de l'ordre de plusieurs requêtes asynchrones.

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

Dans le code ci-dessus, getUserInfo, getUserOrder et getUserAddress sont toutes des requêtes asynchrones qui renvoient Promise. En utilisant async/await, nous pouvons garantir leur ordre en écrivant simplement du code séquentiellement. La fonction getUserData est une fonction de haut niveau contenant trois requêtes asynchrones. Elle obtient les données utilisateur et renvoie un objet contenant les informations, l'ordre et l'adresse de l'utilisateur. La méthode then de l'objet Promise est utilisée pour traiter les données renvoyées et la méthode catch est utilisée pour gérer les erreurs.

3. Utilisez Promise.all et la syntaxe de déstructuration de tableaux

La méthode Promise.all est un moyen fourni par l'API Promise qui peut être utilisé pour exécuter plusieurs requêtes asynchrones en parallèle et renvoyer des résultats une fois terminées. Lorsqu'il est utilisé conjointement avec async/await, nous pouvons utiliser la syntaxe de déstructuration de tableau pour déconstruire le résultat renvoyé en un tableau, ce qui facilite la gestion des résultats de plusieurs requêtes.

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

Dans le code ci-dessus, nous utilisons la fonction fetch pour obtenir des informations sur les utilisateurs, des commandes et des adresses, et les encapsuler respectivement dans un objet Promise. Nous utilisons ensuite la méthode Promise.all pour exécuter ces trois promesses en parallèle et déstructurer leurs résultats dans un tableau. Comme la méthode ci-dessus, la méthode then de l'objet Promise est utilisée pour traiter les données renvoyées et la méthode catch est utilisée pour gérer les erreurs.

En utilisant les fonctions de rappel, async/await et Promise.all, nous pouvons facilement gérer l'ordre de plusieurs requêtes asynchrones et traiter leurs résultats. Selon différents scénarios et besoins, nous pouvons choisir la manière la plus appropriée d'écrire du code Node.js.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!