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

Introducción

Gestionar la carga de archivos y producir documentos PDF son requisitos estándar para muchas aplicaciones en el actual panorama de desarrollo en línea. Resumiendo las capacidades de IronPDF yMulteren un entorno de Node.js ofrece una solución sólida para manejar de manera efectiva estos requisitos.

Multeres un middleware de Node.js que facilita el manejo de multipart/form-data—que se utiliza principalmente para la carga de archivos. Debido a su gran flexibilidad, los desarrolladores pueden especificar restricciones de tamaño de archivo, opciones de almacenamiento y filtrado de archivos para garantizar cargas de archivos seguras y efectivas. Multer es una opción principal para los desarrolladores que desean integrar fácilmente la funcionalidad de carga de archivos en sus aplicaciones, debido a lo sencillo que es integrarlo con Express.js.

A la inversa,IronPDFes una potente biblioteca de creación de PDF que permite a los programadores crear documentos PDF usando texto HTML. Con sus numerosas capacidades, incluyendo soporte para ejecución de JavaScript, estilado CSS y la inserción de fuentes e imágenes, es la herramienta perfecta para convertir información web dinámica en PDFs de aspecto profesional.

Demostraremos la cooperación fluida entre estas dos herramientas potentes al explicar cómo configurar y utilizar IronPDF para crear documentos PDF y Multer para gestionar la carga de archivos en una aplicación de Node.js.

¿Qué es Multer en Node.js?

Multeres un middleware de Node.js que facilita el manejo de multipart/form-data, utilizado principalmente para la carga de archivos. Ofrece un método fiable para gestionar las capacidades de carga de archivos en aplicaciones web e interactúa con Express.js con facilidad. Para asegurarse de que solo se carguen tipos de archivos autorizados, Multer otorga a los desarrolladores la capacidad de especificar restricciones de tamaño de archivo, configurar opciones de almacenamiento y aplicar filtros de archivos.

Proporciona al servidor flexibilidad en la gestión de archivos al admitir tanto el almacenamiento en disco como en memoria. Multer es perfecto para formularios que necesitan que se envíen numerosos archivos a la vez porque puede gestionar varios archivos cargados simultáneamente. Considerando todo, Multer simplifica el proceso de carga de archivos, mejorando la capacidad de las aplicaciones de Node.js para manejar de manera segura y efectiva el material subido por el usuario.

Características de Multer para Node.js

Opciones de Almacenamiento de Archivos

• Multer tiene la capacidad de almacenar archivos subidos directamente en el disco. El motor de almacenamiento en disco te permite proporcionar el nombre del archivo y el directorio de destino. Esto es especialmente útil para programas que requieren que los archivos se guarden para uso futuro.
• Almacenamiento de memoria: Multer tiene la capacidad de almacenar archivos en la memoria como objetos de buffer para uso momentáneo. Esto es útil en situaciones donde los archivos no necesitan mantenerse en el disco y se pueden procesar de inmediato.

Límites de tamaño de los archivos

Las limitaciones de tamaño que permite establecer Multer para los archivos subidos pueden ayudar a proteger el rendimiento del servidor y gestionar de manera eficiente los recursos de almacenamiento al evitar la carga de archivos demasiado grandes. Puede utilizar la opción de limitaciones para lograr esto.

Filtrado de archivos

Multer tiene una opción llamada fileFilter que te permite gestionar qué archivos se aceptan. Los archivos que no cumplan con los requisitos pueden ser rechazados por esta función, la cual también puede verificar el tipo MIME del archivo y otros atributos. Esto garantiza que solo se envíen tipos específicos de archivos, como documentos e imágenes.

Manejo de múltiples archivos

Multer puede gestionar varios archivos cargados simultáneamente. Las rutas se pueden configurar para aceptar múltiples campos que contengan archivos o arreglos de archivos. Esto es útil para formularios cuando los usuarios deben cargar varios archivos a la vez, como documentos de respaldo e imágenes de perfil.

Motores de almacenamiento personalizables

