Test dans un environnement réel
Test en production sans filigrane.
Fonctionne partout où vous en avez besoin.
Il est essentiel de créer des applications qui soient à la fois réactives et capables de gérer efficacement des flux de travail complexes dans l'environnement de développement rapide d'aujourd'hui. Pour ce faire, il est essentiel de disposer de systèmes de gestion documentaire efficaces et d'architectures pilotées par les événements. Combinés, les puissants outils EventEmitter2 et IronPDF permettent aux développeurs de créer des apps dynamiques et événementielles dotées de fonctionnalités avancées de manipulation des PDF.
La fonctionnalité de la classe EventEmitter normale est étendue par EventEmitter2, une bibliothèque d'émetteurs d'événements étendue pour Node.js, qui ajoute des fonctionnalités telles que des auditeurs multiples, des espaces de noms d'événements, des caractères génériques et des événements d'expression régulière. Grâce à ces améliorations, la gestion despiloté par les événements la gestion des flux de travail est simplifiée, ce qui garantit que votre application peut exécuter un large éventail de tâches asynchrones en toute simplicité.
Dans cet article, nous allons voir comment intégrer EventEmitter2 avec IronPDF dans une application Node.js. Nous verrons comment installer et configurer les deux outils, nous donnerons des exemples de gestion d'événements et de création de PDF dynamiques, et nous parlerons des cas d'utilisation avancés et des pratiques recommandées. Après avoir lu cet article, vous devriez savoir comment utiliser ces technologies puissantes pour construire des systèmes complexes, pilotés par les événements, qui peuvent traiter les PDF avec facilité.
Améliorez la fonctionnalité de la classe native EventEmitter avecÉmetteur d'événements2node.js, un puissant module de gestion d'événements pour Node.js. Pour gérer plus efficacement les structures complexes pilotées par les événements, il offre un certain nombre de fonctionnalités puissantes. Les événements Wildcard et les événements à expressions régulières sont deux fonctionnalités importantes qui permettent des déclenchements d'événements plus flexibles basés sur des modèles, ainsi que le regroupement et le traitement de nombreux événements connexes à l'aide d'espaces de noms. La hiérarchisation des auditeurs pour gérer différentes actions déclenchées par le même événement est rendue possible par la capacité d'EventEmitter2 à gérer plusieurs auditeurs pour un seul événement.
Il fournit également des espaces de noms d'événements, qui permettent d'organiser et de classer les événements, facilitant ainsi la gestion de systèmes complexes et le débogage. Les auditeurs asynchrones, qui sont essentiels pour gérer les actions non bloquantes dans les applications Node.js, sont également pris en charge par la bibliothèque de méthodes d'émetteurs d'événements. En raison de ces caractéristiques, EventEmitter2 est particulièrement utile pour les applications en ligne à grande échelle, les jeux et les systèmes en temps réel qui nécessitent une gestion fiable des événements. EventEmitter2, qui est une extension de la classe EventEmitter classique, offre aux programmeurs de solides capacités pour écrire un code plus évolutif et plus facile à maintenir.
La classe EventEmitter intégrée dans Node.js est améliorée par le paquetage robuste de traitement des événements EventEmitter2. Voici les principales caractéristiques qui distinguent EventEmitter2 :
Permet d'utiliser des caractères génériques pour spécifier un événement, afin de traiter et de regrouper plusieurs événements liés. Ces outils sont utiles pour la gestion d'événements plus hiérarchiques et structurés.
Permet de déclencher des événements en fonction de modèles d'expressions régulières, offrant ainsi une plus grande flexibilité dans la gestion des événements.
Permet d'attacher plus d'un écouteur à un événement. Il est possible de contrôler plus précisément l'ordre dans lequel les écouteurs sont exécutés au-dessus des événements décrits en permettant à chaque écouteur d'avoir une priorité.
Simplifie la gestion et le débogage de systèmes complexes en facilitant l'utilisation d'espaces de noms pour l'organisation et la classification des événements.
Permet des actions non bloquantes, qui sont essentielles pour les applications de haute performance, en prenant en charge les récepteurs d'événements asynchrones.
Offre des moyens efficaces d'ajouter, de supprimer et de gérer les auditeurs.
Prévient les fuites de mémoire dans les programmes longs en permettant de contrôler le nombre d'auditeurs d'un événement et de limiter le nombre de fois qu'un événement est écouté.
Permet aux événements de se propager dans une hiérarchie en prenant en charge le bouillonnement d'événements, qui est comparable à la façon dont les événements bouillonnent dans le DOM des navigateurs web.
Optimisé en termes de performances, il convient aux applications à fort trafic nécessitant un traitement rapide et efficace des événements.
Aide les développeurs à préserver la santé de leurs applications en les alertant sur les fuites de mémoire possibles lorsque trop d'auditeurs sont ajoutés à un seul événement.
Il est simple de créer et de configurer EventEmitter2 dans une application Node.js. Voici un tutoriel détaillé sur la configuration et l'utilisation d'EventEmitter2.
La première étape consiste à installer le paquet EventEmitter2 à l'aide de npm. Dans un terminal ouvert, tapez la commande suivante :
npm install eventemitter2
npm install eventemitter2
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'npm install eventemitter2
Ensuite, importez EventEmitter2 dans votre programme Node.js et modifiez-le en fonction de vos besoins. Voici une illustration d'une configuration simple d'un émetteur d'événements deux :
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
)
Après avoir configuré l'émetteur d'événements, vous pouvez commencer à envoyer des événements et observer la réaction des destinataires. Pour émettre des événements, procédez comme suit :
// 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' });
Le même événement vous permet d'ajouter et de supprimer des auditeurs selon vos besoins. Voici comment procéder :
// 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' });
Les auditeurs asynchrones sont pris en charge par EventEmitter2, ce qui est avantageux lors de la gestion d'opérations à forte intensité d'E/S ou d'autres processus asynchrones :
// 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' });
Les erreurs qui peuvent survenir lors du traitement des événements d'erreur doivent être traitées. Vous pouvez faire attention aux erreurs :
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!'));
Voici un exemple complet qui suit chacune des étapes mentionnées précédemment :
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' });
Ce guide donne un aperçu complet de la création et de la configuration d'EventEmitter2 dans une application Node.js, y compris la configuration de l'auditeur, l'émission d'événements, la gestion des erreurs et la gestion des opérations asynchrones.
Les développeurs peuvent construire des applications dynamiques, pilotées par des événements, avec de puissantes capacités de création et de manipulation de PDF en combinant EventEmitter2 avec IronPDF pour Node.js dans une application Node.js. Ce guide vous permettra de configurer et d'intégrer ces deux outils dans votre projet Node.js.
Une puissante bibliothèque Node.js qui vise à produire des pages PDF d'une qualité exceptionnelle à partir de texte HTML estIronPDF. Sans sacrifier le contenu web original, il accélère le processus de conversion des fichiers HTML, CSS et autres fichiers JavaScript en PDF correctement formatés. Pour les applications web qui doivent générer des documents dynamiques et imprimables tels que des rapports, des factures et des certifications, c'est un outil très utile.
Paramètres de page personnalisables, en-têtes, pieds de page, et la possibilité d'ajouter des polices et des images ne sont qu'un aperçu des capacités d'IronPDF. Elle peut gérer des styles et des mises en page complexes afin de garantir que chaque PDF de sortie de test respecte la mise en page requise. En outre, IronPDF gère l'exécution de JavaScript à l'intérieur de HTML, ce qui permet un rendu précis des informations dynamiques et interactives.
**Génération de PDF à partir de HTML
Convertissez JavaScript, HTML et CSS en PDF. IronPDF prend en charge les media queries et le responsive design, deux normes web contemporaines. utile pour décorer dynamiquement des rapports, des factures et des documents PDF avec du HTML et du CSS.
Édition PDF
Des textes, des photos et d'autres contenus peuvent être ajoutés à des PDF préexistants. Extrayez du texte et des images de fichiers PDF, combinez plusieurs PDF en un seul fichier et divisez des fichiers PDF en plusieurs documents distincts. Inclure des filigranes, des annotations, des en-têtes et des pieds de page.
Performance et fiabilité
Les performances élevées et la fiabilité sont des qualités recherchées dans les environnements industriels. Gestion aisée de grands ensembles de documents.
Installez le package IronPDF pour obtenir les outils dont vous avez besoin pour travailler avec des PDF dans des projets Node.js.
npm install @ironsoftware/ironpdf
npm install @ironsoftware/ironpdf
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'npm install @ironsoftware/ironpdf
Créez un nouveau fichier et configurez 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' });
Nous avons besoin de la classe IronPDF du package IronPDF et de la classe EventEmitter2 du package Eventemitter2. Nous lançons une instance d'EventEmitter2 et définissons ses paramètres, notamment le nombre maximal d'auditeurs, le délimiteur pour les espaces de noms et la prise en charge des caractères génériques. Nous développons une méthode asynchrone appeléegeneratePdfReport qui convertit les informations HTML en PDF à l'aide d'IronPDF.
Après avoir reçu des données d'événement, la fonction produit une chaîne HTML, un document PDF et un fichier. La gestion des erreurs est intégrée pour enregistrer tous les problèmes rencontrés lors de la création des PDF.
Nous utilisons un caractère de remplacement(utilisateur.*) pour mettre en place un écouteur pour les événements utilisateur. Tout événement commençant par l'utilisateur entraîne l'activation de cet écouteur. Lorsqu'un événement est déclenché, l'écouteur enregistre les informations le concernant et utilise les données d'événement qu'il contient pour invoquer la fonction generatePdfReport. Deux événements de test, user.login et user.logout, sont publiés. Chaque événement a une charge utile contenant le nom d'utilisateur et le nom de l'événement (eventName).
Une application Node.js peut créer des systèmes dynamiques, pilotés par des événements et dotés de solides capacités de création de PDF en intégrant EventEmitter2 à Node-IronPDF. Cette combinaison puissante est une excellente option pour les applications qui nécessitent des rapports automatisés et un suivi des données en temps réel, car elle permet aux développeurs de gérer des flux de travail complexes et de fournir des rapports détaillés.
Associée aux capacités sophistiquées de production de PDF d'IronPDF et à l'adaptabilité d'EventEmitter2 dans la gestion des événements génériques et des espaces de noms, cette intégration constitue une solution solide pour une variété de cas d'utilisation. Avec cette seule méthode d'intégration, vous pouvez construire des systèmes plus évolutifs et plus faciles à entretenir, qu'il s'agisse d'un système de reporting automatisé, d'un tableau de bord analytique en temps réel ou de tout autre type d'application pilotée par les événements.
L'OCR, la lecture de codes-barres, la création de PDF, l'intégration d'Excel et une pléthore d'autres fonctionnalités peuvent être ajoutées à votre boîte à outils pour le développement Node.js à l'aide d'IronPDF et d'IronPDFIronSoftware grâce à l'édition ordinaire d'IronSoftware, qui ne coûte que 749 dollars, les développeurs peuvent utiliser les systèmes et la suite extrêmement adaptables d'IronSoftware pour créer davantage d'applications et de fonctionnalités web avec une plus grande efficacité.
Le fait de disposer d'alternatives de licence claires et adaptées au projet permet aux développeurs de sélectionner facilement le modèle idéal. Grâce à ces fonctionnalités, les développeurs peuvent résoudre facilement, efficacement et de manière cohérente un large éventail de problèmes.
9 produits de l'API .NET pour vos documents de bureau