Node.jsModules
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, whileES 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 operationshttp- HTTP server and clientpath- File path utilitiesos- Operating system utilitiesevents- Event handling
util- Utility functionsstream- Stream handlingcrypto- Cryptographic functionsurl- URL parsingquerystring- URL query string handling
To use any built-in module, use therequire() function:
Example: Using Multiple Built-in Modules
Now you can use the module's features, like creating a server:
Example: Simple HTTP Server
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:
1. Exporting Multiple Items
Add properties to theexports object for multiple exports:
Example: utils.js
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 };
2. Exporting a Single Item
To export a single item (function, object, etc.), assign it tomodule.exports:
Example: logger.js
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;
3. Using Your Modules
Import and use your custom modules usingrequire() with a relative or absolute path:
Example: app.js
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 subsequentrequire() 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_modulesfolders - Local files (using
./or../prefix)
Run the example in your terminal:
Visithttp://localhost:8080 to see the result in your browser.
Best Practices
Module Organization
- Keep modules focused on a single responsibility
- Use meaningful file and directory names
- Group related functionality together
- Use
index.jsfor module entry points
Export Patterns
- 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 andmodule.exportsto export - Modules are cached after first load
- Follow best practices for module organization and structure
