eventemitter2 NPM (Cómo funciona para desarrolladores)

Introducción

En el vertiginoso entorno de desarrollo actual, es esencial crear aplicaciones que respondan a las necesidades y sean capaces de gestionar flujos de trabajo complicados con eficacia. Para ello, es esencial contar con sistemas eficaces de gestión de documentos y arquitecturas basadas en eventos. Cuando se combinan, las potentes herramientas EventEmitter2 e IronPDF permiten a los desarrolladores crear aplicaciones dinámicas basadas en eventos con funciones avanzadas de manipulación de PDF.

La funcionalidad de la clase EventEmitter normal se amplía con EventEmitter2, una biblioteca de emisores de eventos extendida para Node.js, que añade características como múltiples oyentes, espacios de nombres de eventos, comodines y eventos de expresión regular. Con estas mejoras, la gestión deorientado a eventos los flujos de trabajo se simplifican, garantizando que su aplicación pueda realizar una amplia gama de tareas asíncronas con facilidad.

En este artículo veremos cómo integrar EventEmitter2 con IronPDF en una aplicación Node.js. Repasaremos cómo instalar y configurar ambas herramientas, daremos ejemplos de cómo gestionar eventos y crear PDF dinámicos, y hablaremos de casos de uso avanzados y prácticas recomendadas. Después de leer este artículo, deberías saber cómo utilizar estas potentes tecnologías para crear sistemas complejos basados en eventos que puedan procesar archivos PDF con facilidad.

¿Qué es EventEmitter2 NPM?

Mejore la funcionalidad de la clase nativa EventEmitter conEmisor de eventos2node.js, un potente módulo de gestión de eventos para Node.js. Para manejar con mayor eficacia las intrincadas estructuras basadas en eventos, ofrece una serie de potentes funciones. Los eventos comodín y los eventos de expresión regular son dos funciones importantes que permiten activar eventos de forma más flexible basándose en patrones y agrupar y procesar numerosos eventos relacionados mediante espacios de nombres. La capacidad de EventEmitter2 de ofrecer múltiples escuchas para un mismo evento permite priorizar los escuchas para gestionar diferentes acciones provocadas por el mismo evento.

También proporciona espacios de nombres de eventos, que ayudan a organizar y clasificar los eventos, facilitando la gestión y depuración de sistemas complejos. Los oyentes asíncronos, que son esenciales para gestionar acciones no bloqueantes en aplicaciones Node.js, también son compatibles con la biblioteca de métodos emisores de eventos. Debido a estas características, EventEmitter2 es especialmente beneficioso para aplicaciones en línea a gran escala, juegos y sistemas en tiempo real que necesitan una gestión de eventos fiable. EventEmitter2, que es una extensión de la clase habitual EventEmitter, ofrece a los programadores sólidas capacidades para escribir código más escalable y mantenible.

La clase EventEmitter incorporada en Node.js se ha mejorado con el robusto paquete de gestión de eventos EventEmitter2. A continuación se indican las principales características que distinguen a EventEmitter2:

Eventos Wildcard

Permite el uso de patrones comodín evento especificado, para manejar y agrupar varios eventos relacionados. Esto es útil para una gestión de eventos más jerárquica y estructurada.

Expresiones regulares

Permite la activación de eventos según patrones de expresiones regulares, lo que proporciona más flexibilidad en la gestión de eventos.

Múltiples oyentes

Permite adjuntar más de un oyente a un evento. Un control más preciso sobre la secuencia en la que se ejecutan los escuchadores sobre los eventos descritos es posible permitiendo que cada escuchador tenga una prioridad.

Espacios de nombres de eventos

Simplifica la gestión y depuración de sistemas complicados facilitando el uso de espacios de nombres para la organización y clasificación de eventos.

Receptores asíncronos

Permite acciones no bloqueantes, esenciales para aplicaciones de alto rendimiento, al admitir escuchadores de eventos asíncronos.

Manipulación de oyentes

Ofrece formas eficaces de añadir, eliminar y gestionar oyentes.

Control de emisión de eventos

Evita fugas de memoria en programas largos al permitir controlar el número de oyentes de un evento y la capacidad de restringir el número de veces que se escucha un evento.