Multer te permite diseñar nuevos motores de almacenamiento además de las soluciones de almacenamiento en disco y memoria integradas. Para obtener la máxima flexibilidad, puede crear su propia lógica para gestionar las subidas de archivos, incluyendo dónde y cómo se guardan los archivos.

Fácil integración con Express

Multer está diseñado para integrarse fácilmente con Express.js. Es sencillo añadir la capacidad de carga de archivos a tus aplicaciones web usándolo como middleware en tus rutas de Express.

Manejo Automático de Datos Multipartes

Al analizar automáticamente multipart/form-data, Multer simplifica el proceso de manejo de cargas de archivos en el código del lado del servidor al hacer que los archivos cargados y los datos del formulario estén disponibles en el objeto req.

Carga de archivos individual y múltiple

Multer ofrece varias maneras (individual, matriz y campos)para gestionar cargas de uno o más archivos. El método único maneja un archivo por solicitud, el método de matriz admite varios archivos con el mismo nombre de campo, y el método de campos puede manejar numerosos archivos con diferentes nombres de campo.

Crear y configurar Multer en Node.js JS

Los pasos a continuación se pueden utilizar para construir y configurar Multer en una aplicación de Node.js:

Instalar dependencias

El primer paso es instalar Multer y Express. Se puede usar npm para esto:

npm install multer
npm install express

npm install multer
npm install express

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'npm install multer npm install express

Configurar Multer

Configura Multer para manejar cargas de archivos en tu archivo .js. Aquí tienes una ilustración detallada:

const express = require('express');
const multer = require('multer');
const path = require('path');
const fs = require('fs');
// Initialize Express
const app = express();
// Set up storage configuration for Multer
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, 'uploads/'); // Directory to save uploaded files
  },
  filename: (req, file, cb) => {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, file.fieldname + '-' + uniqueSuffix + path.extname(file.originalname)); // Unique filename
  }
});
// Configure file filter function to allow only certain file types
const fileFilter = (req, file, cb) => {
  const allowedFileTypes = /jpeg
jpg
png
gif/;
  const mimetype = allowedFileTypes.test(file.mimetype);
  const extname = allowedFileTypes.test(path.extname(file.originalname).toLowerCase());
  if (mimetype && extname) {
    return cb(null, true);
  } else {
    cb(new Error('Only images are allowed!'));
  }
};
// Initialize Multer with storage, file size limit, and file filter options
const upload = multer({
  storage: storage,
  limits: { fileSize: 1024 * 1024 * 5 }, // 5 MB file size limit
  fileFilter: fileFilter
});
// Single file upload route
app.post('/upload-single', upload.single('profilePic'), (req, res) => {
  try {
    res.send('Single file uploaded successfully');
  } catch (err) {
    res.status(400).send({ error: err.message });
  }
});
// Multiple files upload route
app.post('/upload-multiple', upload.array('photos', 5), (req, res) => {
  try {
    res.send('Multiple files uploaded successfully');
  } catch (err) {
    res.status(400).send({ error: err.message });
  }
});
// Error handling middleware
app.use((err, req, res, next) => {
  if (err) {
    res.status(400).send({ error: err.message });
  }
});
// Start the server
const PORT = process.env.PORT 
 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

