Node.js Modules: Complete Tutorial

What are Modules?

Modules are reusable blocks of code that encapsulate related functionality. They keep applications organized, maintainable, and scalable.

Think of modules like LEGO blocks: each block has a specific purpose, can be reused, combined, and replaced safely.

Types of Modules

Node.js Modules
1) Core Modules (built-in)
2) Local Modules (user-created)
3) Third-party Modules (npm)

Core Modules

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

Local Modules

const myModule = require('./myModule.js');
const utils = require('./utils');

Third-party Modules

const express = require('express');
const lodash = require('lodash');

Core Modules

fs Example

const fs = require('fs');
fs.readFile('./example.txt', 'utf8', (err, data) => {
  if (err) console.error(err);
  else console.log(data);
});

path Example

const path = require('path');
console.log(path.extname('file.txt'));
console.log(path.join('/users', 'john', 'docs'));

events Example

const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.on('login', user => console.log(`${user} logged in`));
emitter.emit('login', 'Alice');

http Example

const http = require('http');
http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello Node.js!');
}).listen(3000);

Local Modules

math.js

const PI = 3.14159;
function add(a, b) { return a + b; }
function subtract(a, b) { return a - b; }
function multiply(a, b) { return a * b; }
function divide(a, b) { if (b === 0) throw new Error('Division by zero'); return a / b; }
function circleArea(r) { return PI * r * r; }
module.exports = { add, subtract, multiply, divide, circleArea };

app.js

const math = require('./math.js');
console.log(math.add(10, 5));
console.log(math.circleArea(5));

Module Exports

// module.exports vs exports
console.log(module.exports === exports); // true initially

// Correct
module.exports = { add: (a, b) => a + b };
// Also correct
exports.add = (a, b) => a + b;

Export Patterns

• Export object with multiple functions
• Export a class
• Export a single function
• Export singleton instance

Module Import (require)

const fs = require('fs');                // core
const myModule = require('./myModule');   // local
const express = require('express');       // npm
const config = require('./config.json');  // json

Resolution Order

1. Core modules
2. Relative/absolute file modules
3. Directory modules (`index.js` / package main)
4. `node_modules` search

ES6 Modules (import/export)

Using .mjs

// math.mjs
export function add(a, b) { return a + b; }
export const PI = 3.14159;

// app.mjs
import { add, PI } from './math.mjs';

Using package.json

{
  "type": "module"
}

CommonJS vs ESM

Module Caching

// counter.js
let count = 0;
module.exports = { increment: () => ++count, getCount: () => count };

// app.js
const c1 = require('./counter');
const c2 = require('./counter');
c1.increment();
console.log(c2.getCount()); // 1 (shared cache)

delete require.cache[require.resolve('./myModule')];
const fresh = require('./myModule');

Module Wrapper Function

(function(exports, require, module, __filename, __dirname) {
  // your module code
});

This gives each module scope isolation and special variables like __filename and __dirname.

Module Patterns

• Revealing Module: expose selected methods, keep internals private.
• Class Module: export class for stateful objects.
• Factory Module: create configured instances dynamically.
• Singleton: single shared instance (config/db manager).
• Plugin Architecture: register and initialize extensible plugins.

// singleton config
class Config { get(key) { /* ... */ } }
module.exports = new Config();

Practical Examples

1) Authentication Module

const crypto = require('crypto');
const users = new Map();
module.exports = {
  register(username, password) { /* hash + store */ },
  login(username, password) { /* verify + token */ }
};

2) Validator Module

module.exports = {
  isEmail(v) { return /^[^\s@]+@([^\s@.,]+\.)+[^\s@.,]{2,}$/.test(v); },
  minLength: n => v => v.length >= n
};

3) API Client Module

class APIClient {
  get(path) { return this.request('GET', path); }
  post(path, data) { return this.request('POST', path, data); }
}
module.exports = APIClient;

4) Config Module

class Config {
  get(key) { /* dot path getter */ }
  set(key, value) { /* dot path setter */ }
}
module.exports = new Config();

Best Practices

1. Keep modules focused (single responsibility).
2. Use descriptive filenames and exported symbols.
3. Export at bottom for readability.
4. Avoid circular dependencies.
5. Use index files for folder-level exports.
6. Use specific error types instead of generic errors.
7. Document module API with comments/JSDoc.

10 Interview Questions + 10 MCQs

Contextual Learning Links

• HTML Tutorial - structure and semantics for web pages
• CSS Tutorial - styling concepts used in full-stack apps
• Bootstrap Tutorial - fast responsive UI building
• JavaScript Tutorial - core language foundation for Node.js