← Back to Tutorials Chapter 15

References

A quick reference guide for the most commonly used Node.js built-in modules, APIs, and utilities.

Built-in Modules Quick Reference

EventEmitter

The events module provides the EventEmitter class, which is the foundation for many Node.js APIs.

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const emitter = new MyEmitter();

// Register listeners
emitter.on('event', handler);           // Add listener
emitter.once('event', handler);         // Single-use listener
emitter.prependListener('event', fn);   // Add to beginning
emitter.removeListener('event', fn);    // Remove specific
emitter.removeAllListeners('event');    // Remove all

// Emit
emitter.emit('event', arg1, arg2);

// Utility
emitter.listenerCount('event');         // Count listeners
emitter.eventNames();                   // All registered events
emitter.setMaxListeners(n);             // Set max (default 10)

Cluster

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  const numWorkers = os.cpus().length;

  // Fork workers
  for (let i = 0; i < numWorkers; i++) {
    const worker = cluster.fork();
  }

  // Events
  cluster.on('fork', (worker) => { /* Worker forked */ });
  cluster.on('online', (worker) => { /* Worker is online */ });
  cluster.on('listening', (worker, address) => { /* Worker listening */ });
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork(); // Auto-restart
  });

  // Disconnect all workers
  cluster.disconnect();
} else {
  // Worker process - runs your app
}

Crypto APIs

const crypto = require('crypto');

// Hashing
crypto.createHash('sha256').update('data').digest('hex');
crypto.createHash('md5').update('data').digest('base64');

// HMAC
crypto.createHmac('sha256', 'secret').update('data').digest('hex');

// Encryption (AES-256-CBC)
const algorithm = 'aes-256-cbc';
const key = crypto.randomBytes(32);
const iv = crypto.randomBytes(16);

function encrypt(text) {
  const cipher = crypto.createCipheriv(algorithm, key, iv);
  let encrypted = cipher.update(text, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  return { iv: iv.toString('hex'), encrypted };
}

function decrypt(encrypted) {
  const decipher = crypto.createDecipheriv(
    algorithm, key, Buffer.from(encrypted.iv, 'hex')
  );
  let decrypted = decipher.update(encrypted.encrypted, 'hex', 'utf8');
  decrypted += decipher.final('utf8');
  return decrypted;
}

// Random values
crypto.randomBytes(16).toString('hex');
crypto.randomUUID(); // Generates UUID v4

// Password hashing (PBKDF2)
crypto.pbkdf2Sync('password', 'salt', 100000, 64, 'sha512').toString('hex');

Socket APIs (Net)

const net = require('net');

// TCP Server
const server = net.createServer((socket) => {
  console.log('Client connected');

  socket.on('data', (data) => {
    console.log('Received:', data.toString());
    socket.write('Echo: ' + data);
  });

  socket.on('end', () => console.log('Client disconnected'));
});

server.listen(8000, () => console.log('TCP server on port 8000'));

// TCP Client
const client = net.createConnection({ port: 8000 }, () => {
  client.write('Hello from client!');
});

client.on('data', (data) => console.log('Server:', data.toString()));

File Streams

const fs = require('fs');

// Readable Stream
const readStream = fs.createReadStream('input.txt', {
  highWaterMark: 64 * 1024, // 64KB chunks
  encoding: 'utf8'
});

readStream.on('data', (chunk) => console.log('Chunk:', chunk.length));
readStream.on('end', () => console.log('Finished reading'));
readStream.on('error', (err) => console.error(err));

// Writable Stream
const writeStream = fs.createWriteStream('output.txt');
writeStream.write('First line\n');
writeStream.write('Second line\n');
writeStream.end('Last line\n');
writeStream.on('finish', () => console.log('Finished writing'));

// Transform Stream (example: uppercase transform)
const { Transform } = require('stream');
const upperCase = new Transform({
  transform(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
});

fs.createReadStream('input.txt')
  .pipe(upperCase)
  .pipe(fs.createWriteStream('output-upper.txt'));

HTTP/HTTPS APIs

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

// HTTP Server
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ status: 'ok' }));
});

server.listen(3000);

// HTTP Client (GET)
http.get('http://api.example.com/data', (res) => {
  let data = '';
  res.on('data', chunk => data += chunk);
  res.on('end', () => console.log(JSON.parse(data)));
});

// HTTP Client (POST)
const postData = JSON.stringify({ name: 'Alice' });
const options = {
  hostname: 'api.example.com',
  port: 443,
  path: '/users',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(postData)
  }
};

const req = https.request(options, (res) => {
  let body = '';
  res.on('data', chunk => body += chunk);
  res.on('end', () => console.log(JSON.parse(body)));
});

req.on('error', (e) => console.error(e));
req.write(postData);
req.end();

Readline Interface

const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// Ask a question
rl.question('What is your name? ', (answer) => {
  console.log(`Hello, ${answer}!`);
  rl.close();
});

// Read file line by line
const rlFile = readline.createInterface({
  input: fs.createReadStream('data.txt'),
  crlfDelay: Infinity
});

rlFile.on('line', (line) => {
  console.log('Line:', line);
});

rlFile.on('close', () => {
  console.log('File reading complete');
});

Unit (assert)

const assert = require('assert');

assert.strictEqual(actual, expected);       // === equality
assert.notStrictEqual(actual, expected);    // !==
assert.deepStrictEqual(actual, expected);   // Deep equality
assert.ok(value);                            // Truthy check
assert.throws(fn, error);                   // Expects error
assert.rejects(promise, error);             // Expects rejected promise
assert.doesNotReject(promise);              // Expects fulfilled promise

Useful Resources

Congratulations! You've completed the Node.js Tutorial: A Complete Guide. Keep building, keep experimenting, and happy coding!