const express = require('express');
const multer = require('multer');
const path = require('path');
const fs = require('fs');
// Initialize Express
const app = express();
// Set up storage configuration for Multer
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, 'uploads/'); // Directory to save uploaded files
  },
  filename: (req, file, cb) => {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, file.fieldname + '-' + uniqueSuffix + path.extname(file.originalname)); // Unique filename
  }
});
// Configure file filter function to allow only certain file types
const fileFilter = (req, file, cb) => {
  const allowedFileTypes = /jpeg
jpg
png
gif/;
  const mimetype = allowedFileTypes.test(file.mimetype);
  const extname = allowedFileTypes.test(path.extname(file.originalname).toLowerCase());
  if (mimetype && extname) {
    return cb(null, true);
  } else {
    cb(new Error('Only images are allowed!'));
  }
};
// Initialize Multer with storage, file size limit, and file filter options
const upload = multer({
  storage: storage,
  limits: { fileSize: 1024 * 1024 * 5 }, // 5 MB file size limit
  fileFilter: fileFilter
});
// Single file upload route
app.post('/upload-single', upload.single('profilePic'), (req, res) => {
  try {
    res.send('Single file uploaded successfully');
  } catch (err) {
    res.status(400).send({ error: err.message });
  }
});
// Multiple files upload route
app.post('/upload-multiple', upload.array('photos', 5), (req, res) => {
  try {
    res.send('Multiple files uploaded successfully');
  } catch (err) {
    res.status(400).send({ error: err.message });
  }
});
// Error handling middleware
app.use((err, req, res, next) => {
  if (err) {
    res.status(400).send({ error: err.message });
  }
});
// Start the server
const PORT = process.env.PORT 
 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

