HILFE ZUM KNOTENPUNKT

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

Regan Pun

29. September 2024

Teilen Sie:

Node Fetchist 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 der Browserumgebung verfügbar ist. Node-fetch bietet Unterstützung für die Fetch-API in Node.js und ermöglicht es Service-Workern, HTTP-Header zu bearbeiten und HTTPS-Anfragen effizient durchzuführen.

Dieser Artikel wird Ihnen helfen, die Hauptmerkmale und die Nutzung von Node-fetch zu erkunden, und bietet einen umfassenden Leitfaden für Entwickler, die ihre HTTP-Anfragenbearbeitung in Node.js optimieren möchten. Wir werden auch nutzenIronPDF, eine PDF-Bibliothek für Node.js, die Programmierern ermöglicht, PDFs zu erstellen und zu bearbeiten, HTML-Inhalte in PDFs umzuwandeln und vieles mehr.

Was ist Node.js Fetch?

Node abrufenist ein Modul, das die Fetch-API zu Node.js bringt. Die Fetch-API ist eine moderne Schnittstelle für 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 bearbeiten.

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

Hauptmerkmale von Node.js Fetch

1. Einfachheit und Vertrautheit

Node.js fetch ahmt die Fetch-API nach, die in Browsern zu finden ist, und bietet eine einfache und vertraute Schnittstelle für Entwickler.

2. Versprechen-basiert

Ähnlich wie die Fetch-API ist der Node.js-Fetch versprechensbasiert, was es Entwicklern ermöglicht, asynchronen Code auf eine lesbarere und verwaltbarere Weise zu schreiben.

3. Leicht

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

4. Kompatibilität

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

5. Streaming

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

Installation von Node.js Fetch

Für den Einstieg in dieNode-fetch, müssen Sie es über npm installieren(Node-Paketmanager). Führen Sie den folgenden Befehl in Ihrem Projektverzeichnis aus:

npm install node-fetch

Grundlegende Verwendung

Hier ist ein einfaches Beispiel, wie man mit Node.js fetch eine GET-Anfrage macht:

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

Dieser Codeausschnitt zeigt eine einfache GET-Anfrage zum Abrufen von JSON-Daten von einer API. Die fetch-Funktion gibt ein Versprechen zurück, das auf das Antwort-Objekt aufgelöst wird. Sie können dann Methoden aufrufen, die Antworten zurückgeben, wie json.()**um den Antwortinhalt zu analysieren.

Konsolenausgabe

Node.js Fetch(Wie es für Entwickler funktioniert): Abbildung 2 - Konsolenausgabe für eine einfache GET-Anfrage zum Abrufen von JSON-Daten von einer API-URL "https://jsonplaceholder.typicode.com/posts" mit Node.js fetch.

Erweiterte Verwendung

Node.js Fetch unterstützt auch fortschrittlichere Funktionen, beispielsweise das Senden von POST-Anfragen, das Festlegen eines benutzerdefinierten Anforderungsheader-Objekts und das Verarbeiten verschiedener Antworttypen.

Einen POST-Anfrage stellen

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

Dieses Beispiel zeigt, wie ein POST-Anforderungsobjekt mit einem JSON-Nutzlast gesendet wird. Die Option headers wird verwendet, um den Inhaltstyp der neuen Antwort anzugeben, und die Option body enthält die serialisierten JSON-Daten.

Konsolenausgabe

Node.js Fetch(Wie es für Entwickler funktioniert): Abbildung 3 - Konsolenausgabe für ein POST-Anfrageobjekt, das mit Node.js fetch an die URL „https://jsonplaceholder.typicode.com/posts“ gesendet wurde.

Umgang mit Streaming-Antworten

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

In diesem Beispiel wird der Antwortkörper als Dateistream an den Server geleitet, um zu demonstrieren, wie man große Antworten effizient verarbeitet.

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. Die Fehlerantwort von Node.js fetch bietet eine einfache Möglichkeit, Fehler mit Hilfe von Promises abzufangen und zu behandeln.

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

