AYUDA PARA NODOS

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

Publicado en 29 de septiembre, 2024

Node Fetches un módulo ligero popular en el ecosistema de Node.js, diseñado para simplificar y hacer intuitivas las solicitudes HTTP. Ofrece una manera ligera y familiar de interactuar con las APIs web, inspirado en la API Fetch disponible en el entorno del navegador. Node-fetch proporciona soporte para la API Fetch en Node.js, permitiendo a los service workers manejar encabezados HTTP y realizar solicitudes HTTPS de manera eficiente.

Este artículo te ayudará a explorar las características clave y el uso de Node-fetch, ofreciendo una guía completa para los desarrolladores que buscan optimizar el manejo de sus solicitudes HTTP en Node.js. También utilizaremosIronPDF, 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 fetches 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.

Node.js Fetch(Cómo funciona para desarrolladores): Figura 1 - Node.js Fetch

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 empezar conNode-fetch, necesitas instalarlo a través de npm(Gestor de paquetes Node). Ejecute el siguiente comando en el directorio de su proyecto:

npm install node-fetch

npm install node-fetch

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

VB C#

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

'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#

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

Node.js Fetch(Cómo Funciona Para Desarrolladores): Figura 2 - Salida de consola para una solicitud GET simple para obtener datos JSON de una URL API "https://jsonplaceholder.typicode.com/posts" usando Node.js fetch.

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

'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#

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

Node.js Fetch(Cómo Funciona Para Desarrolladores): Figura 3 - Salida de consola para un objeto de solicitud POST enviado a la URL https://jsonplaceholder.typicode.com/posts utilizando Node.js fetch

Manejo de Respuestas de Transmisión

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#

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

Node.js Fetch(Cómo Funciona para Desarrolladores): Figura 4 - Archivo de salida: large-data.json

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

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#

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 fetches una biblioteca popular en el ecosistema de Node.js para realizar solicitudes de búsqueda HTTP. Cuando se combina con IronPDF, una poderosa biblioteca de generación de PDF, se convierte en una herramienta versátil para crear PDFs a partir de diversos recursos web.

¿Qué es IronPDF?

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

Node.js Fetch(Cómo Funciona Para Desarrolladores): Figura 5 - IronPDF for Node.js: La Biblioteca PDF de Node.js

Instalación de la biblioteca IronPDF

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

npm i @ironsoftware/ironpdf

npm i @ironsoftware/ironpdf

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

VB C#

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, podrías obtener los datos de un endpoint de API, generar HTML dinámico yconvertirlo en 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!");
})();

'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#

Salida PDF

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

Node.js Fetch(Cómo Funciona Para Desarrolladores): Figura 6 - Cadena HTML convertida a PDF utilizando IronPDF con precisión.

Para más detalles sobreIronPDFy sus funcionalidades, por favor consulte estepágina de documentación.

Conclusión

Node fetches una herramienta poderosa pero sencilla 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é realizando solicitudes GET básicas o manejando solicitudes POST complejas con encabezados personalizados, Node fetch ofrece una forma limpia y eficiente de interactuar con las APIs web.

Combinación deNode fetch conIronPDFproporciona una forma poderosa y flexible de generar PDF 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.

IronPDFdesde $749. Experimente sus potentes funciones de generación de PDF sin riesgo. Pruébalo hoy y comprueba la diferencia por ti mismo.!

< ANTERIOR
Ramda JS NPM (Cómo funciona para desarrolladores)

SIGUIENTE >
Multer Node.js (Cómo Funciona para Desarrolladores)