Node.js – Modules (User & Built-in) – The Complete Guide to Modular Node.js Development

Introduction – What Are Modules in Node.js?

In Node.js, modules are reusable blocks of code that encapsulate functionality in separate files. This makes your codebase cleaner, more maintainable, and easier to debug. Node.js supports both:

• Built-in Modules (like fs, http, path, etc.)
• User-Defined Modules (custom modules you create)

Modules are fundamental to Node.js development and follow the CommonJS module system, where you export using module.exports and import with require().

In this guide, you’ll learn:

• How Node.js modules work
• Key built-in modules and their usage
• How to create and use custom modules
• Best practices for modular application design

What Is a Module in Node.js?

A module in Node.js is any JavaScript file that exports logic to be reused elsewhere. By default, every .js file in Node.js is treated as a module.

// math.js (User Module)
exports.add = (a, b) => a + b;
exports.sub = (a, b) => a - b;

You can use it like this:

// app.js
const math = require('./math');
console.log(math.add(10, 5)); // Output: 15

Built-in Core Modules in Node.js

Node.js comes with several core modules you can use without installing anything.

Example – Using fs Module:

const fs = require('fs');

fs.writeFileSync('hello.txt', 'Hello from Node.js!');

Example – Using path Module:

const path = require('path');

console.log(path.join(__dirname, 'file.txt'));

Creating User-Defined Modules

Step 1: Create a Module (math.js)

function add(x, y) {
  return x + y;
}

function multiply(x, y) {
  return x * y;
}

module.exports = {
  add,
  multiply
};

Step 2: Import and Use It (app.js)

const math = require('./math');

console.log(math.add(5, 10));       // Output: 15
console.log(math.multiply(2, 4));   // Output: 8

Module Types in Node.js

Module Caching

Node.js caches modules after the first time they are loaded, which improves performance:

const example = require('./myModule');
const example2 = require('./myModule');

console.log(example === example2); // true (cached)

Example – Modular Web Server with Custom Module

greet.js:

module.exports = (name) => `Hello, ${name}!`;

server.js:

const http = require('http');
const greet = require('./greet');

http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end(greet('Visitor'));
}).listen(3000);

Output:

Hello, Visitor!

Best Practices for Using Modules

Summary – Recap & Next Steps

Modules are the backbone of Node.js development. They help organize your code, promote reusability, and integrate built-in or community-maintained libraries easily.

Key Takeaways:

• Use require() to import both built-in and custom modules
• Use module.exports to expose logic to other files
• Core modules like fs, http, path offer powerful built-in capabilities

Real-world relevance:
All Node.js applications—APIs, CLIs, servers—rely on modular code organization for scalability and maintainability.

FAQs – Node.js Modules

What’s the difference between exports and module.exports?
module.exports is the actual object returned by require(), while exports is a shorthand reference. Use one consistently.

How do I import a module in Node.js?
Use require():

const fs = require('fs');

Can I import JSON files as modules?
Yes. Node.js allows importing .json directly:

const config = require('./config.json');

Are Node.js modules cached?
Yes. Modules are cached after the first load to boost performance.

Can I use ES6 import/export in Node.js?
Yes, by using .mjs file extension or enabling "type": "module" in package.json.