Burbujeo de eventos

Permite que los eventos se propaguen por una jerarquía mediante el soporte de burbujeo de eventos, que es comparable a la forma en que los eventos burbujean en el DOM de los navegadores web.

Optimización del rendimiento

Con un rendimiento optimizado, es apropiado para aplicaciones de alto tráfico en las que se requiere un procesamiento de eventos rápido y eficaz.

Advertencias detalladas sobre fugas de memoria

Ayuda a los desarrolladores a mantener sanas sus aplicaciones alertándoles de posibles fugas de memoria cuando se añaden demasiados escuchadores a un mismo evento.

Creación y configuración de EventEmitter2 Node.js

Es sencillo crear y configurar EventEmitter2 en una aplicación Node.js. Aquí tienes un tutorial detallado sobre la configuración y el uso de EventEmitter2.

Instalar EventEmitter2

El primer paso es instalar el paquete EventEmitter2 mediante npm. Utilizando un terminal abierto, escriba el siguiente comando:

npm install eventemitter2

npm install eventemitter2

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

Importar y configurar EventEmitter2

Después, importa EventEmitter2 a tu programa Node.js y modifícalo para adaptarlo a tus necesidades. Esta es una ilustración de una configuración sencilla de dos emisores de eventos:

const EventEmitter2 = require('eventemitter2').EventEmitter2;
const eventEmitter = new EventEmitter2({
  wildcard: true,         // Allows use of wildcards.
  delimiter: '.',         // The delimiter used to segment namespaces.
  newListener: false,     // If true, the `newListener` event is emitted when new listeners are added.
  maxListeners: 20,       // Maximum number of listeners per event.
  verboseMemoryLeak: true // Show warnings if potential memory leaks are detected.
});
// Example: Define a listener for a wildcard event.
eventEmitter.on('user.*', (data) => {
  console.log('User event:', data);
});

const EventEmitter2 = require('eventemitter2').EventEmitter2;
const eventEmitter = new EventEmitter2({
  wildcard: true,         // Allows use of wildcards.
  delimiter: '.',         // The delimiter used to segment namespaces.
  newListener: false,     // If true, the `newListener` event is emitted when new listeners are added.
  maxListeners: 20,       // Maximum number of listeners per event.
  verboseMemoryLeak: true // Show warnings if potential memory leaks are detected.
});
// Example: Define a listener for a wildcard event.
eventEmitter.on('user.*', (data) => {
  console.log('User event:', data);
});

const EventEmitter2 = require( 'eventemitter2').EventEmitter2;
const eventEmitter = New EventEmitter2({
	wildcard:= True,
	delimiter:= "."c,
	newListener:= False,
	maxListeners:= 20,
	verboseMemoryLeak:= True
})
' Example: Define a listener for a wildcard event.
eventEmitter.on( 'user.*', (data) =>
If True Then
	console.log( 'User event:', data);
End If
)

Eventos Emit

Después de configurar el emisor de eventos, puedes empezar a enviar eventos y observar cómo reaccionan los destinatarios. Para emitir eventos, siga estos pasos:

// Emit a user login event.
eventEmitter.emit('user.login', { username: 'john_doe' });
// Emit a user logout event.
eventEmitter.emit('user.logout', { username: 'john_doe' });

// Emit a user login event.
eventEmitter.emit('user.login', { username: 'john_doe' });
// Emit a user logout event.
eventEmitter.emit('user.logout', { username: 'john_doe' });

' Emit a user login event.
eventEmitter.emit( 'user.login', { username: 'john_doe' });
' Emit a user logout event.
eventEmitter.emit( 'user.logout', { username: 'john_doe' });

Añadir y eliminar receptores

El mismo evento permite añadir y eliminar oyentes según sea necesario. Así se hace:

// Define a specific listener.
const loginListener = (data) => {
  console.log('User logged in:', data);
};
// Add the login listener to the user.login event.
eventEmitter.on('user.login', loginListener);
// Emit the login event.
eventEmitter.emit('user.login', { username: 'jane_doe' });
// Remove the login listener.
eventEmitter.off('user.login', loginListener);
// Emit the login event again to show that the listener has been removed.
eventEmitter.emit('user.login', { username: 'jane_doe' });