Private const express = require( 'express');
Private const multer = require( 'multer');
Private const path = require( 'path');
Private const fs = require( 'fs');
' Initialize Express
Private const app = express()
' Set up storage configuration for Multer
Private const storage = multer.diskStorage({ destination:= (req, file, cb) =>
	cb(Nothing, 'uploads/');
'INSTANT VB TODO TASK: Lambda expressions and anonymous methods are not converted by Instant VB if local variables of the outer method are referenced within the anonymous method:
, filename: (req, file, cb) =>
' Configure file filter function to allow only certain file types
'INSTANT VB TODO TASK: Lambda expressions and anonymous methods are not converted by Instant VB if local variables of the outer method are referenced within the anonymous method:
const fileFilter = (req, file, cb) =>
If True Then
'INSTANT VB WARNING: Instant VB cannot determine whether both operands of this division are integer types - if they are then you should use the VB integer division operator:
  const allowedFileTypes = /jpeg jpg png gif/
  const mimetype = allowedFileTypes.test(file.mimetype)
  const extname = allowedFileTypes.test(path.extname(file.originalname).toLowerCase())
  If mimetype AndAlso extname Then
	Return cb(Nothing, True)
  Else
	cb(New [Error]( 'Only images are allowed!'));
  End If
End If
' Initialize Multer with storage, file size limit, and file filter options
const upload = multer({
	storage:= storage,
	limits:= { fileSize:= 1024 * 1024 * 5 },
	fileFilter:= fileFilter
})
' Single file upload route
app.post( '/upload-@single', upload.@single('profilePic'), (req, res) =>
If True Then
	Try
		res.send( 'Single file uploaded successfully');
	Catch e1 As err
		res.status(400).send({ [error]:= err.message })
	End Try
End If
)
' Multiple files upload route
app.post( '/upload-multiple', upload.array('photos', 5), (req, res) =>
If True Then
	Try
		res.send( 'Multiple files uploaded successfully');
	Catch e2 As err
		res.status(400).send({ [error]:= err.message })
	End Try
End If
)
' Error handling middleware
'INSTANT VB TODO TASK: Lambda expressions and anonymous methods are not converted by Instant VB if local variables of the outer method are referenced within the anonymous method:
app.use((err, req, res, [next]) =>
' Start the server
const PORT = process.env.PORT 3000
'INSTANT VB TODO TASK: Lambda expressions and anonymous methods are not converted by Instant VB if local variables of the outer method are referenced within the anonymous method:
app.listen(PORT, () =>

Configurar el sistema de almacenamiento

destination: Indica la carpeta en la que se almacenarán los archivos cargados.

nombre de archivo: Mantiene la extensión de archivo original mientras crea un nombre de archivo único para cada archivo subido basado en la marca de tiempo y un número aleatorio.

Filtro de archivos: una opción para verificar el tipo de archivo de los archivos que se suben. Solo se permiten archivos de imagen con las extensiones jpeg, jpg, png o gif en este ejemplo.

Inicializar Multer:

• almacenamiento: Describe la configuración del almacenamiento.
• límites: Define el tamaño máximo de archivo que se permite(5 MB en este ejemplo).
• fileFilter: Utiliza la función de un filtro de archivos.

Primeros pasos con IronPDF

EnIronPDFse utiliza para crear documentos PDF yMulterse utiliza para manejar las cargas de archivos, se crea una solución poderosa para gestionar contenido generado por el usuario y convertirlo en PDFs pulidos. A continuación se encuentra una explicación de cómo instalar y combinar estas dos bibliotecas en una aplicación de Node.js.

¿Qué es IronPDF?

IronPDFes un conjunto de bibliotecas de aplicaciones diseñadas para facilitar la creación, edición y gestión de archivos PDF. Con esta aplicación, los desarrolladores pueden extraer texto e imágenes de documentos HTML, añadir encabezados y marcas de agua, fusionar numerosas páginas PDF y realizar una variedad de otras actividades. La documentación exhaustiva de IronPDF y su API fácil de usar hacen que sea sencillo para los desarrolladores generar automáticamente documentos PDF de alta calidad. IronPDF incluye todas las características y funcionalidades necesarias para mejorar los flujos de trabajo de documentos y ofrecer experiencias de usuario de primera clase en una variedad de escenarios, como la creación de documentación, informes y facturas.

Características de IronPDF

Un método rápido y sencillo para manejar cualquier tipo de texto HTML, incluyendo CSS y JavaScript, es convertirlo a PDF.

Fusión de archivos PDF: Para facilitar las tareas de gestión de documentos,combinar múltiples PDFdocumentos en un solo archivo PDF.

Extracción de texto e imágenes: Extraer el texto y las imágenes de archivos PDF para utilizarlos en procesamiento o análisis de datos adicionales.

Marcado de agua: Por razones de seguridad o de marca, puedes añadir marcas de agua de texto o imágenes a las páginas PDF.

Incluir Encabezado y Pie de Página: Elencabezados y pies de páginade los documentos PDF le permiten incluir un mensaje personalizado o números de página.

Instalar IronPDF

Utilice el administrador de paquetes de Node para instalar los paquetes necesarios de Node.js con el fin de habilitar la funcionalidad de IronPDF.

npm install @ironsoftware/ironpdf

npm install @ironsoftware/ironpdf

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

Integrar Multer Node.js con IronPDF

Modifica app.js para configurar IronPDF para crear PDFs y Multer para gestionar la subida de archivos.

const express = require('express');
const multer = require('multer');
const path = require('path');
const IronPdf = require("@ironsoftware/ironpdf");
const document=IronPdf.PdfDocument;
var config=IronPdf.IronPdfGlobalConfig
// Initialize Express
const app = express();
// Set up Multer storage configuration
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, 'uploads/'); // Directory to save uploaded files
  },
  filename: (req, file, cb) => {
    cb(null, `${Date.now()}-${file.originalname}`); // Unique filename
  }
});
const upload = multer({ storage: storage });
// Single file upload route
app.post('/upload-single', upload.single('file'), async (req, res) => {
  try {
    // Read the uploaded file
    const filePath = path.join(__dirname, 'uploads', req.file.filename);
      // Create HTML content for PDF
      const htmlContent = `
        <html>
          <head>
            <title>Uploaded File Content</title>
          </head>
          <body>
            <h1>Uploaded File Content</h1>
            <img src="${filePath}" alt="image" width="500" height="600">
          </body>
        </html>
      `;
    // Initialize IronPDF
    const pdf = await document.fromHtml(htmlContent);
    // Save PDF to file
    const pdfPath = path.join(__dirname, 'uploads', `${Date.now()}-output.pdf`);
    await pdf.saveAs(pdfPath);
    // Respond to the client
    res.send(`File uploaded and PDF generated successfully! <a href="/download-pdf?path=${pdfPath}">Download PDF</a>`);
  } catch (err) {
    res.status(500).send({ error: err.message });
  }
});
// Route to download generated PDF
  app.get('/download-pdf', (req, res) => {
    const filename = req.query.filename;
    const pdfPath = path.join(__dirname, 'uploads', filename);
    res.download(pdfPath);
  });
