Modules, File System, Buffers & EventEmitters

Learn how to manage file streams, binary buffer data, and custom event listeners in Node.js.

1. Overview

Node.js provides essential built-in primitives for building server-side applications: 1. **Module System**: CommonJS (`require`/`module.exports`) and modern ES Modules (`import`/`export`). 2. **File System (`fs`)**: Asynchronous disk reading, writing, appending, and watching files. 3. **EventEmitter (`events`)**: The foundation of Node's reactive event-driven architecture. 4. **Buffers & Streams (`stream`)**: Efficient chunked processing of massive binary data without loading whole files into RAM.

2. Visual Architecture & Flow

Interactive REST API Explorer

Simulate HTTP GET, POST, PUT, DELETE endpoints with headers, request bodies, and real-time response inspection.

REST Architecture

Authorization Header

Content-Type: application/json

Accept: application/json

User-Agent: YourLearn-Explorer/1.0

Response Data

Status: 200

45ms

{
  "status": "success",
  "results": 2,
  "data": [
    {
      "id": "usr_101",
      "name": "Alex Mercer",
      "email": "alex@example.com",
      "role": "FullStack Engineer",
      "createdAt": "2026-07-24"
    },
    {
      "id": "usr_102",
      "name": "Sarah Connor",
      "email": "sarah@example.com",
      "role": "Backend Architect",
      "createdAt": "2026-07-20"
    }
  ]
}

3. Detailed Technical Theory

### 1. CommonJS vs ES Modules CommonJS resolves dependencies synchronously at runtime using `require()`. ES Modules (`import`/ `export`) perform static analysis at compile time, allowing tree-shaking and top-level await. ### 2. Buffers & Binary Data JavaScript in browsers originally dealt with strings. Node.js introduced `Buffer` to handle raw binary data streams directly in memory (represented as an array of octets 0-255). ### 3. Streams: Readable, Writable, Duplex, Transform Loading a 5GB video file into memory using `fs.readFile()` will crash your Node process with an `ERR_STRING_TOO_LONG` or Out-Of-Memory exception. **Streams** read data chunk by chunk (typically 64KB chunks), piping readable source data directly into a writable destination.

4. Real-World Analogy

Think of Buffers as a Bucket of Water and Streams as a Garden Hose. If you need to fill a swimming pool (A 10GB log file): - Using `fs.readFile` is like carrying thousands of heavy buckets of water all at once in your arms (Memory crash). - Using `fs.createReadStream` is like connecting a flexible garden hose that flows water continuously chunk by chunk until finished!

5. Code Example: streams-demo.js

javascript

const fs = require('fs');
const http = require('http');

// Efficiently Stream a Large File over HTTP without memory spikes
const server = http.createServer((req, res) => {
  if (req.url === '/video') {
    res.writeHead(200, { 'Content-Type': 'video/mp4' });
    const readStream = fs.createReadStream('./large-video.mp4');
    
    // Pipe reads chunks automatically into the HTTP response stream
    readStream.pipe(res);
    
    readStream.on('error', (err) => {
      res.statusCode = 500;
      res.end('File Stream Error');
    });
  }
});

server.listen(3000, () => console.log('Server running on port 3000'));