Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF for Node.js
  2. IronPDF für den Node.js Blog
  3. Node-Hilfe
  4. Node.js Fetch
NODE-HILFE

Node.js Fetch (Wie es für Entwickler funktioniert)

Darrius Serrant
Darrius Serrant
Aktualisiert:

Node Fetch ist ein beliebtes leichtgewichtiges Modul im Node.js-Ökosystem, das entwickelt wurde, um HTTP-Anfragen einfach und intuitiv zu gestalten. Es bietet eine leichte und vertraute Möglichkeit, mit Web-APIs zu interagieren, inspiriert von der Fetch-API, die in Browserumgebungen verfügbar ist. Node-fetch bietet Unterstützung für die Fetch-API in Node.js, was es Servicearbeitern ermöglicht, HTTP-Header zu verwalten und HTTPS-Anfragen effizient durchzuführen.

Dieser Artikel hilft Ihnen, die wichtigsten Funktionen und die Nutzung von Node-fetch zu erkunden und bietet einen umfassenden Leitfaden für Entwickler, die ihr HTTP-Anfrage-Handling in Node.js optimieren möchten. Wir werden auch IronPDF nutzen, eine PDF-Bibliothek für Node.js, die Programmierern ermöglicht, PDFs zu erstellen und zu bearbeiten, HTML-Inhalte in PDFs zu konvertieren und vieles mehr.

Was ist Node.js fetch?

Node fetch ist ein Modul, das die Fetch-API zu Node.js bringt. Die Fetch-API ist eine moderne Schnittstelle für die Durchführung von HTTP-Anfragen, die häufig in Webbrowsern verwendet wird. Node.js fetch repliziert diese Funktionalität und ermöglicht es Node.js-Anwendungen, HTTP-Anfragen mit derselben Leichtigkeit und Einfachheit durchzuführen. Dies macht es zu einer ausgezeichneten Wahl für Entwickler, die bereits mit der Fetch-API vertraut sind oder nach einer einfachen Möglichkeit suchen, HTTP-Anfragen in ihren Node.js-Anwendungen zu verwalten.

Node.js Fetch (So funktioniert es für Entwickler): Abbildung 1 - Node.js Fetch

Wichtige Funktionen von Node.js Fetch

1. Einfachheit und Vertrautheit

Node.js fetch imitiert die in Browsern gefundene Fetch-API und bietet Entwicklern eine einfache und vertraute Schnittstelle.

2. Auf Versprechen basierend

Genau wie die Fetch-API basiert Node.js fetch auf Versprechen, was es Entwicklern ermöglicht, asynchrone Code auf eine lesbare und handhabbare Weise zu schreiben.

3. Leichtgewichtig

Node.js fetch ist eine minimalistische Bibliothek, die es schnell und effizient macht. Es kommt nicht mit dem Overhead größerer HTTP-Bibliotheken, was Ihre Anwendung schlank hält.

4. Kompatibilität

Node.js fetch unterstützt eine breite Palette von HTTP-Methoden, -Headern und -Antworttypen, was es hochgradig vielseitig macht.

5. Streaming

Es unterstützt Streaming-Antworten, was nützlich ist, um große Datenmengen effizient zu verarbeiten.

Installation von Node.js Fetch

Um mit Node-fetch zu beginnen, müssen Sie es über NPM (Node Package Manager) installieren. Führen Sie den folgenden Befehl in Ihrem Projektverzeichnis aus:

npm install node-fetch
npm install node-fetch
SHELL

Grundlegende Nutzung

Hier ist ein einfaches Beispiel dafür, wie man Node.js fetch verwendet, um eine GET-Anfrage zu machen:

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

Dieses Codebeispiel zeigt eine einfache GET-Anfrage, um JSON-Daten von einer API abzurufen. Die fetch-Funktion gibt ein Versprechen zurück, das zum Antwortobjekt aufgelöst wird. Sie können dann Methoden aufrufen, die Antworten zurückgeben, wie json(), um den Antwortkörper zu analysieren.

Konsolenausgabe

Node.js Fetch (So funktioniert es für Entwickler): Abbildung 2 – Konsolenausgabe einer einfachen GET-Anfrage zum Abrufen von JSON-Daten von der API-URL

Erweiterte Nutzung

Node.js fetch unterstützt auch fortgeschrittenere Funktionen, wie das Erstellen von POST-Anfragen, das Setzen benutzerdefinierter Anfrage-Header und die Verwaltung verschiedener Antworttypen.

Erstellen einer POST-Anfrage

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

Dieses Beispiel zeigt, wie man eine POST-Anfrage mit einer JSON-Nutzlast sendet. Die Option headers wird verwendet, um den Inhaltstyp der Antwort zu spezifizieren, und die Option body enthält die serialisierten JSON-Daten.

Konsolenausgabe

Node.js Fetch (So funktioniert es für Entwickler): Abbildung 3 – Konsolenausgabe für ein POST-Anfrageobjekt, das mit Node.js fetch an die URL

