requête synchrone nodejs

Node.js est un environnement d'exécution JavaScript construit sur le moteur Chrome V8 et basé sur un modèle d'E/S non bloquant et piloté par les événements, ce qui le rend performant lors du traitement de grandes collections de données et de requêtes simultanées élevées. Mais dans certains cas, nous devons faire des requêtes synchrones, car nous devons attendre que la requête précédente soit terminée avant de faire la requête suivante, ce qui nécessite des compétences particulières pour effectuer des requêtes synchrones.

Il existe de nombreuses façons d'effectuer des requêtes synchrones dans Node.js. Les méthodes les plus courantes incluent : l'utilisation de rappels, l'utilisation de Promise et l'utilisation d'async/await. L'utilisation de ces méthodes sera présentée ici.

1. Utiliser les rappels

La première méthode de traitement asynchrone dans Node.js est la fonction de rappel. Les opérations ultérieures peuvent être effectuées dans la fonction de rappel, ou la fonction de rappel peut être transmise en tant que valeur à d'autres fonctions. Une fonction de rappel est une fonction JavaScript qui peut appeler une autre fonction au sein de la fonction.

Lorsque vous effectuez une demande synchrone, vous pouvez utiliser la fonction de rappel pour vous assurer que la demande est terminée avant d'effectuer d'autres opérations. Par exemple :

const request = require('request');

request('https://jsonplaceholder.typicode.com/todos/1', function (error, response, body) {
  if (!error && response.statusCode == 200) {
    console.log(body) // 输出请求得到的结果
  }
})

Dans l'exemple ci-dessus, nous avons utilisé le module de requête pour effectuer des requêtes et afficher les résultats sur la console. Étant donné que la fonction de rappel est traitée de manière asynchrone, nous devons effectuer des opérations ultérieures dans la fonction de rappel. Cela garantit que d'autres opérations peuvent être effectuées une fois la demande terminée.

2. Utilisation de Promise

Promise est une méthode de traitement asynchrone plus avancée, qui fournit un code plus flexible et plus lisible. Une promesse représente l’achèvement ou l’échec éventuel d’une opération asynchrone et renvoie une valeur. Il simplifie la complexité du code asynchrone et prend en charge les appels chaînés.

Lorsque vous utilisez Promise pour effectuer des requêtes synchrones, vous pouvez utiliser le module request-promise. Ce module est la version Promise du module de requête, qui peut facilement convertir les requêtes de requête en objets Promise pour implémenter des requêtes synchrones. Par exemple :

const rp = require('request-promise');

rp('https://jsonplaceholder.typicode.com/todos/1')
  .then(function (response) {
    console.log(response);
  })
  .catch(function (err) {
    console.log(err);
  });

Dans l'exemple ci-dessus, nous avons utilisé le module request-promise pour effectuer la requête et utilisé l'objet Promise pour gérer le résultat de la requête. Cela garantit que d'autres opérations peuvent être effectuées une fois la demande terminée.

3. Utiliser async/await

async/await est la dernière méthode de traitement asynchrone d'ES2017. Il écrit le code asynchrone de manière plus synchrone, ce qui rend le code asynchrone plus lisible et maintenable.

Lorsque vous utilisez async/await pour effectuer des requêtes synchrones, vous devez utiliser le module request-promise. Par exemple :

const rp = require('request-promise');

async function getData() {
  const result = await rp('https://jsonplaceholder.typicode.com/todos/1');
  console.log(result);
}

getData().catch((err) => {
  console.error(err);
});

Dans l'exemple ci-dessus, nous avons utilisé async/await pour encapsuler le module request-promise. L'utilisation du mot-clé async peut transformer la fonction getData() en une fonction asynchrone, puis nous utilisons le mot-clé wait pour attendre la fin de la requête avant d'effectuer d'autres opérations à l'intérieur de la fonction.

Résumé

En tant que langage côté serveur hautes performances, Node.js a pleinement exploité ses capacités de traitement asynchrone. Mais dans certains cas, des requêtes synchrones sont requises. Dans ce cas, nous pouvons utiliser des rappels, Promise et async/await pour effectuer des requêtes synchrones. Dans le développement réel, la méthode la plus appropriée peut être sélectionnée en fonction de la situation réelle.

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!