Node.js Fetch (Cómo funciona para desarrolladores)

Node Fetch es un módulo ligero popular en el ecosistema de Node.js, diseñado para hacer que las solicitudes HTTP sean simples e intuitivas. Proporciona una forma ligera y familiar de interactuar con las APIs web, inspirado en la Fetch API disponible en el entorno del navegador. Node-fetch proporciona soporte para la API Fetch en Node.js, permitiendo que los service workers manejen encabezados HTTP y realicen solicitudes HTTPS de manera eficiente.

Este artículo le ayudará a explorar las características clave y el uso de Node-fetch, ofreciendo una guía integral para los desarrolladores que buscan optimizar el manejo de solicitudes HTTP en Node.js. También utilizaremos IronPDF, una biblioteca PDF para Node.js que permite a los programadores crear y editar PDFs, convertir contenido HTML a PDF y mucho más.

¿Qué es Node.js fetch?

Node fetch es un módulo que lleva la API Fetch a Node.js. La API Fetch es una interfaz moderna para realizar solicitudes HTTP, comúnmente utilizada en navegadores web. Node.js fetch replica esta funcionalidad, permitiendo que las aplicaciones de Node.js realicen solicitudes HTTP con la misma facilidad y simplicidad. Esto lo convierte en una excelente opción para los desarrolladores que ya están familiarizados con la API Fetch o aquellos que buscan una manera sencilla de manejar solicitudes HTTP en sus aplicaciones de Node.js.

Características clave de Node.js Fetch

1. Simplicidad y Familiaridad

Node.js fetch imita la API Fetch que se encuentra en los navegadores, proporcionando una interfaz simple y familiar para los desarrolladores.

2. Basado en promesas

Al igual que la API Fetch, Node.js fetch está basado en promesas, lo que permite a los desarrolladores escribir código asincrónico de una manera más legible y manejable.

3. Ligero

La función fetch de Node.js es una biblioteca minimalista, lo que la hace rápida y eficiente. No viene con la sobrecarga de bibliotecas HTTP más grandes, manteniendo su aplicación ligera.

4. Compatibilidad

Node.js fetch admite una amplia gama de métodos HTTP, encabezados y tipos de respuesta, lo que lo hace altamente versátil.

5. Transmisión

Admite respuestas en streaming, lo cual es útil para manejar grandes cargas con eficiencia.

Instalando Node.js Fetch

Para comenzar con Node-fetch, necesitas instalarlo a través de npm (Node Package Manager). Ejecute el siguiente comando en el directorio de su proyecto:

npm install node-fetch

Uso básico

A continuación, se muestra un ejemplo básico de cómo usar Node.js fetch para realizar una solicitud GET:

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

Este fragmento de código demuestra una solicitud GET simple para obtener datos JSON de una API. La función fetch devuelve una promesa que se resuelve en el objeto de respuesta. A continuación, puedes llamar a métodos que devuelven respuestas, como json() para analizar el cuerpo de la respuesta.

Salida de la consola

Uso avanzado

La función fetch de Node.js también admite características más avanzadas, por ejemplo, como realizar solicitudes POST, configurar un objeto de cabeceras personalizadas para la solicitud y manejar diferentes tipos de respuesta.

Realizar una solicitud POST

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

Este ejemplo muestra cómo enviar un objeto de solicitud POST con una carga útil JSON. La opción headers se utiliza para especificar el tipo de contenido de la nueva respuesta, y la opción body contiene los datos JSON serializados.

Salida de la consola

Manejo de Respuestas en Streaming

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

En este ejemplo, el cuerpo de la respuesta se canaliza al servidor como un flujo de archivo, demostrando cómo manejar respuestas grandes de manera eficiente.

SALIDA

Tratamiento de errores

El manejo adecuado de errores es crucial al trabajar con solicitudes HTTP. La respuesta de error de fetch de Node.js proporciona una manera sencilla de capturar y manejar errores utilizando promesas.

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

Aquí, se lanza un error si el estado de los encabezados de la respuesta no está en el rango de 200-299, y el bloque catch maneja cualquier error que ocurra durante la solicitud; de lo contrario, se devuelve la respuesta JSON válida.

Usar Node.js fetch con IronPDF para generar PDFs en Node.js

Node fetch es una biblioteca popular en el ecosistema de Node.js para realizar solicitudes HTTP fetch. Cuando se combina con IronPDF, una potente biblioteca de generación de PDF, se convierte en una herramienta versátil para crear PDFs a partir de varios recursos web.

¿Qué es IronPDF?

IronPDF es una biblioteca robusta que permite a los desarrolladores crear, editar y extraer contenido de PDFs de una manera sencilla y eficiente. Disponible para C#, Python, Java y Node.js, IronPDF simplifica la manipulación de PDF con su API intuitiva.

Instalación de la biblioteca IronPDF

Primero, necesitas instalar IronPDF en tu proyecto. Utiliza los siguientes comandos npm para instalar estas bibliotecas:

npm i @ironsoftware/ironpdf

Vamos a explorar cómo usar fetch de Node.js con IronPDF para generar PDFs a partir de fuentes de contenido web.

Combinando Node.js fetch e IronPDF

Puedes aprovechar el poder tanto de Node.js fetch como de IronPDF para obtener contenido web de manera dinámica y generar PDFs. Por ejemplo, puede obtener los datos de un endpoint de API, generar HTML dinámico y convertirlo en un PDF. El siguiente ejemplo demuestra cómo puedes lograr esta tarea:

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

Salida PDF

La salida de respuesta JSON se mapea elegantemente a la tabla HTML y IronPDF la convierte con todo su estilo de manera precisa.

Para obtener más detalles sobre IronPDF y sus funcionalidades, por favor consulte esta página de documentación.

Conclusión

Node fetch es una herramienta poderosa pero simple para realizar solicitudes HTTP en Node.js. Su API familiar, enfoque basado en promesas y naturaleza ligera lo convierten en una excelente opción tanto para principiantes como para desarrolladores experimentados. Ya sea que estés realizando solicitudes GET básicas o manejando solicitudes POST complejas con cabeceras personalizadas, Node fetch ofrece una forma limpia y eficiente de interactuar con las API web.

Combinar Node fetch con IronPDF ofrece una forma potente y flexible de generar PDFs a partir de diversas fuentes de contenido web en Node.js. Al integrar estas dos bibliotecas, puedes crear aplicaciones robustas que aprovechen los datos web y generen PDFs profesionales con facilidad.

IronPDF a partir de $749. Experimente sus potentes funciones de generación de PDF sin riesgos. ¡Pruébalo hoy y comprueba la diferencia por ti mismo!