Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF for Node.js
  2. Blog do IronPDF for Node.js
  3. Ajuda do Node
  4. Busca em Node.js
AJUDA DO NODE

Node.js Fetch (Como funciona para desenvolvedores)

Darrius Serrant
Darrius Serrant
Atualizado:

O Node Fetch é um módulo leve e popular no ecossistema Node.js , projetado para tornar as requisições HTTP simples e intuitivas. Ele oferece uma maneira leve e familiar de interagir com APIs da web, inspirada na API Fetch disponível no ambiente do navegador. O Node-fetch oferece suporte à API Fetch no Node.js, permitindo que os service workers manipulem cabeçalhos HTTP e realizem solicitações HTTPS de forma eficiente.

Este artigo ajudará você a explorar os principais recursos e usos do Node-fetch , oferecendo um guia completo para desenvolvedores que desejam otimizar o tratamento de requisições HTTP em Node.js Também utilizaremos o IronPDF , uma biblioteca PDF for Node.js que permite aos programadores criar e editar PDFs, converter conteúdo HTML em PDF e muito mais.

O que é o fetch do Node.js ?

Node fetch é um módulo que traz a API Fetch para o Node.js A API Fetch é uma interface moderna para fazer requisições HTTP, comumente usada em navegadores web. O fetch do Node.js replica essa funcionalidade, permitindo que aplicativos Node.js realizem requisições HTTP com a mesma facilidade e simplicidade. Isso a torna uma excelente opção para desenvolvedores que já estão familiarizados com a API Fetch ou para aqueles que buscam uma maneira simples de lidar com solicitações HTTP em seus aplicativos Node.js

Node.js Fetch (Como funciona para desenvolvedores): Figura 1 - Node.js Fetch

Principais funcionalidades do Fetch em Node.js

1. Simplicidade e Familiaridade

O fetch do Node.js imita a API Fetch encontrada nos navegadores, fornecendo uma interface simples e familiar para os desenvolvedores.

2. Baseado em promessas

Assim como a API Fetch, o fetch do Node.js é baseado em promessas, permitindo que os desenvolvedores escrevam código assíncrono de uma maneira mais legível e gerenciável.

3. Leve

A biblioteca fetch do Node.js é minimalista, o que a torna rápida e eficiente. Não acarreta a sobrecarga de bibliotecas HTTP maiores, mantendo sua aplicação enxuta.

4. Compatibilidade

O fetch do Node.js suporta uma ampla gama de métodos HTTP, cabeçalhos e tipos de resposta, tornando-o altamente versátil.

5. Streaming

Ele suporta respostas em fluxo contínuo, o que é útil para lidar com grandes volumes de dados de forma eficiente.

Instalando o Fetch do Node.js

Para começar a usar o Node-fetch , você precisa instalá-lo via npm (Node Package Manager). Execute o seguinte comando no diretório do seu projeto:

npm install node-fetch
npm install node-fetch
SHELL

Uso básico

Aqui está um exemplo básico de como usar o fetch do Node.js para fazer uma requisição 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

Este trecho de código demonstra uma solicitação GET simples para obter dados JSON de uma API. A função fetch retorna uma promessa que se resolve com o objeto de resposta. Em seguida, você pode chamar métodos que retornam respostas, como json(), para analisar o corpo da resposta.

Saída do console

Fetch do Node.js (Como funciona para desenvolvedores): Figura 2 - Saída do console para uma solicitação GET simples para buscar dados JSON de uma URL de API https://jsonplaceholder.typicode.com/posts usando o fetch do Node.js .

Uso avançado

O fetch do Node.js também oferece suporte a recursos mais avançados, como fazer solicitações POST, definir cabeçalhos de solicitação personalizados e lidar com diferentes tipos de resposta.

Como fazer uma solicitação 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

Este exemplo mostra como enviar uma solicitação POST com uma carga útil JSON. A opção headers é usada para especificar o tipo de conteúdo da resposta, e a opção body contém os dados JSON serializados.

Saída do console

Fetch do Node.js (Como funciona para desenvolvedores): Figura 3 - Saída do console para um objeto de solicitação POST enviado para a URL https://jsonplaceholder.typicode.com/posts usando fetch do Node.js