Hier wird ein Fehler ausgelöst, wenn der Status der Antwortheader nicht im Bereich von 200-299 liegt, und der Catch-Block behandelt alle Fehler, die während der Anfrage auftreten, andernfalls wird die gültige JSON-Antwort zurückgegeben.

Verwendung von Node.js-fetch mit IronPDF zur Erstellung von PDFs in Node.js

Node abrufenist eine beliebte Bibliothek im Node.js-Ökosystem für das Ausführen von HTTP-Fetch-Anfragen. Wenn kombiniert mitIronPDF, eine leistungsstarke PDF-Generierungsbibliothek, wird zu einem vielseitigen Werkzeug für die Erstellung von PDFs aus verschiedenen Webressourcen.

Was ist IronPDF?

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

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

Installation der IronPDF-Bibliothek

Zuerst müssen Sie installierenIronPDFin Ihrem Projekt. Verwenden Sie die folgenden npm-Befehle, um diese Bibliotheken zu installieren:

npm i @ironsoftware/ironpdf

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

Kombinieren 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önnten Sie die Daten eines API-Endpunkts abrufen, dynamisches HTML generieren undKonvertierung in ein PDF. Das folgende Beispiel zeigt, 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

Ausgabe PDF

Die JSON-Antwortausgabe wird elegant auf die HTML-Tabelle abgebildet und IronPDF konvertiert sie mit all ihren Stilen genau.

Node.js Fetch(Wie es für Entwickler funktioniert): Abbildung 6 - HTML-String, der mit IronPDF genau in PDF konvertiert wurde.

Für weitere Einzelheiten zuIronPDFund seine Funktionen, finden Sie in diesemDokumentationsseite.

Schlussfolgerung

Node abrufenist ein leistungsstarkes, aber einfaches Tool zur Durchführung von HTTP-Anfragen in Node.js. Seine vertraute API, der auf Versprechungen basierende Ansatz und die leichte Natur machen es zu einer hervorragenden Wahl sowohl für Anfänger als auch für erfahrene Entwickler. Egal, ob Sie grundlegende GET-Anfragen ausführen oder komplexe POST-Anfragen mit benutzerdefinierten Headern bearbeiten, bietet Node fetch eine saubere und effiziente Möglichkeit, mit Web-APIs zu interagieren.

KombinierenNode abrufen mitIronPDFbietet eine leistungsstarke und flexible Möglichkeit, PDFs aus verschiedenen Webinhalten in Node.js zu generieren. Durch die Integration dieser beiden Bibliotheken können Sie robuste Anwendungen erstellen, die Webdaten nutzen und mühelos professionelle PDFs erzeugen.

IronPDF beginnend bei $749. Erleben Sie die leistungsstarken Funktionen zur PDF-Erstellung risikofrei. Probieren Sie es noch heute aus und sehen Sie den Unterschied selbst.!

Regan Pun

Jetzt mit dem Ingenieurteam chatten

Software-Ingenieur

Regan schloss sein Studium an der University of Reading mit einem BA in Elektrotechnik ab. Bevor er zu Iron Software kam, konzentrierte er sich in seinen früheren Jobs auf einzelne Aufgaben. Was ihm bei Iron Software am meisten Spaß macht, ist das Spektrum der Aufgaben, die er übernehmen kann, sei es im Vertrieb, im technischen Support, in der Produktentwicklung oder im Marketing. Es macht ihm Spaß, die Art und Weise zu verstehen, wie Entwickler die Bibliothek von Iron Software nutzen, und dieses Wissen zu nutzen, um die Dokumentation und die Produkte kontinuierlich zu verbessern.

< PREVIOUS
Ramda JS NPM (Wie es für Entwickler funktioniert)

NÄCHSTES >
Multer Node.js (Wie es für Entwickler funktioniert)