nodejs envoie plusieurs requêtes http

Avec le développement d'Internet, les progrès technologiques et l'émergence continue d'applications Internet, les gens ont de plus en plus de demandes en matière de communications réseau. Parmi ces communications réseau, le protocole http est la méthode la plus courante. Dans nodejs, nous pouvons facilement envoyer des requêtes http pour établir une communication réseau. Cet article explique comment envoyer plusieurs requêtes http à l'aide de nodejs.

1. Module http

Dans nodejs, le module http est un module utilisé pour gérer le protocole http. Il fournit des API pratiques pour créer des serveurs et des clients HTTP, gérer les requêtes HTTP entrantes et envoyer des requêtes HTTP.

Deux méthodes peuvent être utilisées pour envoyer des requêtes http à l'aide du module http :

• http.request(options[, callback]) : utilisé pour envoyer des requêtes http et renvoyer un objet http.ClientRequest, qui fournit quelques méthodes pour configurer les requêtes , envoyer des demandes et traiter les réponses.
• http.get(options[, callback]) : Utilisé pour envoyer des requêtes http GET. Cette méthode est un wrapper de la méthode http.request. Les demandes peuvent être simplifiées et les paramètres de demande sont fournis au format URL.

2. Promise

Nous savons que la programmation asynchrone est une méthode de programmation très courante dans nodejs, nous pouvons donc utiliser Promise pour effectuer une programmation asynchrone de plusieurs requêtes http.

Promise est un objet qui représente les résultats futurs, et Promise lui-même est un constructeur qui reçoit un paramètre de fonction. La fonction a deux paramètres : résoudre et rejeter, qui représentent respectivement les fonctions de rappel de réussite et d'échec.

L'avantage d'utiliser Promise est qu'il peut résoudre le problème de l'enfer des rappels et rendre le code plus lisible et maintenable.

3. async/await

Le sucre syntaxique async/wait introduit dans ES6 nous permet d'implémenter une programmation asynchrone sans utiliser Promise, rendant le code plus concis et clair.

async/await simplifie et encapsule en fait Promise. Il utilise le mot-clé async pour déclarer une fonction asynchrone, puis utilise le mot-clé wait pour attendre le résultat de l'opération asynchrone, afin que l'exécution du programme puisse être effectuée dans l'ordre et les rappels sont évités. Les problèmes avec l'enfer.

Ci-dessous, nous utiliserons Promise et async/await pour envoyer plusieurs requêtes http.

4. Exemple d'utilisation de Promise pour envoyer plusieurs requêtes http

Nous supposons que nous voulons envoyer des requêtes http à plusieurs sites Web et fusionner les résultats renvoyés par ces sites Web.

Nous créons d'abord un tableau pour stocker l'URL cible et la méthode de requête de ces requêtes (ici nous utilisons la méthode GET), comme indiqué ci-dessous :

const targets = [
    {url: 'https://www.baidu.com', method: 'GET'},
    {url: 'https://www.google.com', method: 'GET'},
    {url: 'https://www.bing.com', method: 'GET'},
];

Ensuite, nous définissons une fonction qui reçoit une url cible et une méthode de requête, et Renvoie un objet Promise pour envoyer des requêtes http et traiter les réponses. L'implémentation de la fonction est la suivante :

const http = require('http');

function sendRequest(target) {
    return new Promise((resolve, reject) => {
        const req = http.request(target, res => {
            let result = '';
            res.setEncoding('utf8');
            res.on('data', chunk => {
                result += chunk;
            });
            res.on('end', () => {
                resolve(result);
            });
        });
        req.on('error', err => {
            reject(err);
        });
        req.end();
    });
}

Dans la fonction ci-dessus, nous utilisons la méthode http.request pour envoyer une requête http et recevons les données de réponse via l'événement res.on('data', ...) fonction de gestion, et via res. La fonction de gestion d'événement on('end', ...) gère la logique après la fin de la réponse et renvoie finalement les données de réponse reçues comme résultat de Promise.

Nous pouvons tester si cette fonction fonctionne correctement grâce au code suivant.

sendRequest({url: 'https://www.baidu.com', method: 'GET'})
    .then(result => {
         console.log(result);
     })
     .catch(err => {
          console.error('An error occurred:', err);
     });

Nous pouvons maintenant définir une fonction qui reçoit plusieurs URL cibles et méthodes de requête et renvoie un objet Promise pour envoyer plusieurs requêtes http et fusionner leurs résultats. L'implémentation de la fonction est la suivante :

function sendMultiRequests(targets) {
    return Promise.all(targets.map(target => {
        return sendRequest(target);
    }));
}

Dans la fonction ci-dessus, nous utilisons la méthode Promise.all pour encapsuler plusieurs objets Promise dans un nouvel objet Promise. Lorsque toutes les promesses actuelles réussissent, la promesse renvoyée réussit. toute promesse échoue, la promesse renvoyée échouera.

Nous pouvons désormais utiliser cette fonction pour envoyer plusieurs requêtes http et fusionner leurs résultats.

sendMultiRequests(targets)
    .then(results => {
        console.log('All requests completed.');
        console.log('Results:');
        console.log(results);
    })
    .catch(err => {
        console.error('An error occurred:', err);
    });

Lorsque toutes les requêtes http sont terminées, nous fusionnons leurs résultats et les imprimons.

5. Exemple d'utilisation de async/await pour envoyer plusieurs requêtes http

Dans ES6, nous pouvons utiliser la syntaxe async/await pour implémenter une programmation asynchrone. Nous pouvons implémenter le code ci-dessus en utilisant async/await. Le cœur de cette implémentation est d'encapsuler Promise en tant que fonction asynchrone et d'utiliser le mot-clé wait pour attendre la fin des opérations asynchrones.

Ce qui suit est un exemple d'utilisation de async/await pour envoyer plusieurs requêtes http.

async function sendRequests(targets) {
    const results = await Promise.all(targets.map(async target => {
        const result = await sendRequest(target);
        return result;
    }));
    return results;
}

Dans le code ci-dessus, nous définissons une fonction asynchrone sendRequests pour envoyer plusieurs requêtes http et attendre leurs résultats. La méthode Promise.all renvoie un objet Promise. Lorsque toutes les promesses réussissent, la promesse renvoyée réussira. Si une promesse échoue, la promesse renvoyée échouera. Nous utilisons le mot-clé wait pour attendre la fin de l'objet Promise et attribuer directement le résultat au tableau de résultats.

Nous pouvons utiliser le code suivant pour tester si cette fonction asynchrone fonctionne correctement.

sendRequests(targets)
    .then(results => {
        console.log('All requests completed.');
        console.log('Results:');
        console.log(results);
    })
    .catch(err => {
        console.error('An error occurred:', err);
    });

Lorsque toutes les requêtes http sont terminées, nous fusionnons leurs résultats et les imprimons.

6. Résumé

Cet article présente deux façons d'envoyer plusieurs requêtes http à l'aide de nodejs. La première consiste à utiliser Promise pour envoyer plusieurs requêtes http et fusionner leurs résultats. La deuxième façon consiste à utiliser le sucre de syntaxe async/await pour envoyer plusieurs requêtes http et attendre leurs résultats. Que vous utilisiez Promise ou async/await, vous pouvez facilement implémenter une programmation asynchrone de plusieurs requêtes http, rendant le code plus lisible et maintenable.

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!