Custom event emitter classes in Node.js - Performance & Optimization

Performance: Custom event emitter classes

MEDIUM IMPACT

This concept affects how efficiently events are handled and propagated in a Node.js application, impacting responsiveness and CPU usage.

Creating a custom event emitter to handle multiple event listeners

Node.js

const { EventEmitter } = require('events');
class GoodEmitter extends EventEmitter {
  // Inherits optimized event handling from Node.js core
}

const emitter = new GoodEmitter();
emitter.on('event', async (data) => {
  // handle event asynchronously
});

Uses Node.js built-in EventEmitter which is optimized for performance, supports async listeners, and handles errors gracefully.

📈 Performance GainNon-blocking event handling; fewer CPU spikes; better error management.

Creating a custom event emitter to handle multiple event listeners

Node.js

class BadEmitter {
  constructor() {
    this.listeners = {};
  }
  on(event, listener) {
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    this.listeners[event].push(listener);
  }
  emit(event, ...args) {
    if (this.listeners[event]) {
      this.listeners[event].forEach(listener => {
        listener(...args);
      });
    }
  }
}

This implementation uses a simple array and calls listeners synchronously without error handling or optimization, causing potential blocking and unhandled exceptions.

📉 Performance CostBlocks event loop during emit; triggers multiple synchronous calls; no batching or async handling.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Custom synchronous event emitter	N/A	N/A	N/A	[X] Bad
Node.js built-in EventEmitter with async listeners	N/A	N/A	N/A	[OK] Good

Rendering Pipeline

Custom event emitters affect the Node.js event loop and callback queue, influencing how quickly events are processed and how responsive the application feels.

→Event Loop

→Callback Execution

⚠️ BottleneckSynchronous listener execution blocks the event loop, delaying other tasks.

Core Web Vital Affected

INP

This concept affects how efficiently events are handled and propagated in a Node.js application, impacting responsiveness and CPU usage.

Optimization Tips

1Avoid synchronous listener calls that block the event loop.

2Use Node.js built-in EventEmitter for optimized event handling.

3Implement asynchronous listeners to keep the app responsive.

Performance Quiz - 3 Questions

What is a main performance risk of a custom event emitter that calls listeners synchronously without error handling?

A It blocks the event loop causing delays in other operations.

B It reduces memory usage significantly.

C It improves event handling speed by parallel execution.

D It automatically batches events to reduce CPU load.

DevTools: Performance

How to check: Run your Node.js app with --inspect flag, open Chrome DevTools, go to Performance panel, record while emitting events, and analyze event loop delays.

What to look for: Look for long tasks blocking the event loop during event emission; shorter tasks indicate better performance.