// Start the server
const PORT = process.env.PORT 
 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

const express = require('express');
const multer = require('multer');
const path = require('path');
const IronPdf = require("@ironsoftware/ironpdf");
const document=IronPdf.PdfDocument;
var config=IronPdf.IronPdfGlobalConfig
// Initialize Express
const app = express();
// Set up Multer storage configuration
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, 'uploads/'); // Directory to save uploaded files
  },
  filename: (req, file, cb) => {
    cb(null, `${Date.now()}-${file.originalname}`); // Unique filename
  }
});
const upload = multer({ storage: storage });
// Single file upload route
app.post('/upload-single', upload.single('file'), async (req, res) => {
  try {
    // Read the uploaded file
    const filePath = path.join(__dirname, 'uploads', req.file.filename);
      // Create HTML content for PDF
      const htmlContent = `
        <html>
          <head>
            <title>Uploaded File Content</title>
          </head>
          <body>
            <h1>Uploaded File Content</h1>
            <img src="${filePath}" alt="image" width="500" height="600">
          </body>
        </html>
      `;
    // Initialize IronPDF
    const pdf = await document.fromHtml(htmlContent);
    // Save PDF to file
    const pdfPath = path.join(__dirname, 'uploads', `${Date.now()}-output.pdf`);
    await pdf.saveAs(pdfPath);
    // Respond to the client
    res.send(`File uploaded and PDF generated successfully! <a href="/download-pdf?path=${pdfPath}">Download PDF</a>`);
  } catch (err) {
    res.status(500).send({ error: err.message });
  }
});
// Route to download generated PDF
  app.get('/download-pdf', (req, res) => {
    const filename = req.query.filename;
    const pdfPath = path.join(__dirname, 'uploads', filename);
    res.download(pdfPath);
  });
// Start the server
const PORT = process.env.PORT 
 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

