POMOC NODE

Node.js Fetch (jak to działa dla programistów)

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Zaktualizowano:22 czerwca, 2025

Node Fetch to popularny, lekki moduł w ekosystemie Node.js, zaprojektowany w celu uproszczenia i intuicyjnego wykonywania żądań HTTP. Zapewnia lekki i znany sposób interakcji z interfejsami API sieci Web, zainspirowany interfejsem API Fetch dostępnym w środowisku przeglądarki. Node-fetch zapewnia obsługę interfejsu API Fetch w środowisku Node.js, umożliwiając pracownikom serwisowym obsługę nagłówków HTTP i wydajne wykonywanie żądań HTTPS typu fetch.

Ten artykuł pomoże Ci poznać kluczowe funkcje i zastosowania Node-fetch, oferując kompleksowy przewodnik dla programistów pragnących usprawnić obsługę żądań HTTP w Node.js. Wykorzystamy również IronPDF for Node.js, bibliotekę PDF, która umożliwia programistom tworzenie i edycję plików PDF, konwersję treści HTML do formatu PDF i wiele więcej.

Czym jest Node.js fetch?

Node fetch to moduł, który udostępnia interfejs API Fetch w środowisku Node.js. Fetch API to nowoczesny interfejs do wysyłania żądań HTTP, powszechnie stosowany w przeglądarkach internetowych. Node.js fetch odtwarza tę funkcjonalność, umożliwiając aplikacjom Node.js wykonywanie żądań HTTP z taką samą łatwością i prostotą. To sprawia, że jest to doskonały wybór dla programistów, którzy znają już Fetch API, lub tych, którzy szukają prostego sposobu na obsługę żądań HTTP w swoich aplikacjach Node.js.

Node.js Fetch (jak to działa dla programistów): Rysunek 1 – Node.js Fetch

Kluczowe funkcje Node.js Fetch

1. Prostota i znajomość tematu

Node.js fetch naśladuje interfejs API Fetch występujący w przeglądarkach, zapewniając programistom prosty i znany interfejs.

2. Oparte na obietnicach

Podobnie jak Fetch API, Node.js fetch opiera się na obietnicach, umożliwiając programistom pisanie kodu asynchronicznego w sposób bardziej czytelny i łatwiejszy w zarządzaniu.

3. Lekki

Node.js fetch to minimalistyczna biblioteka, dzięki czemu jest szybka i wydajna. Nie wiąże się to z obciążeniem charakterystycznym dla większych bibliotek HTTP, dzięki czemu aplikacja pozostaje lekka.

4. Kompatybilność

Node.js fetch obsługuje szeroki zakres metod HTTP, nagłówków i typów odpowiedzi, co czyni go bardzo wszechstronnym.

5. Przesyłanie strumieniowe

Obsługuje strumieniowe odpowiedzi, co jest przydatne do wydajnego przetwarzania dużych ładunków danych.

Instalacja Node.js Fetch

Aby rozpocząć pracę z Node-fetch, należy zainstalować go za pomocą npm (Node Package Manager). Uruchom następujące polecenie w katalogu projektu:

npm install node-fetch

npm install node-fetch

SHELL

Podstawowe zastosowanie

Oto podstawowy przykład wykorzystania funkcji fetch w Node.js do wysłania żądania 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

Ten fragment kodu przedstawia proste żądanie GET służące do pobrania danych JSON z interfejsu API. Funkcja fetch zwraca obietnicę, która rozstrzyga się na obiekt odpowiedzi. Następnie można wywołać metody zwracające odpowiedzi, takie jak json(), aby przeanalizować treść odpowiedzi.

Wynik konsoli

Node.js Fetch (jak to działa dla programistów): Rysunek 2 – Wynik konsoli dla prostego żądania GET w celu pobrania danych JSON z adresu API

Zaawansowane zastosowania

Node.js fetch obsługuje również bardziej zaawansowane funkcje, takie jak wysyłanie żądań POST, ustawianie niestandardowych nagłówków żądań oraz obsługa różnych typów odpowiedzi.

Wysyłanie żądania 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

Ten przykład pokazuje, jak wysłać żądanie POST z ładunkiem JSON. Opcja headers służy do określenia typu zawartości odpowiedzi, a opcja body zawiera zserializowane dane JSON.

Wynik konsoli

Node.js Fetch (jak to działa dla programistów): Rysunek 3 – Wynik konsoli dla obiektu żądania POST wysłanego na adres URL

Obsługa odpowiedzi strumieniowych

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