Lidando com respostas de 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

Neste exemplo, o corpo da resposta é enviado ao servidor como um fluxo de arquivo, demonstrando como lidar com respostas grandes de forma eficiente.

SAÍDA

Node.js Fetch (Como funciona para desenvolvedores): Figura 4 - Arquivo de saída: large-data.json

Tratamento de erros

O tratamento adequado de erros é crucial ao trabalhar com requisições HTTP. O fetch do Node.js oferece uma maneira simples de capturar e lidar com erros usando promises.

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

Neste caso, um erro é lançado se o status da resposta não estiver no intervalo de 200 a 299, e o bloco catch trata quaisquer erros que ocorram durante a requisição. Caso contrário, a resposta JSON válida é retornada.

Utilizando o método fetch do Node.js com o IronPDF para gerar PDFs em Node.js

Node fetch é uma biblioteca popular no ecossistema Node.js para fazer requisições HTTP fetch. Quando combinado com o IronPDF , uma poderosa biblioteca de geração de PDFs, ele se torna uma ferramenta versátil para criar PDFs a partir de diversos recursos da web.

O que é o IronPDF?

IronPDF é uma biblioteca robusta que permite aos desenvolvedores criar, editar e extrair conteúdo de PDFs de maneira simples e eficiente. Disponível para C#, Python, Java e Node.js, o IronPDF simplifica a manipulação de PDFs com sua API intuitiva.

Node.js Fetch (Como funciona para desenvolvedores): Figura 5 - IronPDF for Node.js: A biblioteca PDF for Node.js

Instalando a biblioteca IronPDF

Primeiro, você precisa instalar o IronPDF em seu projeto. Utilize o seguinte comando npm para instalar a biblioteca:

 npm e @ironsoftware/ironpdf

Vamos explorar como usar o fetch do Node.js com o IronPDF para gerar PDFs a partir de fontes de conteúdo da web.

Combinando o fetch do Node.js com o IronPDF

Você pode aproveitar o poder do fetch do Node.js e do IronPDF para buscar conteúdo da web dinamicamente e gerar PDFs. Por exemplo, você pode buscar os dados de um endpoint de API, gerar HTML dinâmico e convertê-lo em um PDF . O exemplo a seguir demonstra como você pode realizar essa tarefa:

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 de saída

A resposta em JSON é elegantemente mapeada para a tabela HTML e o IronPDF a converte com precisão, preservando toda a sua formatação.

Node.js Fetch (Como funciona para desenvolvedores): Figura 6 - String HTML convertida para PDF usando IronPDF com precisão.

Para obter mais detalhes sobre o IronPDF e suas funcionalidades, consulte esta página de documentação .

Conclusão

Node fetch é uma ferramenta poderosa e simples para fazer requisições HTTP em Node.js Sua API familiar, abordagem baseada em promessas e natureza leve a tornam uma excelente escolha tanto para iniciantes quanto para desenvolvedores experientes. Quer você esteja realizando solicitações GET básicas ou lidando com solicitações POST complexas com cabeçalhos personalizados, o Node fetch oferece uma maneira simples e eficiente de interagir com APIs da web.

A combinação do Node fetch com o IronPDF oferece uma maneira poderosa e flexível de gerar PDFs a partir de diversas fontes de conteúdo da web em Node.js Ao integrar essas duas bibliotecas, você pode criar aplicativos robustos que aproveitam dados da web e geram PDFs profissionais com facilidade.

IronPDF começando em $799. Experimente seus poderosos recursos de geração de PDF sem riscos. Experimente hoje mesmo e veja a diferença por si próprio!

Darrius Serrant
Darrius Serrant
  Converse agora mesmo com a equipe de engenharia.
Engenheiro de Software Full Stack (WebOps)

Darrius Serrant é bacharel em Ciência da Computação pela Universidade de Miami e trabalha como Engenheiro de Marketing WebOps Full Stack na Iron Software. Atraído por programação desde jovem, ele via a computação como algo misterioso e acessível ao mesmo tempo, tornando-a o meio ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim