Faire des requêtes HTTP dans Node.js avec Got

Lors de la création d'applications dans Node.js, l'envoi de requêtes HTTP est une tâche fondamentale, que vous interagissiez avec des API externes, récupériez des données ou communiquiez entre services. Bien que Node.js dispose d'un module http intégré pour effectuer des requêtes, ce n'est pas la solution la plus conviviale ou la plus riche en fonctionnalités. C'est là qu'interviennent les bibliothèques comme Got.

Got est un client HTTP léger, riche en fonctionnalités et basé sur des promesses pour Node.js. Il simplifie le processus de création de requêtes HTTP, en fournissant une API propre, des tentatives automatiques, la prise en charge des flux, etc. Dans cet article, nous explorerons comment utiliser Got pour effectuer des requêtes HTTP et gérer les erreurs.

Pourquoi choisir Got pour les requêtes HTTP ?

Avant de plonger dans le code, il est important de comprendre pourquoi Got est un choix préféré pour de nombreux développeurs :

• API simple : Got fournit une API propre et intuitive qui facilite l'exécution de différents types de requêtes HTTP.
• Basé sur des promesses : Got est entièrement basé sur des promesses, vous permettant d'utiliser la syntaxe async/await pour un code plus propre et plus lisible.
• Tentatives automatiques : Got peut réessayer automatiquement les requêtes en cas de panne de réseau ou d'autres problèmes, ce qui est particulièrement utile pour améliorer la fiabilité de votre application.
• Prise en charge des flux : Got prend en charge le streaming, ce qui est utile pour télécharger des fichiers volumineux ou travailler avec des données en morceaux.
• Personnalisable : Got est hautement personnalisable, avec des options pour modifier les en-têtes, les paramètres de requête, les délais d'attente, etc.

Installation de Got

Pour démarrer avec Got, vous devez d'abord l'installer dans votre projet Node.js. Si vous n'avez pas encore configuré de projet Node.js, suivez ces étapes :

1. Initialisez votre projet : Ouvrez votre terminal et créez un nouveau répertoire pour votre projet :

   mkdir got-http-requests
   cd got-http-requests
   npm init -y

Cette commande crée un nouveau répertoire de projet et l'initialise avec un fichier package.json.

1. Installer Got : Ensuite, installez Got en utilisant npm :

   npm install got

Got est maintenant ajouté à votre projet et vous pouvez commencer à l'utiliser pour effectuer des requêtes HTTP.

Faire des requêtes HTTP avec Got

Got facilite l'exécution de différents types de requêtes HTTP. Passons en revue quelques cas d'utilisation courants.

1. Faire une demande GET de base

Une requête GET est le type de requête HTTP le plus courant, généralement utilisé pour récupérer des données à partir d'un serveur. Avec Got, faire une requête GET est simple :

const got = require('got');

(async () => {
    try {
        const response = await got('https://jsonplaceholder.typicode.com/posts/1');
        console.log('GET Request:');
        console.log(response.body);
    } catch (error) {
        console.error('Error in GET request:', error.message);
    }
})();

• Explication :
• Endpoint : https://jsonplaceholder.typicode.com/posts/1 est une API de test qui renvoie les détails d'une publication avec l'ID 1.
• Got Syntaxe : La fonction got(url) envoie une requête GET à l'URL spécifiée. La réponse est traitée comme une promesse, ce qui nous permet d'utiliser wait pour attendre la réponse.
• Réponse : Le corps de la réponse est enregistré dans la console, qui contiendra les données JSON de la publication.

2. Faire une demande POST

Une requête POST est utilisée pour envoyer des données à un serveur, souvent pour créer une nouvelle ressource. Avec Got, vous pouvez facilement envoyer des données JSON dans une requête POST :

const got = require('got');

(async () => {
    try {
        const response = await got.post('https://jsonplaceholder.typicode.com/posts', {
            json: {
                title: 'foo',
                body: 'bar',
                userId: 1
            },
            responseType: 'json'
        });
        console.log('POST Request:');
        console.log(response.body);
    } catch (error) {
        console.error('Error in POST request:', error.message);
    }
})();

• Explication :
• Point de terminaison : https://jsonplaceholder.typicode.com/posts est utilisé pour créer une nouvelle publication sur le serveur.
• Données JSON : L'option json dans la requête Got permet de préciser les données à envoyer. Ici, nous envoyons un nouveau message avec un titre, un corps et un identifiant utilisateur.
• Réponse : La réponse du serveur, qui comprend les données envoyées avec un nouvel identifiant, est enregistrée dans la console.

3. Gestion des erreurs

Des problèmes de réseau ou des erreurs de serveur peuvent survenir lors des requêtes HTTP. Got fournit un moyen simple de gérer ces erreurs :

const got = require('got');

(async () => {
    try {
        const response = await got('https://nonexistent-url.com');
        console.log(response.body);
    } catch (error) {
        console.error('Error handling example:', error.message);
    }
})();

• Explication :
• URL inexistante : Cet exemple tente de faire une requête GET vers une URL qui n'existe pas.
• Gestion des erreurs : Got renvoie automatiquement une erreur lorsque la requête échoue. Le bloc catch capture cette erreur et enregistre le message d'erreur sur la console.

Fonctionnalités avancées de Got

Got ne consiste pas seulement à faire de simples requêtes GET et POST. Il est livré avec plusieurs fonctionnalités avancées qui peuvent vous aider à gérer des scénarios plus complexes.

1. Personnalisation des options de demande

Got vous permet de personnaliser les requêtes en définissant des en-têtes, des paramètres de requête, des délais d'attente, etc. :

const got = require('got');

(async () => {
    try {
        const response = await got('https://jsonplaceholder.typicode.com/posts/1', {
            headers: {
                'User-Agent': 'My-Custom-Agent'
            },
            searchParams: {
                userId: 1
            },
            timeout: 5000
        });
        console.log('Customized Request:');
        console.log(response.body);
    } catch (error) {
        console.error('Error in customized request:', error.message);
    }
})();

• Explanation:
• Headers: You can set custom headers using the headers option. Here, we set a custom User-Agent.
• Query Parameters: The searchParams option allows you to add query parameters to the URL.
• Timeout: The timeout option sets the maximum time (in milliseconds) the request can take before throwing an error.

2. Streaming with Got

Got supports streaming, which is useful for handling large data or working with files:

const fs = require('fs');
const got = require('got');

(async () => {
    const downloadStream = got.stream('https://via.placeholder.com/150');
    const fileWriterStream = fs.createWriteStream('downloaded_image.png');

    downloadStream.pipe(fileWriterStream);

    fileWriterStream.on('finish', () => {
        console.log('Image downloaded successfully.');
    });
})();

• Explanation:
• Streaming: The got.stream(url) function initiates a streaming GET request. The data is piped directly to a writable stream, such as a file.
• File Writing: The fs.createWriteStream() function is used to write the streamed data to a file.

Download the source code here.

Conclusion

Got is a versatile and powerful library for making HTTP requests in Node.js. It simplifies the process of interacting with web services by providing a clean and intuitive API, while also offering advanced features like error handling, timeouts, and streams. Whether you’re building a simple script or a complex application, Got is an excellent choice for handling HTTP requests.

By using Got, you can write cleaner, more maintainable code and take advantage of its robust feature set to meet the needs of your application. So the next time you need to make an HTTP request in Node.js, consider using Got for a hassle-free experience.

Thanks for reading…

Happy Coding!

The post Making HTTP Requests in Node.js with Got first appeared on Innovate With Folasayo.

The post Making HTTP Requests in Node.js with Got appeared first on Innovate With Folasayo.

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!