AIDE SUR LES NœUDS

Node.js Fetch (Comment cela fonctionne pour les développeurs)

Kannapat Udonpant

septembre 29, 2024

Node Fetchest un module léger populaire dans l'écosystème Node.js, conçu pour simplifier et rendre les requêtes HTTP intuitives. Il offre un moyen léger et familier d'interagir avec les API web, inspiré par l'API Fetch disponible dans l'environnement du navigateur. Node-fetch offre un support de l'API Fetch dans Node.js, permettant aux workers de service de gérer les en-têtes HTTP et d'effectuer des requêtes HTTPS de manière efficace.

Cet article vous aidera à explorer les principales fonctionnalités et l'utilisation de Node-fetch, offrant un guide complet pour les développeurs cherchant à optimiser la gestion de leurs requêtes HTTP dans Node.js. Nous utiliserons égalementIronPDF, une bibliothèque PDF pour Node.js qui permet aux programmeurs de créer et de modifier des fichiers PDF, de convertir du contenu HTML en PDF, et bien plus encore.

Qu'est-ce que le fetch de Node.js ?

Node fetchest un module qui apporte l'API Fetch à Node.js. L'API Fetch est une interface moderne pour effectuer des requêtes HTTP, couramment utilisée dans les navigateurs web. Node.js fetch reproduit cette fonctionnalité, permettant aux applications Node.js d'effectuer des requêtes HTTP avec la même facilité et simplicité. Cela en fait un excellent choix pour les développeurs déjà familiers avec l'API Fetch ou ceux qui recherchent un moyen simple de gérer les requêtes HTTP dans leurs applications Node.js.

Node.js Fetch(Comment cela fonctionne pour les développeurs) : Figure 1 - Node.js Fetch

Fonctionnalités clés de Node.js Fetch

1. Simplicité et Familiarité

Node.js fetch imite l'API Fetch trouvée dans les navigateurs, offrant une interface simple et familière pour les développeurs.

2. Basé sur des promesses

Tout comme l'API Fetch, le fetch de Node.js est basé sur les promesses, permettant aux développeurs d'écrire du code asynchrone de manière plus lisible et gérable.

3. Léger

Node.js fetch est une bibliothèque minimaliste, ce qui la rend rapide et efficace. Cela n'entraîne pas la surcharge des bibliothèques HTTP plus volumineuses, ce qui permet de garder votre application légère.

4. Compatibilité

La fonctionnalité fetch de Node.js prend en charge un large éventail de méthodes HTTP, d'en-têtes et de types de réponse, ce qui la rend très polyvalente.

5. Diffusion en continu

Il prend en charge les réponses en streaming, ce qui est utile pour gérer efficacement de grandes charges utiles.

Installation de Node.js Fetch

Pour commencerNode-fetch, vous devez l'installer via npm(Gestionnaire de paquets Node). Exécutez la commande suivante dans le répertoire de votre projet :

npm install node-fetch

Utilisation de base

Voici un exemple de base sur la façon d'utiliser Node.js fetch pour effectuer une requête GET :

import fetch from 'node-fetch';
import fs from 'fs';
const url = 'https://jsonplaceholder.typicode.com/posts';
fetch(url)
    .then(response => {
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        return response.json();
    })
    .then(data => {
        console.log(data);
    })
    .catch(error => {
        console.error('There has been a problem with your fetch operation:', error);
    });

import fetch from 'node-fetch';
import fs from 'fs';
const url = 'https://jsonplaceholder.typicode.com/posts';
fetch(url)
    .then(response => {
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        return response.json();
    })
    .then(data => {
        console.log(data);
    })
    .catch(error => {
        console.error('There has been a problem with your fetch operation:', error);
    });

JAVASCRIPT

Cet extrait de code démontre une simple requête GET pour récupérer des données JSON depuis une API. La fonction fetch renvoie une promesse qui se résout en l'objet de réponse. Vous pouvez ensuite appeler des méthodes qui renvoient des réponses, comme json() pour analyser le corps de la réponse.

Sortie de la console

Fetch Node.js (Comment cela fonctionne pour les développeurs) : Figure 2 - Sortie de la console pour une requête GET simple pour récupérer des données JSON à partir d'une URL d'API "https://jsonplaceholder.typicode.com/posts" en utilisant fetch de Node.js.

Utilisation avancée

Node.js fetch prend également en charge des fonctionnalités plus avancées, par exemple, telles que l'exécution de requêtes POST, la définition d'objets d'en-têtes de requête personnalisés et la gestion de différents types de réponse.

Effectuer une requête POST

