AIDE NODE

rxjs NPM (Comment ça marche pour les développeurs)

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Mis à jour:juin 22, 2025

Dans le développement web contemporain, gérer des processus asynchrones complexes et produire du contenu dynamique à la volée est souvent nécessaire pour construire des systèmes efficaces et réactifs. Node-IronPDF et RxJS (Extensions Réactives pour JavaScript) sont deux bibliothèques puissantes qui peuvent aider les développeurs à atteindre facilement ces objectifs. Ensemble, ils offrent une solution puissante pour gérer les flux de données en temps réel et produire des documents PDF soignés dans un environnement Node.js.

Une bibliothèque d'extensions réactives pour JavaScript appelée RxJS a été créée pour faciliter la programmation réactive avec Observables, simplifiant la création d'applications asynchrones ou basées sur des callbacks avec de meilleures piles d'appels déboguables. Avec ses nombreux opérateurs pour créer, combiner, filtrer et transformer des flux de données, elle permet aux développeurs de travailler de manière déclarative avec les données. Cela améliore la gestion et l'intuitivité de la gestion des événements, des requêtes asynchrones et d'autres sources de données en temps réel. Dans les applications web très interactives d'aujourd'hui, la capacité de RxJS à gérer élégamment des tâches asynchrones complexes est importante.

Nous examinerons comment inclure la bibliothèque d'extensions réactives Node-IronPDF et RxJS pour JavaScript dans une application Node.js dans cet article. Nous commencerons par passer en revue les bases de l'installation des bibliothèques nécessaires et la configuration d'un projet Node.js. Ensuite, nous aborderons la création et la gestion des méthodes de création d'Observable avec RxJS et vous montrerons comment utiliser Node-IronPDF pour utiliser ces Observables pour initier la création de PDF. Au moment où vous aurez terminé de lire cet article, vous devriez savoir exactement comment utiliser la génération de PDF sophistiquée avec la programmation réactive pour créer des applications Node.js dynamiques et réactives.

Qu'est-ce que RxJS ?

Une bibliothèque pour la programmation réactive avec les Observables—un élément crucial des applications réactives—s'appelle RxJS. Elle a une structure de fichier plus modulaire qui facilite la gestion des flux de données asynchrones, des événements, et des opérations dans les applications JavaScript, ce qui est plus facile à manipuler et plus déclaratif pour les développeurs. Une structure de fichier modulaire améliore non seulement la lisibilité et la maintenabilité mais aussi favorise la réutilisation du code et facilite les tests. Voici comment vous pouvez structurer votre projet basé sur RxJS de manière modulaire.

Les Observables qui émettent différentes valeurs au fil du temps, les opérateurs qui manipulent, filtrent, et combinent ces flux de données, et les outils puissants pour gérer la concurrence et les opérations asynchrones sont certains des composants clés de RxJS. RxJS encourage l'utilisation de la programmation fonctionnelle, qui permet aux programmeurs de représenter des processus asynchrones complexes dans un code clair et compréhensible. Obtenir des piles d'appels mieux déboguables dans RxJS est tout à fait possible avec les bonnes approches et outils.

rxjs NPM (Comment cela fonctionne pour les développeurs) : Figure 1 - RxJS

Le traitement de données en temps réel, la programmation événementielle, le contrôle de processus asynchrones complexes comme les requêtes HTTP, et la gestion réactive des interactions de l'interface utilisateur sont parmi les cas d'utilisation communs pour RxJS. C'est un choix populaire pour développer des applications réactives et évolutives tant dans le développement JavaScript frontend que backend grâce à son adaptabilité et sa vaste surface d'API.

Créer et Configurer RxJS NPM

Pour créer et configurer RxJS dans un projet Node.js en utilisant npm, suivez ces étapes :

Installer RxJS

Utilisez npm pour ajouter la dernière version de la bibliothèque RxJS en tant que dépendance à votre projet :

npm install rxjs

npm install rxjs

SHELL

Configurer RxJS dans votre application Node.js

RxJS peut être utilisé dans votre application Node.js après son installation. Un Observable peut être créé et souscrit en utilisant l'exemple simple suivant :

Ajoutez le code suivant à un fichier :

// Import necessary RxJS modules
const { Observable } = require('rxjs');

