Icône de message
Passer au contenu du pied de page
  1. IronPDF for Node.js
  2. Blog IronPDF for Node.js
  3. Aide Node
  4. Fetch Node.js
AIDE NODE

Node.js Fetch (Comment ça marche pour les développeurs)

Darrius Serrant
Darrius Serrant
Mis à jour:

Node Fetch est un module léger populaire dans l'écosystème Node.js, conçu pour rendre les requêtes HTTP simples et intuitives. Il fournit un moyen léger et familier d'interagir avec les API web, inspiré par l'API Fetch disponible dans l'environnement de navigateur. Node-fetch fournit la prise en charge de l'API Fetch dans Node.js, permettant aux travailleurs 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 à simplifier leur gestion des requêtes HTTP dans Node.js. Nous utiliserons également IronPDF, une bibliothèque PDF pour Node.js qui permet aux programmeurs de créer et d'éditer des PDFs, de convertir du contenu HTML en PDF, et bien plus encore.

Qu'est-ce que Node.js fetch ?

Node fetch est 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 réplique 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 qui sont déjà familiers avec l'API Fetch ou ceux cherchant un moyen simple de gérer les requêtes HTTP dans leurs applications Node.js.

Fonctionnement de la fonction Fetch de Node.js pour les développeurs : Figure 1 - Fonction Fetch de Node.js

Caractéristiques principales de Node.js Fetch

1. Simplicité et Familiarité

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

2. Basé sur Promesse

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

3. Légèreté

Node.js fetch est une bibliothèque minimaliste, la rendant rapide et efficace. Elle n'a pas la surcharge des bibliothèques HTTP plus grandes, gardant votre application légère.

4. Compatibilité

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

5. Streaming

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

Installer Node.js Fetch

Pour commencer avec Node-fetch, vous devez l'installer via NPM (Node Package Manager). Exécutez la commande suivante dans votre répertoire de projet :

npm install node-fetch
npm install node-fetch
SHELL

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';

const url = 'https://jsonplaceholder.typicode.com/posts';

// Make a GET request to fetch data
fetch(url)
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        // Parse the response as JSON
        return response.json();
    })
    .then(data => {
        // Process the JSON data
        console.log(data);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('There has been a problem with your fetch operation:', error);
    });
import fetch from 'node-fetch';

const url = 'https://jsonplaceholder.typicode.com/posts';

// Make a GET request to fetch data
fetch(url)
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        // Parse the response as JSON
        return response.json();
    })
    .then(data => {
        // Process the JSON data
        console.log(data);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('There has been a problem with your fetch operation:', error);
    });
JAVASCRIPT

Ce bout de code montre une simple requête GET pour récupérer des données JSON à partir d'une API. La fonction fetch retourne une promesse qui se résout à l'objet de réponse. Vous pouvez alors appeler des méthodes qui renvoient des réponses, telles que json() pour analyser le corps de la réponse.

Sortie Console

Fonctionnement de la fonction Fetch de Node.js pour les développeurs : Figure 2 - Sortie console d'une simple requête GET pour récupérer des données JSON depuis l'URL de l'API

Utilisation avancée

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

Faire une Requête POST

import fetch from 'node-fetch';

const url = 'https://jsonplaceholder.typicode.com/posts';
const data = { key: 'value' };

// Make a POST request with JSON payload
fetch(url, {
    method: 'POST',
    headers: {
        // Specify content type as JSON
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        // Parse the response as JSON
        return response.json();
    })
    .then(data => {
        // Process the JSON data
        console.log(data);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('There has been a problem with your fetch operation:', error);
    });
import fetch from 'node-fetch';

const url = 'https://jsonplaceholder.typicode.com/posts';
const data = { key: 'value' };

// Make a POST request with JSON payload
fetch(url, {
    method: 'POST',
    headers: {
        // Specify content type as JSON
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        // Parse the response as JSON
        return response.json();
    })
    .then(data => {
        // Process the JSON data
        console.log(data);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('There has been a problem with your fetch operation:', error);
    });
JAVASCRIPT

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

Sortie Console

Fonctionnement de la fonction Fetch de Node.js (pour les développeurs) : Figure 3 - Sortie console pour un objet de requête POST envoyé à l'URL

Gestion des Réponses en Streaming

import fetch from 'node-fetch';
import fs from 'fs';

const url = 'https://jsonplaceholder.typicode.com/posts';

// Make a GET request to fetch data and stream it to a file
fetch(url)
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        // Pipe the response body as a file stream to 'large-data.json'
        const dest = fs.createWriteStream('./large-data.json');
        response.body.pipe(dest);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        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';

// Make a GET request to fetch data and stream it to a file
fetch(url)
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        // Pipe the response body as a file stream to 'large-data.json'
        const dest = fs.createWriteStream('./large-data.json');
        response.body.pipe(dest);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('There has been a problem with your fetch operation:', error);
    });