// Define a specific listener.
const loginListener = (data) => {
  console.log('User logged in:', data);
};
// Add the login listener to the user.login event.
eventEmitter.on('user.login', loginListener);
// Emit the login event.
eventEmitter.emit('user.login', { username: 'jane_doe' });
// Remove the login listener.
eventEmitter.off('user.login', loginListener);
// Emit the login event again to show that the listener has been removed.
eventEmitter.emit('user.login', { username: 'jane_doe' });

' Define a specific listener.
'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 loginListener = (data) =>
If True Then
  console.log( 'User logged in:', data);
End If
' Add the login listener to the user.login event.
eventEmitter.on( 'user.login', loginListener);
' Emit the login event.
eventEmitter.emit( 'user.login', { username: 'jane_doe' });
' Remove the login listener.
eventEmitter.off( 'user.login', loginListener);
' Emit the login event again to show that the listener has been removed.
eventEmitter.emit( 'user.login', { username: 'jane_doe' });

Uso de escuchadores asíncronos

EventEmitter2 admite escuchas asíncronas, lo que resulta ventajoso cuando se gestionan operaciones de E/S intensivas u otros procesos asíncronos:

// Define an asynchronous listener.
eventEmitter.on('file.upload', async (data) => {
  await new Promise((resolve) => setTimeout(resolve, 2000)); // Simulate async operation.
  console.log('File uploaded:', data);
});
// Emit the file upload event.
eventEmitter.emit('file.upload', { filename: 'example.txt' });

// Define an asynchronous listener.
eventEmitter.on('file.upload', async (data) => {
  await new Promise((resolve) => setTimeout(resolve, 2000)); // Simulate async operation.
  console.log('File uploaded:', data);
});
// Emit the file upload event.
eventEmitter.emit('file.upload', { filename: 'example.txt' });

' Define an asynchronous listener.
eventEmitter.on( 'file.upload', async(data) =>
If True Then
	Await New Promise(Sub(resolve) setTimeout(resolve, 2000))
	console.log( 'File uploaded:', data);
End If
)
' Emit the file upload event.
eventEmitter.emit( 'file.upload', { filename: 'example.txt' });

Gestión de errores

Deben abordarse los errores que puedan surgir durante el procesamiento de eventos de error. Presta mucha atención a los errores:

eventEmitter.on('error', (err) => {
  console.error('An error occurred:', err);
});
// Emit an error event.
eventEmitter.emit('error', new Error('Something went wrong!'));

eventEmitter.on('error', (err) => {
  console.error('An error occurred:', err);
});
// Emit an error event.
eventEmitter.emit('error', new Error('Something went wrong!'));

eventEmitter.on( '@error', (err) =>
If True Then
	console.error( 'An @error occurred:', err);
End If
)
' Emit an error event.
eventEmitter.emit( '@error', New @Error('Something went wrong!'));

Juntando Todo

He aquí un ejemplo exhaustivo que sigue cada uno de los pasos mencionados anteriormente:

const EventEmitter2 = require('eventemitter2').EventEmitter2;
const eventEmitter = new EventEmitter2({
  wildcard: true,
  delimiter: '.',
  newListener: false,
  maxListeners: 20,
  verboseMemoryLeak: true
});
// Add listeners
eventEmitter.on('user.*', (data) => {
  console.log('User event:', data);
});
const loginListener = (data) => {
  console.log('User logged in:', data);
};
eventEmitter.on('user.login', loginListener);
eventEmitter.on('file.upload', async (data) => {
  await new Promise((resolve) => setTimeout(resolve, 2000));
  console.log('File uploaded:', data);
});
eventEmitter.on('error', (err) => {
  console.error('An error occurred:', err);
});
// Emit events
eventEmitter.emit('user.login', { username: 'john_doe' });
eventEmitter.emit('user.logout', { username: 'john_doe' });
eventEmitter.emit('file.upload', { filename: 'example.txt' });
//first event data argument error
eventEmitter.emit('error', new Error('Something went wrong!'));
// Remove listeners
eventEmitter.off('user.login', loginListener);
eventEmitter.emit('user.login', { username: 'jane_doe' });