const express = require( 'express');
const multer = require( 'multer');
const path = require( 'path');
const IronPdf = require("@ironsoftware/ironpdf")
const document=IronPdf.PdfDocument
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: var config=IronPdf.IronPdfGlobalConfig const app = express();
IronPdf.IronPdfGlobalConfig Const app = express()
Dim config As Dim=IronPdf.IronPdfGlobalConfig Const app
' Set up Multer storage configuration
'INSTANT VB TODO TASK: Lambda expressions and anonymous methods are not converted by Instant VB if local variables of the outer method are referenced within the anonymous method:
const storage = multer.diskStorage({ destination:= (req, file, cb) =>
If True Then
	cb(Nothing, 'uploads/');
End If
'INSTANT VB TODO TASK: Lambda expressions and anonymous methods are not converted by Instant VB if local variables of the outer method are referenced within the anonymous method:
, filename: (req, file, cb) =>
const upload = multer({ storage:= storage })
' Single file upload route
app.post( '/upload-@single', upload.@single('file'), async(req, res) =>
If True Then
	Try
		const filePath = path.join(__dirname, 'uploads', req.file.filename);
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: const htmlContent = ` <html> <head> <title> Uploaded File Content</title> </head> <body> <h1> Uploaded File Content</h1> <img src="${filePath}" alt="image" width="500" height="600"> </body> </html> `;
		"500" height="600"> </body> </html> `
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: const htmlContent = ` <html> <head> <title> Uploaded File Content</title> </head> <body> <h1> Uploaded File Content</h1> <img src="${filePath}" alt="image" width="500" height
		"image" width="500" height
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: const htmlContent = ` <html> <head> <title> Uploaded File Content</title> </head> <body> <h1> Uploaded File Content</h1> <img src="${filePath}" alt="image" width
		"${filePath}" alt="image" width
'INSTANT VB TODO TASK: The following line contains an assignment within expression that was not extracted by Instant VB:
'ORIGINAL LINE: const htmlContent = ` <html> <head> <title> Uploaded File Content</title> </head> <body> <h1> Uploaded File Content</h1> <img src="${filePath}" alt
		const htmlContent = ` (Of html) (Of head) (Of title) Uploaded File Content</title> </head> (Of body) (Of h1) Uploaded File Content</h1> <img src="${filePath}" alt
		const pdf = Await document.fromHtml(htmlContent)
		const pdfPath = path.join(__dirname, 'uploads', `${@Date.now()}-output.pdf`);
		Await pdf.saveAs(pdfPath)
'INSTANT VB TODO TASK: The following line contains an assignment within expression that was not extracted by Instant VB:
'ORIGINAL LINE: res.send(`File uploaded and PDF generated successfully! <a href="/download-pdf?path=${pdfPath}"> Download PDF</a>`);
		res.send(`File uploaded [and] PDF generated successfully!<a href="/download-pdf?path=${pdfPath}"> Download PDF</a>`)
	Catch e1 As err
		res.status(500).send({ [error]:= err.message })
	End Try
End If
)
' Route to download generated PDF
  app.get( '/download-pdf', (req, res) =>
  If True Then
	  const filename = req.query.filename
	  const pdfPath = path.join(__dirname, 'uploads', filename);
	  res.download(pdfPath)
  End If
  )
' Start the server
const PORT = process.env.PORT 3000
'INSTANT VB TODO TASK: Lambda expressions and anonymous methods are not converted by Instant VB if local variables of the outer method are referenced within the anonymous method:
app.listen(PORT, () =>

Integramos Multer e IronPDF en el código proporcionado de Node.js para crear un sistema confiable de gestión de cargas de archivos y producción de documentos PDF. Configuramos Multer con una configuración de almacenamiento en disco para manejar la carga de archivos multipart/form-data utilizando el framework Express, asignando a cada archivo subido un nombre de archivo y un directorio de destino únicos. Multer guarda los archivos subidos por los usuarios a través de la ruta /upload-single, y el servidor examina el contenido de esos archivos.

Después de eso, este contenido se integra en una plantilla HTML básica. Este HTML se introduce en IronPDF, el cualcrea un archivo PDFque se almacena en el directorio de subidas. Al final, el servidor proporciona un enlace para descargar el PDF generado. Esta integración demuestra lo eficaz que puede ser Multer para manejar cargas de archivos, y IronPDF convierte esas cargas en PDFs de alta calidad para proporcionar una gestión de archivos y creación de documentos fluida dentro de una aplicación Node.js.

Conclusión

En conclusión, se proporciona una solución completa para organizar el contenido generado por el usuario y convertirlo en documentos pulidos mediante la integración.Multerpara cargas de archivos conIronPDFpara la generación de PDF en una aplicación Node.js. Con características como limitaciones de tamaño, filtrado de archivos y configuración de almacenamiento de archivos, Multer facilita la gestión de cargas de archivos. Por otro lado, IronPDF ofrece opciones de personalización y soporte para una variedad de elementos de estilo, lo que hace posibleconvertir información HTMLen documentos PDF de alta calidad.

Estas dos bibliotecas pueden combinarse para crear aplicaciones flexibles que permiten a los usuarios enviar archivos y hacer que se transformen automáticamente en documentos PDF estéticamente agradables. Esta integración aumenta la eficiencia de las operaciones de generación de documentos y mejora la experiencia del usuario al agilizar el proceso de generación de facturas, certificaciones, informes y más.

Proporcionar soluciones de software premium y ricas en funciones para clientes y usuarios finales se ha vuelto más fácil al integrarIronPDFy en su pila de desarrollo de aplicaciones empresariales. Además, esta sólida base facilitará proyectos, sistemas backend y mejora de procesos.

IronPDF.

Aprende más sobre otrosProductos de Iron Software. Debido a su rica documentación, una vibrante comunidad de desarrolladores en línea y revisiones frecuentes, estas tecnologías son una excelente opción para los proyectos de desarrollo de software contemporáneo.