Event Emitter

EventEmitter in Node.js: Use Cases and Benefits

What is EventEmitter?

EventEmitter is a core class in Node.js that implements the Observer pattern. It allows objects to communicate with each other through a publisher-subscriber model. One object (the emitter) emits named events, and other objects (the listeners) can subscribe to these events.

How it Works

const EventEmitter = require('events');

// Create an emitter
const myEmitter = new EventEmitter();

// Add event listener
myEmitter.on('event', (arg) => {
  console.log('Event triggered with:', arg);
});

// Emit event
myEmitter.emit('event', 'some data');

Key Use Cases

Server-side Applications
- HTTP servers emitting events when requests arrive
- Database connections signaling successful connections or errors
Stream Processing
- File streams emit events like 'data', 'end', and 'error'
- Network streams handling incoming packets
Custom Application Logic
- Task processing and workflows
- User interaction handling
- Logging and monitoring
Asynchronous APIs
- Long-running operations with progress updates
- Resource monitoring

Benefits of EventEmitter

Decoupling - Separates event producers from consumers, enabling modular code
Asynchronous Execution - Naturally handles async operations without callback pyramids
Multiple Listeners - Many functions can respond to the same event
Custom Events - Define domain-specific events for your application
Extensibility - Easy to add new event types and listeners without changing core code
Error Handling - Special 'error' event pattern for centralized error handling

Common Methods

on(eventName, listener) - Register a listener
once(eventName, listener) - Register a one-time listener
emit(eventName, [args]) - Trigger an event
removeListener(eventName, listener) - Remove a specific listener
removeAllListeners([eventName]) - Remove all listeners

EventEmitter is fundamental to Node.js's architecture and enables the non-blocking, event-driven programming model that makes Node.js powerful for building scalable network applications.

Common Use Cases for EventEmitter

Progress monitoring for long-running tasks
Handling request/response cycles in servers
Broadcasting state changes to multiple parts of an application
Custom file/stream processing
Message queues and pub/sub patterns

The example above shows how a task processor can emit different events as tasks are added, completed, or encounter errors, allowing other parts of your application to respond accordingly.

// Example: Simple Task Processor using EventEmitter
const EventEmitter = require('events');

// Create a TaskProcessor class that extends EventEmitter
class TaskProcessor extends EventEmitter {
  constructor() {
    super();
    this.tasks = [];
  }

  // Add a task to the queue
  addTask(task) {
    this.tasks.push(task);
    // Emit an event when a task is added
    this.emit('taskAdded', task);
    return this;
  }

  // Process all tasks
  processTasks() {
    console.log(`Starting to process ${this.tasks.length} tasks...`);
    
    this.tasks.forEach((task, index) => {
      // Simulate some async processing
      setTimeout(() => {
        try {
          // Simulate task processing
          console.log(`Processing task: ${task}`);
          
          // Randomly generate errors for some tasks
          if (Math.random() > 0.7) {
            throw new Error(`Failed to process task: ${task}`);
          }
          
          // Emit success event
          this.emit('taskCompleted', task, index);
        } catch (error) {
          // Emit error event
          this.emit('taskError', error, task, index);
        }
        
        // Check if all tasks are processed
        if (index === this.tasks.length - 1) {
          this.emit('tasksCompleted', this.tasks.length);
        }
      }, 1000 * index); // Process tasks with delay to see events in sequence
    });
  }
}

// Create an instance of TaskProcessor
const processor = new TaskProcessor();

// Set up event listeners
processor.on('taskAdded', (task) => {
  console.log(`👋 New task added: ${task}`);
});

processor.on('taskCompleted', (task, index) => {
  console.log(`✅ Task ${index + 1} completed: ${task}`);
});

processor.on('taskError', (error, task, index) => {
  console.error(`❌ Error on task ${index + 1}: ${error.message}`);
});

processor.on('tasksCompleted', (count) => {
  console.log(`All ${count} tasks have been processed!`);
});

// Add tasks and start processing
processor
  .addTask('Read file')
  .addTask('Send email')
  .addTask('Write to database')
  .addTask('Call API')
  .processTasks();

ES Modules in Node.js

ES Modules (ECMAScript Modules) are the official standard module system for JavaScript, now supported in Node.js alongside the original CommonJS module system.

Key Features of ES Modules

Modern Import/Export Syntax:

import { readFile } from 'fs/promises';
export function myFunction() { /* ... */ }

Static Analysis: Imports and exports are determined at parse time, not runtime
Top-level await: You can use await outside of async functions (Node.js 14.8.0+)
Strict mode: Always runs in strict mode by default

Differences from CommonJS

ES Modules	CommonJS
`import`/`export`	`require()`/`module.exports`
Static imports	Dynamic imports
Top-level await supported	No top-level await
File extensions required in imports	File extensions optional

Using ES Modules in Node.js

Method 1: File Extensions

.mjs - Always treated as ES module
.cjs - Always treated as CommonJS
.js - Depends on package.json setting

Method 2: Package.json Configuration

{
  "type": "module"
}

Important Notes

Cannot use CommonJS variables like __dirname or __filename directly in ES modules
Must include file extensions in relative imports: import './file.js' not import './file'
Can use dynamic imports with import() function
Stricter error handling compared to CommonJS

ES Modules provide better compatibility with browser JavaScript, enable tree-shaking optimization, and represent the future direction of JavaScript development.

File Upload

var http = require('http');
var formidable = require('formidable');
var fs = require('fs');
var path = require('path');

http.createServer(function (req, res) {
  if (req.url == '/fileupload') {
    // Create upload directory if it doesn't exist
    const uploadDir = path.join(__dirname, 'uploads');
    if (!fs.existsSync(uploadDir)) {
      fs.mkdirSync(uploadDir);
    }
    
    var form = new formidable.IncomingForm();
    form.parse(req, function (err, fields, files) {
      if (err) {
        console.error('Error parsing form:', err);
        res.writeHead(500, {'Content-Type': 'text/plain'});
        res.end('File upload failed');
        return;
      }
      
      // Handle both old and new formidable API versions
      let fileObject;
      
      if (Array.isArray(files.filetoupload)) {
        // New formidable API (v4+)
        fileObject = files.filetoupload[0];
      } else {
        // Older formidable API
        fileObject = files.filetoupload;
      }
      
      // Check if file exists
      if (!fileObject || !fileObject.filepath) {
        res.writeHead(400, {'Content-Type': 'text/plain'});
        res.end('No file was uploaded or file field name is incorrect');
        return;
      }
      
      var oldpath = fileObject.filepath;
      // Use originalFilename or originalFilename based on version
      var filename = fileObject.originalFilename || fileObject.name;
      var newPath = path.join(uploadDir, filename);

      fs.rename(oldpath, newPath, function (err) {
        if (err) {
          console.error('Error moving file:', err);
          res.writeHead(500, {'Content-Type': 'text/plain'});
          res.end('Failed to move file');
          return;
        }
        
        res.writeHead(200, {'Content-Type': 'text/html'});
        res.write('File uploaded and moved!');
        res.end();
      });
    });
  } else {
    res.writeHead(200, {'Content-Type': 'text/html'});
    res.write('<form action="fileupload" method="post" enctype="multipart/form-data">');
    res.write('<input type="file" name="filetoupload"><br>');
    res.write('<input type="submit">');
    res.write('</form>');
    return res.end();
  }
}).listen(8080);

console.log('Server running at http://localhost:8080/');