const EventEmitter2 = require('eventemitter2').EventEmitter2;
const eventEmitter = new EventEmitter2({
  wildcard: true,
  delimiter: '.',
  newListener: false,
  maxListeners: 20,
  verboseMemoryLeak: true
});
// Add listeners
eventEmitter.on('user.*', (data) => {
  console.log('User event:', data);
});
const loginListener = (data) => {
  console.log('User logged in:', data);
};
eventEmitter.on('user.login', loginListener);
eventEmitter.on('file.upload', async (data) => {
  await new Promise((resolve) => setTimeout(resolve, 2000));
  console.log('File uploaded:', data);
});
eventEmitter.on('error', (err) => {
  console.error('An error occurred:', err);
});
// Emit events
eventEmitter.emit('user.login', { username: 'john_doe' });
eventEmitter.emit('user.logout', { username: 'john_doe' });
eventEmitter.emit('file.upload', { filename: 'example.txt' });
//first event data argument error
eventEmitter.emit('error', new Error('Something went wrong!'));
// Remove listeners
eventEmitter.off('user.login', loginListener);
eventEmitter.emit('user.login', { username: 'jane_doe' });

const EventEmitter2 = require( 'eventemitter2').EventEmitter2;
const eventEmitter = New EventEmitter2({
	wildcard:= True,
	delimiter:= "."c,
	newListener:= False,
	maxListeners:= 20,
	verboseMemoryLeak:= True
})
' Add listeners
eventEmitter.on( 'user.*', (data) =>
If True Then
	console.log( 'User event:', data);
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:
const loginListener = (data) =>
If True Then
  console.log( 'User logged in:', data);
End If
eventEmitter.on( 'user.login', loginListener);
eventEmitter.on( 'file.upload', async(data) =>
If True Then
	Await New Promise(Sub(resolve) setTimeout(resolve, 2000))
	console.log( 'File uploaded:', data);
End If
)
eventEmitter.on( '@error', (err) =>
If True Then
	console.error( 'An @error occurred:', err);
End If
)
' Emit events
eventEmitter.emit( 'user.login', { username: 'john_doe' });
eventEmitter.emit( 'user.logout', { username: 'john_doe' });
eventEmitter.emit( 'file.upload', { filename: 'example.txt' });
'first event data argument error
eventEmitter.emit( '@error', New @Error('Something went wrong!'));
' Remove listeners
eventEmitter.off( 'user.login', loginListener);
eventEmitter.emit( 'user.login', { username: 'jane_doe' });

En esta guía se ofrece una amplia visión general de la creación y configuración de EventEmitter2 en una aplicación Node.js, incluyendo la configuración del listener, la emisión de eventos, la gestión de errores y la gestión de operaciones asíncronas.

Para empezar

Los desarrolladores pueden crear aplicaciones dinámicas basadas en eventos con potentes funciones de creación y manipulación de PDF combinando EventEmitter2 con IronPDF en una aplicación Node.js. Con la ayuda de esta guía podrás configurar e integrar estas dos herramientas en tu proyecto Node.js.

¿Qué es IronPDF?

Una potente biblioteca Node.js cuyo objetivo es producir páginas PDF de calidad excepcional a partir de texto HTML esIronPDF. Sin sacrificar el contenido original de la web, acelera el proceso de convertir archivos HTML, CSS y otros JavaScript en PDFs correctamente formateados. Para aplicaciones web que necesitan generar documentos dinámicos e imprimibles como informes, facturas y certificaciones, esta es una herramienta muy útil.

Configuraciones de página personalizables, encabezados, pies de página y la capacidad de añadir fuentes e imágenes son solo algunas de las capacidades de IronPDF. Puede manejar estilos y diseños intrincados para garantizar que cada PDF de salida de prueba se adhiere al diseño requerido. Además, IronPDF gestiona la ejecución de JavaScript dentro de HTML, lo que permite una representación precisa de la información dinámica e interactiva.

Características de IronPDF

Generación de PDF a partir de HTML

Convierte JavaScript, HTML y CSS a PDF. IronPDF es compatible con media queries y responsive design, dos estándares web contemporáneos. útil para decorar dinámicamente informes, facturas y documentos PDF con HTML y CSS.

Edición de PDF

A los PDF preexistentes se les puede añadir texto, fotos y otros contenidos. Extraiga texto e imágenes de archivos PDF, combine numerosos PDF en un solo archivo y divida archivos PDF en varios documentos independientes. Incluye marcas de agua, anotaciones, encabezados y pies de página.

**Rendimiento y fiabilidad

El alto rendimiento y la fiabilidad son cualidades de diseño deseadas en los entornos industriales. Gestiona grandes conjuntos de documentos con facilidad.

Instalar IronPDF

Instale el paquete IronPDF para obtener las herramientas que necesita para trabajar con PDF en proyectos Node.js.

npm install @ironsoftware/ironpdf

npm install @ironsoftware/ironpdf

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

Generar PDF con EventEmitter2

Crea un archivo nuevo y configura EventEmitter2:

const EventEmitter2 = require('eventemitter2').EventEmitter2;
const IronPdf = require("@ironsoftware/ironpdf");
const document=IronPdf.PdfDocument;
var config=IronPdf.IronPdfGlobalConfig
config.setConfig({licenseKey:''});
// Initialize EventEmitter2
const eventEmitter = new EventEmitter2({
  wildcard: true,
  delimiter: '.',
  newListener: false,
  maxListeners: 20,// show event name in memory leak message when maximum amount of listeners
  verboseMemoryLeak: true,
});
// Function to generate PDF report
const generatePdfReport = async (data) => {
  try {
    const htmlContent = `<h1>Event Report</h1><p>Event: ${data.eventName}</p><p>Data: ${JSON.stringify(data)}</p>`;
    const pdfDoc = await document.fromHtml(htmlContent);
    const filePath = `event_report_${Date.now()}.pdf`;
    await pdfDoc.saveAs(filePath);
    console.log('PDF report generated:', filePath);
  } catch (error) {
    console.error('Error generating PDF report:', error);
  }
};
// Define a listener for a wildcard event
eventEmitter.on('user.*', (data) => {
  console.log('User event:', data);
  generatePdfReport({ eventName: data.eventName, ...data });
});
// test subscription event listener
eventEmitter.emit('user.login', { eventName: 'user.login', username: 'john_doe' });
eventEmitter.emit('user.logout', { eventName: 'user.logout', username: 'john_doe' });

const EventEmitter2 = require('eventemitter2').EventEmitter2;
const IronPdf = require("@ironsoftware/ironpdf");
const document=IronPdf.PdfDocument;
var config=IronPdf.IronPdfGlobalConfig
config.setConfig({licenseKey:''});
// Initialize EventEmitter2
const eventEmitter = new EventEmitter2({
  wildcard: true,
  delimiter: '.',
  newListener: false,
  maxListeners: 20,// show event name in memory leak message when maximum amount of listeners
  verboseMemoryLeak: true,
});
// Function to generate PDF report
const generatePdfReport = async (data) => {
  try {
    const htmlContent = `<h1>Event Report</h1><p>Event: ${data.eventName}</p><p>Data: ${JSON.stringify(data)}</p>`;
    const pdfDoc = await document.fromHtml(htmlContent);
    const filePath = `event_report_${Date.now()}.pdf`;
    await pdfDoc.saveAs(filePath);
    console.log('PDF report generated:', filePath);
  } catch (error) {
    console.error('Error generating PDF report:', error);
  }
};
// Define a listener for a wildcard event
eventEmitter.on('user.*', (data) => {
  console.log('User event:', data);
  generatePdfReport({ eventName: data.eventName, ...data });
});
// test subscription event listener
eventEmitter.emit('user.login', { eventName: 'user.login', username: 'john_doe' });
eventEmitter.emit('user.logout', { eventName: 'user.logout', username: 'john_doe' });

const EventEmitter2 = require( 'eventemitter2').EventEmitter2;
const IronPdf = require("@ironsoftware/ironpdf")
const document=IronPdf.PdfDocument
Dim config=IronPdf.IronPdfGlobalConfig config.setConfig({licenseKey: ''});
' Initialize EventEmitter2
const eventEmitter = New EventEmitter2({
	wildcard:= True,
	delimiter:= "."c,
	newListener:= False,
	maxListeners:= 20,
	verboseMemoryLeak:= True
})
' Function to generate PDF report
'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 generatePdfReport = async(data) =>
If True Then
  Try
	const htmlContent = `(Of h1) [Event] Report</h1>(Of p) [Event]: $
	If True Then
		data.eventName
	End If
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	</p>(Of p) Data: $
'	{
'		JSON.stringify(data)
'	}
	</p>`
	const pdfDoc = Await document.fromHtml(htmlContent)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	const filePath = `event_report_$
'	{
'		@Date.now()
'	}
	.pdf`
	Await pdfDoc.saveAs(filePath)
	console.log( 'PDF report generated:', filePath);
  Catch e1 As [error]
	console.error( '@Error generating PDF report:', @error);
  End Try
End If
' Define a listener for a wildcard event
eventEmitter.on( 'user.*', (data) =>
If True Then
	console.log( 'User event:', data);
	generatePdfReport({
		eventName:= data.eventName,
		...data
	})
End If
)
' test subscription event listener
eventEmitter.emit( 'user.login', { eventName: 'user.login', username: 'john_doe' });
eventEmitter.emit( 'user.logout', { eventName: 'user.logout', username: 'john_doe' });

Necesitamos la clase IronPDF del paquete IronPDF y la clase EventEmitter2 del paquete Eventemitter2. Lanzamos una instancia de EventEmitter2 y establecemos sus parámetros, incluidos el número máximo de oyentes, el delimitador para espacios de nombres y el soporte de comodines. Desarrollamos un método asíncrono llamadogeneratePdfReport que convierte la información HTML en un PDF utilizando IronPDF.

Tras recibir los datos del evento, la función produce una cadena HTML, un documento PDF y un archivo. La gestión de errores está integrada para registrar cualquier problema que surja al crear los PDF.

Utilizamos un comodín(usuario.*) para configurar un receptor de eventos de usuario. Cualquier evento que comience con el usuario hace que se active esta escucha. Cuando se lanza un evento, el listener registra la información sobre él y utiliza los datos del evento arg en él para invocar la función generatePdfReport. Se publican dos eventos de prueba, user.login y user.logout. Cada evento tiene una carga útil con el nombre de usuario y eventName.

Conclusión

Una aplicación Node.js puede crear sistemas dinámicos basados en eventos con sólidas capacidades de creación de PDF integrando EventEmitter2 con Node-IronPDF. Este potente combo es una gran opción para aplicaciones que necesitan informes automatizados y monitorización de datos en tiempo real, ya que ofrece a los desarrolladores la capacidad de gestionar flujos de trabajo intrincados y proporcionar informes exhaustivos.

Cuando se combina con las sofisticadas capacidades de producción de PDF de Node IronPDF y la adaptabilidad de EventEmitter2 en la gestión de eventos comodín y espacios de nombres, esta integración proporciona una solución sólida para una variedad de casos de uso. Sólo con este método de integración, podrá construir sistemas más escalables y fáciles de mantener, tanto si está creando un sistema de informes automatizados, un panel de análisis en tiempo real o cualquier otro tipo de aplicación basada en eventos.

OCR, escaneado de códigos de barras, creación de PDF, integración de Excel y una plétora de otras funciones pueden añadirse a su conjunto de herramientas para el desarrollo de Node.js con la ayuda de IronPDF yIronSoftware con una edición ordinaria que sólo cuesta 749 dólares, los desarrolladores pueden utilizar los sistemas y la suite extremadamente adaptables de IronSoftware para crear más aplicaciones y funciones web con mayor eficacia.

Disponer de alternativas de licencia claras y adaptadas al proyecto facilita a los desarrolladores la selección del modelo ideal. Con la ayuda de estas funcionalidades, los desarrolladores pueden resolver de forma fácil, eficaz y cohesiva una amplia gama de problemas.