HILFE ZUM KNOTENPUNKT

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

Veröffentlicht 29. September 2024

Teilen Sie:

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 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 nutzen IronPDF, 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 abrufen ist 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 die Node-fetch, müssen Sie es über npm installieren (Node-Paketmanager). Führen Sie den folgenden Befehl in Ihrem Projektverzeichnis aus:

npm install node-fetch

npm install node-fetch

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'npm install node-fetch

VB C#

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);
    });

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'import fetch from 'node-fetch'; import fs from 'fs'; const url = 'https: 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); });

VB C#

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);
    });

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'import fetch from 'node-fetch'; import fs from 'fs'; const url = 'https: const data = { key: 'value' }; fetch(url, { method: 'POST', 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); });

VB C#

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);
    });

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'import fetch from 'node-fetch'; import fs from 'fs'; const url = 'https: 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); });

VB C#

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);
    });

fetch(url).then(Function(response)
	If Not response.ok Then
		Throw New [Error](`HTTP [error](Not status):= ${response.status}`)
	End If
	Return response.json()
End Function).then(Sub(data)
	console.log(data)
End Sub).catch(Function([error]) {console.error(})

VB C#

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 abrufen ist eine beliebte Bibliothek im Node.js-Ökosystem für das Ausführen von HTTP-Fetch-Anfragen. Wenn kombiniert mit IronPDF, eine leistungsstarke PDF-Generierungsbibliothek, wird zu einem vielseitigen Werkzeug für die 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, 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 installieren IronPDF in Ihrem Projekt. Verwenden Sie die folgenden npm-Befehle, um diese Bibliotheken zu installieren:

npm i @ironsoftware/ironpdf

npm i @ironsoftware/ironpdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'npm i @ironsoftware/ironpdf

VB C#

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 und Konvertierung 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!");
})();

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'import fetch from 'node-fetch'; import { PdfDocument } from '@ironsoftware/ironpdf'; (async() => { const apiUrl = "https://jsonplaceholder.typicode.com/posts"; const response = await fetch(apiUrl); const data = await response.json(); 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> `; const pdfFromHtmlString = await PdfDocument.fromHtml(htmlContent); await pdfFromHtmlString.saveAs("dynamic_report.pdf"); console.log("PDF generated from API data successfully!"); })();

VB C#

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 zu IronPDF und seine Funktionen, finden Sie in diesem Dokumentationsseite.

Schlussfolgerung

Node abrufen ist 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.

Kombinieren Node abrufen mit IronPDF bietet 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 ab $749. Erleben Sie die leistungsstarken PDF-Generierungsfunktionen risikofrei. Probieren Sie es noch heute aus und sehen Sie den Unterschied selbst.!

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

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