Loading lesson path

Node.js•Module Basics

Node.js Modules

What is a Module in Node.js?

Modules are the building blocks of Node.js applications, allowing you to organize code into logical, reusable components. They help in:

Organizing code into manageable files
Encapsulating functionality
Preventing global namespace pollution
Improving code maintainability and reusability

Node.js supports two module systems: CommonJS (traditional) and ES Modules (ECMAScript modules).

This page covers CommonJS, while ES Modules are covered separately.

Core Built-in Modules

Node.js provides several built-in modules that are compiled into the binary.

Here are some of the most commonly used ones:

fs - File system operations
http - HTTP server and client
path - File path utilities
os - Operating system utilities
events - Event handling

util - Utility functions
stream - Stream handling
crypto - Cryptographic functions
url - URL parsing
querystring - URL query string handling

To use any built-in module, use the require() function:

Example: Using Multiple Built-in Modules

const http = require('http');

Now you can use the module's features, like creating a server:

Example: Simple HTTP Server

http.createServer((req, res) => {
 res.writeHead(200, {'Content-Type': 'text/html'});
 res.end('Hello World!');
}).listen(8080);

Creating and Exporting Modules

In Node.js, any file with a .js extension is a module. You can export functionality from a module in several ways:

Exporting Multiple Items

Add properties to the exports object for multiple exports:

Example: utils.js

// Exporting multiple functions
const getCurrentDate = () => new Date().toISOString();
const formatCurrency = (amount, currency = 'USD') => {
 return new Intl.NumberFormat('en-US', {
 style: 'currency',
 currency: currency
 }).format(amount);
};
// Method 1: Exporting multiple items
exports.getCurrentDate = getCurrentDate;
exports.formatCurrency = formatCurrency;
// Method 2: Exporting an object with multiple properties
// module.exports = { getCurrentDate, formatCurrency };

Exporting a Single Item

To export a single item (function, object, etc.), assign it to module.exports :

class Logger {
 constructor(name) {
 this.name = name;
 }
 log(message) {
 console.log(`[${this.name}] ${message}`);
 }
 error(error) {
 console.error(`[${this.name}] ERROR:`, error.message);
 }
}
// Exporting a single class
module.exports = Logger;

Using Your Modules

Import and use your custom modules using require() with a relative or absolute path:

Example: app.js

const http = require('http');
const path = require('path');
// Importing custom modules
const { getCurrentDate, formatCurrency } = require('./utils');
const Logger = require('./logger');
// Create a logger instance
const logger = new Logger('App');
// Create server
const server = http.createServer((req, res) => {
 try {
 logger.log(`Request received for ${req.url}`);
 res.writeHead(200, { 'Content-Type': 'text/html' });
 res.write(`<h1>Welcome to our app!</h1>`);
 res.write(`<p>Current date: ${getCurrentDate()}</p>`);
 res.write(`<p>Formatted amount: ${formatCurrency(99.99)}</p>`);
 res.end();
 } catch (error) {
 logger.error(error);
 res.writeHead(500, { 'Content-Type': 'text/plain' });
 res.end('Internal Server Error');
}
});
// Start server
const PORT = process.env.PORT || 3000;
server.listen(PORT, () => {
 logger.log(`Server running at http://localhost:${PORT}`);
});

Module Loading and Caching

Node.js caches modules after the first time they are loaded. This means that subsequent require() calls return the cached version.

Module Resolution

When you require a module, Node.js looks for it in this order:

Core Node.js modules (like fs , http )
Node modules in node_modules folders
Local files (using ./ or ../ prefix)

Run the example in your terminal

C:\Users\<Your Name>> node demo_module.js

Visit [http://localhost:8080 to see the result in your browser.

Best Practices

Keep modules focused on a single responsibility
Use meaningful file and directory names
Group related functionality together
Use index.js for module entry points

Prefer named exports for utilities
Use default exports for single-class modules
Document your module's API
Handle module initialization if needed

Summary

Modules are a key concept in Node.js. They enable you to organize code into reusable, maintainable units.

By understanding how to create, export, and use modules effectively, you can build scalable and well-structured applications.

Key takeaways

Node.js uses CommonJS modules by default
Use require() to import and module.exports to export
Modules are cached after first load
Follow best practices for module organization and structure

Node.js ES Modules