import fetch from 'node-fetch';
import fs from 'fs';
const url = 'https://jsonplaceholder.typicode.com/posts';
const data = { key: 'value' };
fetch(url, {
    method: 'POST',
    // Content Type Header
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
    .then(response => {
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        return response.json();
    })
    .then(data => {
        console.log(data);
    })
    .catch(error => {
        console.error('There has been a problem with your fetch operation:', error);
    });

import fetch from 'node-fetch';
import fs from 'fs';
const url = 'https://jsonplaceholder.typicode.com/posts';
const data = { key: 'value' };
fetch(url, {
    method: 'POST',
    // Content Type Header
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
    .then(response => {
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        return response.json();
    })
    .then(data => {
        console.log(data);
    })
    .catch(error => {
        console.error('There has been a problem with your fetch operation:', error);
    });

JAVASCRIPT

Cet exemple montre comment envoyer un objet de requête POST avec une charge utile JSON. L'option headers est utilisée pour spécifier le type de contenu de la nouvelle réponse, et l'option body contient les données JSON sérialisées.

Sortie de la console

Node.js Fetch(Comment cela fonctionne pour les développeurs) : Figure 3 - Sortie de la console pour un objet de requête POST envoyé à l'URL "https://jsonplaceholder.typicode.com/posts" en utilisant Node.js fetch

Gestion des réponses en streaming

import fetch from 'node-fetch';
import fs from 'fs';
const url = 'https://jsonplaceholder.typicode.com/posts';
fetch(url)
    .then(response => {
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        const dest = fs.createWriteStream('./large-data.json');
        response.body.pipe(dest);
    })
    .catch(error => {
        console.error('There has been a problem with your fetch operation:', error);
    });

import fetch from 'node-fetch';
import fs from 'fs';
const url = 'https://jsonplaceholder.typicode.com/posts';
fetch(url)
    .then(response => {
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        const dest = fs.createWriteStream('./large-data.json');
        response.body.pipe(dest);
    })
    .catch(error => {
        console.error('There has been a problem with your fetch operation:', error);
    });

JAVASCRIPT

Dans cet exemple, le corps de la réponse est dirigé vers le serveur sous forme de flux de fichiers, démontrant comment gérer efficacement les réponses volumineuses.

SORTIE

Node.js Fetch(Comment cela fonctionne pour les développeurs) : Figure 4 - Fichier de sortie : large-data.json

Gestion des erreurs

La gestion correcte des erreurs est cruciale lors de la manipulation des requêtes HTTP. La réponse d'erreur de récupérage Node.js offre un moyen simple de capturer et de gérer les erreurs en utilisant des promesses.

fetch(url)
    .then(response => {
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        return response.json();
    })
    .then(data => {
        console.log(data);
    })
    .catch(error => {
        console.error('Fetch error:', error);
    });

fetch(url)
    .then(response => {
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        return response.json();
    })
    .then(data => {
        console.log(data);
    })
    .catch(error => {
        console.error('Fetch error:', error);
    });

JAVASCRIPT

Ici, une erreur est lancée si le statut des en-têtes de réponse n'est pas compris dans la plage 200-299, et le bloc catch gère toute erreur survenant lors de la requête, sinon la réponse JSON valide est renvoyée.

Utilisation de Node.js fetch avec IronPDF pour générer des PDF dans Node.js

Node fetchest une bibliothèque populaire dans l'écosystème Node.js pour effectuer des requêtes HTTP fetch. Lorsqu'il est combiné avecIronPDF, une bibliothèque puissante de génération de PDF, devient un outil polyvalent pour créer des PDFs à partir de diverses ressources web.

Qu'est-ce qu'IronPDF ?

IronPDFest une bibliothèque robuste qui permet aux développeurs de créer, modifier et extraire du contenu des PDF de manière simple et efficace. Disponible pour C#, Python, Java et Node.js, IronPDF simplifie la manipulation des PDF grâce à son API intuitive.

Node.js Fetch(Comment cela fonctionne pour les développeurs) : Figure 5 - IronPDF for Node.js : La bibliothèque PDF Node.js

Installation de la bibliothèque IronPDF

Tout d'abord, vous devez installerIronPDFdans votre projet. Utilisez les commandes npm suivantes pour installer ces bibliothèques :

npm i @ironsoftware/ironpdf

Explorons comment utiliser Node.js fetch avec IronPDF pour générer des PDF à partir de sources de contenu web.

Combiner Node.js fetch et IronPDF

Vous pouvez exploiter la puissance à la fois de Node.js fetch et de IronPDF pour récupérer dynamiquement du contenu web et générer des PDF. Par exemple, vous pourriez récupérer les données d'un point de terminaison API, générer du HTML dynamique, et convertissez-le en PDF. L'exemple suivant montre comment vous pouvez accomplir cette tâche :

import fetch from 'node-fetch';
import { PdfDocument } from '@ironsoftware/ironpdf';
(async () => {
    // Replace the apiUrl with the actual Url
    const apiUrl = "https://jsonplaceholder.typicode.com/posts";
    // Fetch data from API
    const response = await fetch(apiUrl);
    const data = await response.json();
    // Create dynamic HTML content with a table
    const htmlContent = `
        <!DOCTYPE html>
        <html>
        <head>
            <title>Data Report</title>
            <style>
                body {
                    font-family: Arial, sans-serif;
                    margin: 40px;
                }
                table {
                    width: 100%;
                    border-collapse: collapse;
                }
                table, th, td {
                    border: 1px solid black;
                }
                th, td {
                    padding: 10px;
                    text-align: left;
                }
                th {
                    background-color: #f2f2f2;
                }
                h1 {
                    text-align: center;
                }
            </style>
        </head>
        <body>
            <h1>Data Report</h1>
            <table>
                <tr>
                    <th>User ID</th>
                    <th>ID</th>
                    <th>Title</th>
                    <th>Body</th>
                </tr>
                ${data.map(item => `
                    <tr>
                        <td>${item.userId}</td>
                        <td>${item.id}</td>
                        <td>${item.title}</td>
                        <td>${item.body}</td>
                    </tr>
                `).join('')}
            </table>
        </body>
        </html>
    `;
    // Generate PDF from the HTML string
    const pdfFromHtmlString = await PdfDocument.fromHtml(htmlContent);
    await pdfFromHtmlString.saveAs("dynamic_report.pdf");
    console.log("PDF generated from API data successfully!");
})();

import fetch from 'node-fetch';
import { PdfDocument } from '@ironsoftware/ironpdf';
(async () => {
    // Replace the apiUrl with the actual Url
    const apiUrl = "https://jsonplaceholder.typicode.com/posts";
    // Fetch data from API
    const response = await fetch(apiUrl);
    const data = await response.json();
    // Create dynamic HTML content with a table
    const htmlContent = `
        <!DOCTYPE html>
        <html>
        <head>
            <title>Data Report</title>
            <style>
                body {
                    font-family: Arial, sans-serif;
                    margin: 40px;
                }
                table {
                    width: 100%;
                    border-collapse: collapse;
                }
                table, th, td {
                    border: 1px solid black;
                }
                th, td {
                    padding: 10px;
                    text-align: left;
                }
                th {
                    background-color: #f2f2f2;
                }
                h1 {
                    text-align: center;
                }
            </style>
        </head>
        <body>
            <h1>Data Report</h1>
            <table>
                <tr>
                    <th>User ID</th>
                    <th>ID</th>
                    <th>Title</th>
                    <th>Body</th>
                </tr>
                ${data.map(item => `
                    <tr>
                        <td>${item.userId}</td>
                        <td>${item.id}</td>
                        <td>${item.title}</td>
                        <td>${item.body}</td>
                    </tr>
                `).join('')}
            </table>
        </body>
        </html>
    `;
    // Generate PDF from the HTML string
    const pdfFromHtmlString = await PdfDocument.fromHtml(htmlContent);
    await pdfFromHtmlString.saveAs("dynamic_report.pdf");
    console.log("PDF generated from API data successfully!");
})();

JAVASCRIPT

Sortie PDF

La sortie de la réponse JSON est élégamment mappée sur le tableau HTML et IronPDF la convertit avec toute sa mise en forme de manière précise.

Node.js Fetch(Comment ça fonctionne pour les développeurs) : Figure 6 - Chaîne HTML convertie en PDF avec précision à l'aide de IronPDF.

Pour plus de détails surIronPDFet ses fonctionnalités, veuillez vous référer à cecipage de documentation.

Conclusion

Node fetchest un outil puissant mais simple pour effectuer des requêtes HTTP dans Node.js. Son API familière, son approche fondée sur les promesses et sa nature légère en font un excellent choix pour les débutants comme pour les développeurs expérimentés. Que vous effectuiez des requêtes GET basiques ou que vous gériez des requêtes POST complexes avec des en-têtes personnalisés, Node fetch offre un moyen propre et efficace d'interagir avec les API web.

CombinaisonNode fetch avecIronPDFfournit un moyen puissant et flexible de générer des PDFs à partir de diverses sources de contenu web dans Node.js. En intégrant ces deux bibliothèques, vous pouvez créer des applications robustes qui exploitent les données web et génèrent facilement des PDF professionnels.

IronPDF à partir de $749. Découvrez ses puissantes fonctionnalités de génération de PDF sans risque. Essayez-le dès aujourd'hui et voyez la différence par vous-même.!

Kannapat Udonpant

Discutez avec l'équipe d'ingénierie maintenant

Ingénieur logiciel

Avant de devenir ingénieur logiciel, Kannapat a obtenu un doctorat en ressources environnementales à l'université d'Hokkaido au Japon. Tout en poursuivant ses études, Kannapat est également devenu membre du Vehicle Robotics Laboratory, qui fait partie du Department of Bioproduction Engineering (département d'ingénierie de la bioproduction). En 2022, il a mis à profit ses compétences en C# pour rejoindre l'équipe d'ingénieurs d'Iron Software, où il se concentre sur IronPDF. Kannapat apprécie son travail car il apprend directement auprès du développeur qui écrit la majeure partie du code utilisé dans IronPDF. Outre l'apprentissage par les pairs, Kannapat apprécie l'aspect social du travail chez Iron Software. Lorsqu'il n'écrit pas de code ou de documentation, Kannapat peut généralement être trouvé en train de jouer sur sa PS5 ou de revoir The Last of Us.

< PRÉCÉDENT
Ramda JS NPM (Comment cela fonctionne pour les développeurs)

SUIVANT >
Multer Node.js (Comment ça fonctionne pour les développeurs)