Verwaltung von Streaming-Antworten

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

In diesem Beispiel wird der Antwortkörper als Dateistream auf den Server geleitet, was demonstriert, wie große Antworten effizient gehandhabt werden.

AUSGABE

Node.js Fetch (So funktioniert es für Entwickler): Abbildung 4 - Ausgabedatei: large-data.json

Fehlerbehandlung

Eine ordnungsgemäße Fehlerbehandlung ist entscheidend, wenn man mit HTTP-Anfragen arbeitet. Node.js fetch bietet eine einfache Möglichkeit, Fehler mit Hilfe von Versprechen abzufangen und zu behandeln.

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

Hier wird ein Fehler ausgelöst, wenn der Antwortstatus nicht im Bereich 200-299 liegt, und der catch-Block behandelt alle während der Anfrage auftretenden Fehler. Ansonsten wird die gültige JSON-Antwort zurückgegeben.

Verwendung von Node.js fetch mit IronPDF zur PDF-Erzeugung in Node.js

Node fetch ist eine beliebte Bibliothek im Node.js-Ökosystem für das Erstellen von HTTP-Fetch-Anfragen. In Kombination mit IronPDF, einer leistungsstarken PDF-Generierungsbibliothek, wird es zu einem vielseitigen Werkzeug zur Erstellung von PDFs aus verschiedenen Webressourcen.

Was ist IronPDF?

IronPDF ist eine robuste Bibliothek, die Entwicklern ermöglicht, Inhalte aus PDFs einfach und effizient zu erstellen, bearbeiten und zu extrahieren. Verfügbar für C#, Python, Java und Node.js, macht IronPDF die PDF-Verarbeitung mit seiner intuitiven API einfach.

Node.js Fetch (So funktioniert es für Entwickler): Abbildung 5 - IronPDF for Node.js: Die Node.js PDF-Bibliothek

Installation der IronPDF-Bibliothek

Zuerst müssen Sie IronPDF in Ihrem Projekt installieren. Verwenden Sie den folgenden npm-Befehl, um die Bibliothek zu installieren:

 npm i @ironsoftware/ironpdf

Lassen Sie uns erkunden, wie man Node.js fetch mit IronPDF verwendet, um PDFs aus Webinhaltsquellen zu erstellen.

Kombination von Node.js fetch und IronPDF

Sie können die Leistungsfähigkeit von sowohl Node.js fetch als auch IronPDF nutzen, um Webinhalte dynamisch abzurufen und PDFs zu erstellen. Zum Beispiel können Sie Daten von einem API-Endpunkt abrufen, dynamisches HTML generieren und es in ein PDF konvertieren. Das folgende Beispiel demonstriert, wie Sie diese Aufgabe erreichen können:

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

PDF-Ausgabe

Die JSON-Antwortausgabe wird elegant zur HTML-Tabelle abgebildet und IronPDF konvertiert sie mit all ihrem Styling genau.

Node.js Fetch (So funktioniert es für Entwickler): Abbildung 6 – HTML-String, der mit IronPDF präzise in PDF konvertiert wurde.

Für weitere Details zu IronPDF und seinen Funktionen, lesen Sie bitte diese Dokumentationsseite.

Abschluss

Node fetch ist ein leistungsstarkes, aber einfaches Werkzeug für die Durchführung von HTTP-Anfragen in Node.js. Seine vertraute API, versprechensbasierter Ansatz und leichte Natur machen es zu einer ausgezeichneten Wahl sowohl für Anfänger als auch für erfahrene Entwickler. Ob Sie grundlegende GET-Anfragen durchführen oder komplexe POST-Anfragen mit benutzerdefinierten Headern verarbeiten, Node fetch bietet eine saubere und effiziente Möglichkeit, mit Web-APIs zu interagieren.

Die Kombination von Node fetch mit IronPDF bietet eine leistungsstarke und flexible Möglichkeit, PDFs aus verschiedenen Webinhaltsquellen in Node.js zu erstellen. Indem Sie diese beiden Bibliotheken integrieren, können Sie robuste Anwendungen erstellen, die Webdaten nutzen und professionelle PDFs mühelos generieren.

IronPDF beginnt bei $999. Erleben Sie seine leistungsstarken PDF-Erzeugungsfunktionen risikofrei. Probieren Sie es noch heute aus und sehen Sie den Unterschied selbst!

Darrius Serrant
Darrius Serrant
  Jetzt mit dem Ingenieurteam chatten
Full-Stack-Software-Ingenieur (WebOps)

Darrius Serrant hat einen Bachelor-Abschluss in Informatik von der University of Miami und arbeitet als Full-Stack-WebOps-Marketing-Ingenieur bei Iron Software. Seit seiner Jugend vom Programmieren angezogen, sah er die Informatik als sowohl mysteriös als auch zugänglich, was es zum perfekten Medium für Kreativität und Problemlösung ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an