So erstellen Sie einen benutzerdefinierten Prioritätsereignis-Emitter in Node.js

Aufstellen:

Installation und Einrichtung von Bibliotheken

npm i -d @types/node tsx typescript
npx tsc --init

Ändern Sie tsconfig.json und package.json

// tsconfig.json
{
  "compilerOptions": {
    "target": "es2016",
    "module": "ES6",
    "moduleResolution": "nodenext",
    "allowImportingTsExtensions": true,
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "skipLibCheck": true,
    "sourceMap": true,
    "outDir": "./dist",
    "types": ["node"]
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules"]
}

// package.json
{
  "name": "node-starter",
  "version": "0.0.0",
  "type": "module", // This should be set to "module" for using ES6 modules
  "scripts": {
    "test": "jest"
  },
  "devDependencies": {
    "@types/jest": "^29.5.14",
    "jest": "^29.7.0",
    "typescript": "^5.7.2"
  },
  "dependencies": {
    "@types/node": "^22.10.2",
    "tsx": "^4.19.2"
  }
}

---

EventEmitter in Node.js verstehen

Node.js verwendet EventEmitter als grundlegende Klasse für die Verarbeitung von Ereignissen in der asynchronen Programmierung. Mit dieser Klasse können Sie Listener für bestimmte Ereignisse registrieren und diese Ereignisse bei Bedarf ausgeben. Standardmäßig verarbeitet EventEmitter Ereignisse in der Reihenfolge, in der die Listener hinzugefügt wurden. Manchmal möchten wir jedoch möglicherweise der Ausführung bestimmter Listener Vorrang vor anderen einräumen. Hier können wir ein prioritätsbasiertes Veranstaltungssystem einführen.

Schritte zum Erstellen eines Prioritäts-EventEmitters

1. Von EventEmitter erben:
   Um einen benutzerdefinierten Ereignisemitter mit Prioritätsbehandlung zu erstellen, müssen wir die integrierte EventEmitter-Klasse erweitern. Dadurch erhalten wir Zugriff auf alle integrierten Methoden wie „on“, „emit“ und „removeListener“.
   

   import EventEmitter from 'events';
   
   export class PriorityEmitter extends EventEmitter {
     private _listeners: Record<
       string,
       { listener: (...args: any[]) => void; priority: number }[]
     >;
   
     constructor() {
       super();
       this._listeners = {};
     }
   }
   

- `PriorityEmitter` extends `EventEmitter`, so it inherits all of its functionality.
- We introduce a new internal property `_listeners` to store listeners along with their priorities.

1. Überschreiben der on-Methode:
   Durch Überschreiben der on-Methode können wir eine benutzerdefinierte Logik hinzufügen, um die Listener zusammen mit ihren Prioritäten zu speichern und sie basierend auf ihrer Priorität zu sortieren.
   

   on(event: string, listener: (...args: any[]) => void, priority = 0) {
     if (!this._listeners[event]) this._listeners[event] = [];
     this._listeners[event].push({ listener, priority });
     this._listeners[event].sort((a, b) => b.priority - a.priority);
     return this;
   }
   

- For production usage, consider using other data structures instead of arrays, which maintain order.
- When a listener is added using `on`, we push the listener and its priority into the `_listeners` array.
- We then sort the listeners in descending order based on the priority. This ensures that higher-priority listeners are executed first.
- The default priority is `0` if not specified.

1. Überschreiben der Emit-Methode:
   Die emit-Methode löst das Ereignis aus und führt die Listener aus. Bei der überschriebenen Methode verarbeiten wir zunächst die Listener von _listeners basierend auf ihrer Priorität.
   

   emit(event: string, ...args: any[]) {
     if (this._listeners[event]) {
       for (const { listener } of this._listeners[event]) {
         listener(...args);
       }
     }
     return super.emit(event, ...args);
   }
   

- For the given event, we iterate over the sorted listeners and call each listener.
- After handling the custom priority-based logic, we call the parent class’s `emit` method to ensure the standard behavior is also preserved.

1. Überschreiben der Methode „removeListener“:
   Die Methode „removeListener“ wird überschrieben, um sicherzustellen, dass Listener basierend auf ihrer Referenz korrekt entfernt werden. Da wir Listener zusammen mit ihren Prioritäten speichern, filtern wir den richtigen Listener heraus.
   

   removeListener(event: string, listener: (...args: any[]) => void) {
     if (this._listeners[event]) {
       this._listeners[event] = this._listeners[event].filter(
         (stored_listener) => stored_listener.listener !== listener
       );
     }
     super.removeListener(event, listener);
     return this;
   }
   

- We filter the listener array to remove the listener with the exact reference.
- Then we call `super.removeListener` to ensure proper cleanup and avoid memory leaks.

---

So funktioniert der PriorityEmitter

• Wenn ein Ereignis ausgegeben wird, werden Listener in der Reihenfolge ihrer Priorität aufgerufen. Je höher die Priorität, desto früher wird es ausgeführt.
• Listener mit gleicher Priorität werden in der Reihenfolge ausgeführt, in der sie hinzugefügt wurden.

Beispielverwendung

Hier ist ein Beispiel, um zu zeigen, wie der PriorityEmitter in der Praxis funktioniert:

const pe = new PriorityEmitter();

// Listener with higher priority
pe.on('greet', (name: string) => {
  console.log(`Hello ${name}!`);
}, 2);

// Listener with lower priority
pe.on('greet', (name: string) => {
  console.log(`Hi, ${name}!`);
}, 1);

// Emitting the event
pe.emit('greet', 'Alice');

Ausgabe:

npm i -d @types/node tsx typescript
npx tsc --init

• Der Zuhörer mit der Priorität 2 (Hallo Alice!) wird zuerst aufgerufen.
• Der Zuhörer mit der Priorität 1 (Hallo, Alice!) wird als nächstes aufgerufen.

---

Leistungsaspekte

• Datenstrukturauswahl: In diesem einfachen Beispiel verwenden wir ein Array zum Speichern von Listenern und sortieren sie jedes Mal, wenn ein Listener hinzugefügt wird. Dies kann bei einer großen Anzahl von Zuhörern ineffizient werden. Eine bessere Lösung für den Umgang mit Prioritäten in einer leistungskritischen Umgebung wäre die Verwendung eines Max-Heaps, der effiziente Einfüge- und Entfernungsvorgänge ermöglicht.
• Verwendung in der Produktion: Erwägen Sie für Anwendungen auf Produktionsebene die Verwendung erweiterter Datenstrukturen oder externer Bibliotheken, die Prioritätswarteschlangen bereitstellen, um eine große Anzahl von Ereignissen effizienter zu verarbeiten.

---

Vollständiger Code

// tsconfig.json
{
  "compilerOptions": {
    "target": "es2016",
    "module": "ES6",
    "moduleResolution": "nodenext",
    "allowImportingTsExtensions": true,
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "skipLibCheck": true,
    "sourceMap": true,
    "outDir": "./dist",
    "types": ["node"]
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules"]
}

// package.json
{
  "name": "node-starter",
  "version": "0.0.0",
  "type": "module", // This should be set to "module" for using ES6 modules
  "scripts": {
    "test": "jest"
  },
  "devDependencies": {
    "@types/jest": "^29.5.14",
    "jest": "^29.7.0",
    "typescript": "^5.7.2"
  },
  "dependencies": {
    "@types/node": "^22.10.2",
    "tsx": "^4.19.2"
  }
}

Das obige ist der detaillierte Inhalt vonSo erstellen Sie einen benutzerdefinierten Prioritätsereignis-Emitter in Node.js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!