W tym przykładzie treść odpowiedzi jest przekazywana do serwera jako strumień plików, co pokazuje, jak efektywnie obsługiwać duże odpowiedzi.

WYNIK

Node.js Fetch (jak to działa dla programistów): Rysunek 4 – Plik wyjściowy: large-data.json

Obsługa błędów

Prawidłowa obsługa błędów ma kluczowe znaczenie podczas pracy z żądaniami HTTP. Node.js fetch zapewnia prosty sposób na wychwytywanie i obsługę błędów przy użyciu obietnic.

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

W tym przypadku zgłaszany jest błąd, jeśli status odpowiedzi nie mieści się w zakresie 200–299, a blok catch obsługuje wszelkie błędy występujące podczas żądania. W przeciwnym razie zwracana jest prawidłowa odpowiedź JSON.

Wykorzystanie funkcji fetch w Node.js wraz z IronPDF do generowania plików PDF w Node.js

Node fetch to popularna biblioteka w ekosystemie Node.js służąca do wysyłania żądań HTTP typu fetch. W połączeniu z IronPDF, potężną biblioteką do generowania plików PDF, staje się wszechstronnym narzędziem do tworzenia plików PDF z różnych zasobów internetowych.

Czym jest IronPDF?

IronPDF to solidna biblioteka, która pozwala programistom tworzyć, edytować i wyodrębniać treści z plików PDF w prosty i wydajny sposób. Dostępny dla C#, Python, Java i Node.js, IronPDF ułatwia obsługę plików PDF dzięki intuicyjnemu API.

Node.js Fetch (jak to działa dla programistów): Rysunek 5 – IronPDF for Node.js: biblioteka PDF dla Node.js

Instalacja biblioteki IronPDF

Najpierw musisz zainstalować IronPDF w swoim projekcie. Aby zainstalować bibliotekę, użyj następującego polecenia npm:

 npm i @ironsoftware/ironpdf

Zobaczmy, jak używać funkcji fetch w Node.js z IronPDF do generowania plików PDF z treści internetowych.

Połączenie funkcji fetch w Node.js i IronPDF

Możesz wykorzystać możliwości zarówno funkcji fetch w Node.js, jak i biblioteki IronPDF do dynamicznego pobierania treści internetowych i generowania plików PDF. Na przykład można pobrać dane z punktu końcowego API, wygenerować dynamiczny kod HTML i przekonwertować go do formatu PDF. Poniższy przykład pokazuje, jak można zrealizować to zadanie:

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

Wynik w formacie PDF

Odpowiedź JSON jest elegancko mapowana na tabelę HTML, a IronPDF konwertuje ją z zachowaniem wszystkich stylów.

Node.js Fetch (jak to działa dla programistów): Rysunek 6 – Ciąg znaków HTML poprawnie przekonwertowany do formatu PDF przy użyciu IronPDF.

Więcej szczegółów na temat IronPDF i jego funkcji można znaleźć na tej stronie dokumentacji.

Wnioski

Node fetch to potężne, a jednocześnie proste narzędzie do wysyłania żądań HTTP w Node.js. Znane API, podejście oparte na obietnicach oraz lekkość sprawiają, że jest to doskonały wybór zarówno dla początkujących, jak i doświadczonych programistów. Niezależnie od tego, czy wykonujesz podstawowe żądania GET, czy obsługujesz złożone żądania POST z niestandardowymi nagłówkami, Node fetch zapewnia przejrzysty i wydajny sposób interakcji z interfejsami API sieci Web.

Połączenie Node fetch z IronPDF zapewnia potężny i elastyczny sposób generowania plików PDF z różnych źródeł treści internetowych w Node.js. Dzięki integracji tych dwóch bibliotek można tworzyć solidne aplikacje, które wykorzystują dane internetowe i z łatwością generują profesjonalne pliki PDF.

IronPDF od $799. Wypróbuj jego potężne funkcje generowania plików PDF bez ryzyka. Wypróbuj już dziś i przekonaj się sam o różnicy!

Darrius Serrant

Czat z zespołem inżynierów teraz

Full Stack Software Engineer (WebOps)

Darrius Serrant posiada tytuł licencjata z informatyki z Uniwersytetu Miami i pracuje jako Full Stack WebOps Marketing Engineer w Iron Software. Już od młodych lat zainteresował się kodowaniem, postrzegając informatykę jako zarówno tajemniczą, jak i dostępną, co czyni ją doskonałym medium dla kreatywności ...

Czytaj więcej