Patterns courants avec les événements

Les événements sont un aspect fondamental de Node.js et permettent de gérer des actions asynchrones et des interactions dans le code. Voici quelques patterns courants liés à l'utilisation des événements :

1. Observer Pattern

Le pattern Observer est un modèle de conception où un objet (connu sous le nom de "subject") maintient une liste de ses dépendants, appelés "observers", et les notifie automatiquement de tout changement d'état, généralement en appelant une de leurs méthodes. EventEmitter est une implémentation du pattern Observer.

const EventEmitter = require('events');

class Job extends EventEmitter {
  constructor(ops) {
    super(ops);
    // Des opérations d'initialisation
  }

  // Une méthode qui déclenche un événement
  process() {
    // ... faire quelque chose ...
    this.emit('done', { completedOn: new Date() });
  }
}

let job = new Job();

// Ajouter un observer
job.on('done', (details) => {
  console.log(`Le job a été complété à`, details.completedOn);
});

job.process();

2. Pub/Sub (Publish/Subscribe)

Pub/Sub est une forme de communication asynchrone utilisée dans les architectures orientées services. Les émetteurs d'événements (publishers) publient des messages sans se préoccuper des abonnés (subscribers), qui peuvent écouter et réagir à certains messages.

const messageBus = new EventEmitter();
const topic = 'userCreated';

// Subscriber 1
messageBus.on(topic, (user) => {
  sendWelcomeEmail(user);
});

// Subscriber 2
messageBus.on(topic, (user) => {
  logActivity(`Nouvel utilisateur créé: ${user.name}`);
});

// Publisher
messageBus.emit(topic, { name: 'John Doe', email: 'john@example.com' });

3. State Change Events

Les événements peuvent être utilisés pour signaler des changements d'état dans une application, permettant à différentes parties de l'application de réagir à ces changements.

class User {
  constructor() {
    this.status = 'offline';
  }

  login() {
    this.status = 'online';
    this.emit('statusChanged', this.status);
  }

  logout() {
    this.status = 'offline';
    this.emit('statusChanged', this.status);
  }
}

const user = new User();
user.on('statusChanged', (status) => {
  console.log(`L'état de l'utilisateur est maintenant ${status}`);
});

4. Stream Events

Les streams en Node.js sont des instances de EventEmitter qui permettent de travailler avec des données de lecture/écriture de manière asynchrone. Les événements comme data, end, et error sont couramment utilisés pour travailler avec des streams.

const fs = require('fs');
const readableStream = fs.createReadStream('file.txt');

readableStream.on('data', (chunk) => {
  console.log(`Reçu ${chunk.length} octets de données.`);
});

readableStream.on('end', () => {
  console.log('Il n\'y a plus de données à lire.');
});

5. Error Events

La gestion des erreurs est souvent réalisée à l'aide d'événements error. C'est un moyen de propager et de réagir aux erreurs qui peuvent survenir dans différentes parties de l'application.

const net = require('net');
const connection = net.connect('localhost');

connection.on('error', (err) => {
  console.error('Une erreur de connexion est survenue:', err);
});

6. Cleanup Events

Les événements peuvent également être utilisés pour nettoyer ou fermer des ressources avant qu'une application ne se termine, en écoutant des événements comme close ou exit.

process.on('exit', (code) => {
  console.log(`Le processus va se terminer avec le code: ${code}`);
  // Fermer les connexions, nettoyer les ressources, etc.
});

En utilisant ces patterns, vous pouvez structurer votre code de manière à ce qu'il soit modulaire, réactif et facile à comprendre. Les événements sont un outil puissant pour créer des applications Node.js qui sont à la fois efficaces et capables de gérer des opérations complexes.