// Create an Observable that emits three values
const observable = new Observable(observer => {
  observer.next('Hello');
  observer.next('RxJS');
  observer.next('World');
  observer.complete();
});

// Subscribe to the Observable
observable.subscribe({
  next: value => console.log(value),
  complete: () => console.log('Observable completed'),
});

// Output:
// Hello
// RxJS
// World
// Observable completed

// Import necessary RxJS modules
const { Observable } = require('rxjs');

// Create an Observable that emits three values
const observable = new Observable(observer => {
  observer.next('Hello');
  observer.next('RxJS');
  observer.next('World');
  observer.complete();
});

// Subscribe to the Observable
observable.subscribe({
  next: value => console.log(value),
  complete: () => console.log('Observable completed'),
});

// Output:
// Hello
// RxJS
// World
// Observable completed

JAVASCRIPT

Création d'Observable : En utilisant le constructeur Observable, nous créons un observable qui émet les valeurs "Hello", "RxJS", et "World" dans cet ordre.

Abonnement : Nous utilisons la méthode subscribe pour nous abonner à l'observable. Le callback next enregistre chaque valeur dans la console, et le callback complete enregistre un message lorsque l'Observable se termine.

rxjs NPM (Comment cela fonctionne pour les développeurs) : Figure 2 - Sortie d'Observable

Configuration supplémentaire

Un large éventail d'opérateurs est disponible dans RxJS pour combiner, filtrer, et modifier les Observables. Ces opérateurs sont disponibles pour importation dans votre application selon vos besoins :

const { Observable } = require('rxjs');
const { map, filter } = require('rxjs/operators');

// Create an Observable that emits values
const observable = new Observable(observer => {
  observer.next(1);
  observer.next(2);
  observer.next(3);
  observer.complete();
});

// Use pipe to apply operators on the Observable
observable.pipe(
  filter(value => value > 1), // Only pass values greater than 1
  map(value => value * 10)    // Multiply the values by 10
).subscribe({
  next: value => console.log(value), // Log each value
  complete: () => console.log('Observable completed'), // Log when complete
});

// Output:
// 20
// 30
// Observable completed

const { Observable } = require('rxjs');
const { map, filter } = require('rxjs/operators');

// Create an Observable that emits values
const observable = new Observable(observer => {
  observer.next(1);
  observer.next(2);
  observer.next(3);
  observer.complete();
});

// Use pipe to apply operators on the Observable
observable.pipe(
  filter(value => value > 1), // Only pass values greater than 1
  map(value => value * 10)    // Multiply the values by 10
).subscribe({
  next: value => console.log(value), // Log each value
  complete: () => console.log('Observable completed'), // Log when complete
});

// Output:
// 20
// 30
// Observable completed

JAVASCRIPT

Cet exemple démontre l'utilisation des opérateurs avec la bibliothèque RxJS. Nous importons d'abord les opérateurs map et filter du module rxjs/operators et la classe Observable du module rxjs. Nous créons ensuite un Observable qui émet séquentiellement les valeurs 1, 2, et 3 avant de se terminer. La méthode pipe transforme cet Observable, permettant l'enchaînement des opérateurs. L'opérateur filter permet uniquement aux valeurs supérieures à un de passer au travers, et l'opérateur map multiplie chacune de ces valeurs par 10.

rxjs NPM (Comment cela fonctionne pour les développeurs) : Figure 3 - Sortie des Opérateurs avec Observables

L'Observable transformé est souscrit, et chacune des valeurs résultantes est enregistrée dans la console par le callback next. Lorsque l'Observable se termine, le callback complete enregistre un message de fin, ce qui entraîne les valeurs 20 et 30 étant sorties dans la console, suivies de "Observable completed".

Commencer

Pour utiliser RxJS (Extensions Réactives pour JavaScript) et Node-IronPDF dans une application Node.js, nous allons combiner les caractéristiques de programmation réactive de RxJS avec les fonctionnalités de création de PDF de Node-IronPDF. Avec cette combinaison, nous pouvons gérer des flux de données asynchrones et produire des documents PDF à la volée en réponse à des événements ou des modifications dans les données.

Qu'est-ce qu'IronPDF ?