JAVASCRIPT

Dans cet exemple, le corps de la réponse est envoyé au serveur comme un flux de fichiers, démontrant comment gérer efficacement les grandes réponses.

SORTIE

Récupération de données Node.js (Fonctionnement pour les développeurs) : Figure 4 - Fichier de sortie : large-data.json

Gestion des erreurs

Une gestion appropriée des erreurs est cruciale lorsque vous travaillez avec des requêtes HTTP. Node.js fetch fournit un moyen simple d'attraper et de gérer les erreurs à l'aide de promesses.

fetch(url)
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        // Parse the response as JSON
        return response.json();
    })
    .then(data => {
        // Process the JSON data
        console.log(data);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('Fetch error:', error);
    });
fetch(url)
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        // Parse the response as JSON
        return response.json();
    })
    .then(data => {
        // Process the JSON data
        console.log(data);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('Fetch error:', error);
    });
JAVASCRIPT

Ici, une erreur est lancée si le statut de la réponse n'est pas dans la plage 200-299, et le bloc catch gère les erreurs qui surviennent pendant la requête. Sinon, la réponse JSON valide est renvoyée.

Utiliser Node.js fetch avec IronPDF pour Générer des PDFs dans Node.js

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

Qu'est-ce qu'IronPDF ?

IronPDF est une bibliothèque robuste qui permet aux développeurs de créer, éditer et extraire du contenu des PDFs de manière simple et efficace. Disponible pour C#, Python, Java, et Node.js, IronPDF rend la manipulation de PDF simple avec son API intuitive.

Récupération de données Node.js (Fonctionnement pour les développeurs) : Figure 5 - IronPDF for Node.js: La bibliothèque PDF pour Node.js

Installation de la bibliothèque IronPDF

Tout d'abord, vous devez installer IronPDF dans votre projet. Utilisez la commande npm suivante pour installer la bibliothèque :

 npm i @ironsoftware/ironpdf

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

Combiner Node.js fetch et IronPDF

Vous pouvez tirer parti de la puissance de Node.js fetch et IronPDF pour récupérer dynamiquement du contenu web et générer des PDFs. Par exemple, vous pouvez récupérer les données d'un point de terminaison API, générer du HTML dynamique et les convertir en PDF. L'exemple suivant démontre comment vous pouvez réaliser 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 réponse JSON est élégamment mappée au tableau HTML et IronPDF la convertit avec tous ses styles exactement.

Node.js Fetch (Fonctionnement pour les développeurs) : Figure 6 - Chaîne HTML convertie en PDF avec précision grâce à IronPDF .

Pour plus de détails sur IronPDF et ses fonctionnalités, veuillez vous référer à cette page de documentation.

Conclusion

Node fetch est un outil puissant mais simple pour effectuer des requêtes HTTP dans Node.js. Son API familière, son approche basée sur les promesses et sa légèreté 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.

Combiner Node fetch avec IronPDF offre 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 des PDFs professionnels avec facilité.

IronPDF commençant à $999. 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 !

Darrius Serrant
Darrius Serrant
  Discutez maintenant avec l'équipe d'ingénierie
Ingénieur logiciel Full Stack (WebOps)

Darrius Serrant est titulaire d'un baccalauréat en informatique de l'université de Miami et travaille comme ingénieur marketing WebOps Full Stack chez Iron Software. Attiré par le codage dès son plus jeune âge, il a vu l'informatique comme à la fois mystérieuse et accessible, en faisant le ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi