Apprendre Node.js en quelques jours avec l'IA - Jour 6

Aujourd'hui marquait le sixième jour de mon aventure d'apprentissage Node.js, et j'ai plongé dans le monde fascinant de la classe EventEmitter. Voici comment je l’ai parcouru et ce que j’ai appris en cours de route.

Récapitulatif de la théorie

La classe EventEmitter est la pierre angulaire de Node.js pour la gestion des événements. Il fournit un moyen robuste de créer, d'émettre et de gérer des événements, ce qui le rend essentiel pour créer des applications qui s'appuient sur une architecture basée sur les événements.

Méthodes clés d'EventEmitter :

1. on(eventName, listeningr) : enregistre un auditeur pour un événement spécifique.
2. emit(eventName, [...args]) : Émet un événement, en passant des arguments facultatifs aux auditeurs.
3. removeListener(eventName, listening) : Supprime un écouteur spécifique pour un événement.
4. once(eventName, listening) : Ajoute un écouteur qui ne sera déclenché qu'une seule fois.

Tâche pratique

Tâche : Créer des événements et des gestionnaires personnalisés.

J'ai commencé par créer une classe qui étend EventEmitter et ajouté des gestionnaires d'événements personnalisés. Voici un compte rendu étape par étape de ce que j'ai fait :

1. Définition de la classe personnalisée :

J'ai créé une classe appelée DataProcessor qui étend EventEmitter. Cette classe avait une méthode processData pour simuler le traitement des données.

   const EventEmitter = require('events');

   class DataProcessor extends EventEmitter {
     processData(data) {
       this.emit('start');

       // Simulate data processing
       setTimeout(() => {
         this.emit('data', data);
         this.emit('end');
       }, 1000);
     }
   }

1. Configurer les gestionnaires d'événements :

J'ai ensuite initialisé la classe DataProcessor et défini des gestionnaires pour trois événements : 'start', 'data' et 'end'.

   // Initialization
   const processor = new DataProcessor();

   // Event handlers
   processor.on('start', () => console.log('Processing started...'));
   processor.on('data', (data) => console.log(`Processing data: ${data}`));
   processor.on('end', () => console.log('Processing completed.'));

1. Événements émis :

Enfin, j'ai appelé la méthode processData pour voir les événements en action.

   processor.processData('Some data');

Regarder la séquence des événements se dérouler était éclairant. La sortie de la console montrait le flux depuis le démarrage du processus jusqu'à la gestion des données et leur achèvement.

Tâche indépendante

Tâche : Développer un système de notification utilisant des événements.

Pour la tâche indépendante, j'ai conçu une classe Notifier. Voici comment je l’ai abordé :

1. Création de la classe Notifier :

   const EventEmitter = require('events');

   class Notifier extends EventEmitter {
     constructor() {
       super();
       this.notifications = [];
     }

     addNotification(notification) {
       if (typeof notification !== 'string') {
         this.emit('error', 'Notification must be a string');
         return;
       }

       this.notifications.push(notification);
       this.emit('notify', notification);

       if (this.notifications.length > 0) {
         this.emit('complete');
       }
     }
   }

1. Gestionnaires d'événements définis :

J'ai configuré des gestionnaires pour « notifier », « erreur » et « terminer ».

   const notifier = new Notifier();

   notifier.on('notify', (message) => console.log(`New notification: ${message}`));
   notifier.on('error', (err) => console.error(`Error: ${err}`));
   notifier.on('complete', () => console.log('All notifications processed.'));

1. Test du système :

J'ai testé le système en ajoutant des notifications et en gérant les erreurs potentielles.

   notifier.addNotification('This is your first notification.');
   notifier.addNotification('This is your second notification.');
   notifier.addNotification(123); // This should trigger an error

C'était satisfaisant de voir comment les notifications étaient traitées, les erreurs signalées et l'événement d'achèvement déclenché.

Conclusion

L'exploration d'EventEmitter d'aujourd'hui a considérablement approfondi ma compréhension de la programmation événementielle dans Node.js. La mise en œuvre d'événements et de gestionnaires personnalisés était un excellent moyen de voir comment les événements se déroulent et comment ils peuvent être gérés efficacement. La tâche indépendante a encore renforcé ces concepts et m'a donné une expérience pratique de la création d'un système de notification.

Je suis ravi de continuer ce voyage et de voir ce que les prochains jours nous réservent !

Ressources

Toutes les leçons créées par ChatGPT peuvent être trouvées sur : https://king-tri-ton.github.io/learn-nodejs

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!