La bibliothèque IronPDF pour Node.js convertit le contenu HTML en pages PDF de très haute qualité. Il accélère le processus de transformation de fichiers HTML, CSS et autres fichiers JavaScript en PDF correctement formatés sans compromettre le contenu en ligne original. Il s'agit d'un outil très utile pour les applications web qui ont besoin de produire des documents dynamiques et imprimables tels que des factures, des certificats et des rapports.

IronPDF a plusieurs fonctionnalités, y compris des paramètres de page personnalisables, des en-têtes, des pieds de page et la possibilité d'ajouter des polices et des images. Elle peut gérer des styles et des mises en page complexes pour garantir que chaque sortie de test PDF suit les spécifications. De plus, IronPDF contrôle l'exécution de JavaScript dans le HTML, permettant un rendu dynamique et interactif précis du contenu.

rxjs NPM (Comment cela fonctionne pour les développeurs) : Figure 4 - IronPDF

Caractéristiques de IronPDF

Génération de PDF à partir de HTML

Convertissez du HTML, CSS, et JavaScript en PDF. Prend en charge deux normes web modernes : les media queries et le design réactif. Utile pour utiliser HTML et CSS pour décorer dynamiquement des documents PDF, des factures et des rapports.

Édition de PDF

Il est possible d'ajouter du texte, des images, et d'autres contenus à des PDF déjà existants. Extraire du texte et des images à partir de fichiers PDF. Fusionner plusieurs PDF en un seul fichier. Diviser les fichiers PDF en plusieurs documents distincts. Ajouter des en-têtes, pieds de page, annotations, et filigranes.

Performance et Fiabilité

Dans les contextes industriels, les hautes performances et la fiabilité sont des attributs de design souhaitables. Gère facilement de grands ensembles de documents.

Installer IronPDF

Pour obtenir les outils dont vous avez besoin pour travailler avec les PDF dans les projets Node.js, installez le package IronPDF :

npm install @ironsoftware/ironpdf

npm install @ironsoftware/ironpdf

SHELL

Observables RxJS et IronPDF

Faites un fichier et configurez Node-IronPDF pour intégrer RxJS :

// Import necessary modules
const { Observable } = require('rxjs');
const { IronPdf } = require('node-ironpdf');

// Create an instance of Node-IronPDF
const ironPdf = new IronPdf();

// Create an observable that emits events at regular intervals
const observable = new Observable(observer => {
  let counter = 0;
  const intervalId = setInterval(() => {
    counter++;
    observer.next({ eventNumber: counter });
    if (counter === 3) { // Complete after three events
      observer.complete();
      clearInterval(intervalId);
    }
  }, 1000); // Emit every second
});

// Subscribe to the Observable and generate PDFs with Node-IronPDF
observable.subscribe({
  next: async data => {
    try {
      const htmlContent = `<h1>Event Report</h1><p>Event Number: ${data.eventNumber}</p>`;
      const pdf = await ironPdf.createFromHtml(htmlContent); // Create PDF from HTML
      const filePath = `./reports/event_report_${data.eventNumber}.pdf`;
      await pdf.saveAs(filePath); // Save the PDF
      console.log(`PDF report generated: ${filePath}`);
    } catch (error) {
      console.error('Error generating PDF:', error);
    }
  },
  complete: () => console.log('Observable completed'), // Log when all events are processed
});

// Import necessary modules
const { Observable } = require('rxjs');
const { IronPdf } = require('node-ironpdf');

// Create an instance of Node-IronPDF
const ironPdf = new IronPdf();

// Create an observable that emits events at regular intervals
const observable = new Observable(observer => {
  let counter = 0;
  const intervalId = setInterval(() => {
    counter++;
    observer.next({ eventNumber: counter });
    if (counter === 3) { // Complete after three events
      observer.complete();
      clearInterval(intervalId);
    }
  }, 1000); // Emit every second
});

// Subscribe to the Observable and generate PDFs with Node-IronPDF
observable.subscribe({
  next: async data => {
    try {
      const htmlContent = `<h1>Event Report</h1><p>Event Number: ${data.eventNumber}</p>`;
      const pdf = await ironPdf.createFromHtml(htmlContent); // Create PDF from HTML
      const filePath = `./reports/event_report_${data.eventNumber}.pdf`;
      await pdf.saveAs(filePath); // Save the PDF
      console.log(`PDF report generated: ${filePath}`);
    } catch (error) {
      console.error('Error generating PDF:', error);
    }
  },
  complete: () => console.log('Observable completed'), // Log when all events are processed
});

JAVASCRIPT

Tout d'abord, les modules nécessaires sont importés : IronPDF de Node-IronPDF et Observable de RxJS. IronPDF offre des fonctionnalités pour produire et modifier des documents PDF dans Node.js, tandis que Observable est utilisé pour construire un flux de données qui émet des informations au fil du temps. Pour faciliter les opérations de création et de gestion des PDF plus tard dans le code, une instance d'IronPDF est créée.

La définition d'un Observable avec le nom observable forme la base de l'application. Cet Observable est conçu pour utiliser setInterval pour libérer des objets de données { eventNumber } régulièrement. Dans ce cas, il émet trois valeurs à des intervalles d'une seconde (1000 millisecondes) : { eventNumber: 1 }, { eventNumber: 2 }, et { eventNumber: 3 }.

rxjs NPM (Comment cela fonctionne pour les développeurs) : Figure 5 - Sortie de RxJS avec IronPDF

Le callback next dans l'abonnement à l'Observable observable traite chaque valeur émise (data) à mesure qu'elle arrive. Basé sur l'eventNumber des données transmises, une chaîne de contenu HTML (htmlContent) est créée à l'intérieur de ce callback. Le document PDF est ensuite créé en utilisant ironPdf.createFromHtml(htmlContent) avec ce contenu HTML. Dans le répertoire ./reports, chaque fichier PDF est enregistré avec un nom de fichier distinct (event_report_1.pdf, event_report_2.pdf, etc.).

En utilisant un bloc try...catch, une gestion d'erreur est incluse dans le callback next pour traiter les erreurs possibles qui peuvent survenir au cours du processus de création de PDF. Lorsqu'une erreur se produit, elle est enregistrée dans la console à l'aide de console.error.

Finalement, pendant le callback complete de l'abonnement, un message intitulé "Observable completed" est enregistré dans la console, signifiant que l'Observable a conclu son émission de valeurs.

rxjs NPM (Comment cela fonctionne pour les développeurs) : Figure 6 - Sorties PDF

Conclusion

La programmation réactive et la production dynamique de PDF fonctionnent bien ensemble, comme le montre l'intégration de RxJS avec Node-IronPDF dans une application Node.js. En réponse à des événements en temps réel ou à des changements de données, cette combinaison fournit une solution fiable pour gérer des flux de données asynchrones et produire des documents PDF de qualité professionnelle.

À travers l'utilisation des Observables de RxJS, les développeurs peuvent efficacement superviser et modifier des flux de données asynchrones, simplifiant la gestion des flux de travail complexes et permettant des réponses déclaratives et réactives aux interactions utilisateur ou aux événements externes. Les applications comme les tableaux de bord analytiques, les outils de reporting interactifs, et les systèmes de surveillance qui doivent traiter des données en temps réel doivent avoir cette capacité.

Enfin, RxJS combiné avec Node-IronPDF permet aux développeurs de créer des applications réactives et évolutives qui gèrent efficacement les données en temps réel et offrent une création de PDF fluide. Cette combinaison permet de développer des applications complexes et événementielles avec des capacités de reporting dynamiques qui améliorent l'efficacité opérationnelle et l'expérience utilisateur. Ensemble, RxJS et Node-IronPDF fournissent une boîte à outils puissante pour la programmation contemporaine en Node.js, soutenant des tâches telles que la gestion de la création de documents dynamiques, l'interfaçage avec des sources de données en temps réel, et la production de rapports périodiques.

Les développeurs peuvent facilement choisir le meilleur modèle lorsqu'il existe des options de licence spécifiques au projet qui sont bien définies. Ces fonctionnalités permettent aux développeurs de relever une variété de défis rapidement, efficacement, et avec succès.

Darrius Serrant

Discutez maintenant avec l'équipe d'ingénierie

Ingénieur logiciel Full Stack (WebOps)

Darrius Serrant est titulaire d'un baccalauréat en informatique de l'université de Miami et travaille comme ingénieur marketing WebOps Full Stack chez Iron Software. Attiré par le codage dès son plus jeune âge, il a vu l'informatique comme à la fois mystérieuse et accessible, en faisant le ...