Node.js has revolutionized backend development by offering a fast, scalable, and event-driven runtime built on Chrome’s V8 JavaScript engine. Its non-blocking I/O model and modular architecture make it ideal for building everything from simple command-line tools to complex real-time applications. For developers and educators alike, mastering Node.js means understanding not just its syntax, but the rich ecosystem of built-in modules and methods that power its functionality.
This reference guide is designed to demystify the most commonly used Node.js methods, especially those found in core modules like fs, http, path, os, and crypto. These modules form the backbone of most Node.js applications, enabling developers to interact with the file system, create servers, handle paths, access system-level data, and implement secure operations. Whether you’re scaffolding a blog app, building a chat server, or teaching backend fundamentals, knowing how and when to use these methods is essential.
Node.js promotes a modular approach to development. Each module encapsulates specific functionality, and developers can import only what they need using require() or ES6 import syntax. This modularity encourages clean code organization and reusability—principles that are especially valuable in educational content creation and scalable application design.
The fs module, for example, allows asynchronous and synchronous file operations, making it perfect for tasks like reading configuration files, logging user activity, or storing uploaded content. The http module provides the foundation for building web servers without relying on external frameworks, giving learners a clear view of how requests and responses are handled under the hood. Meanwhile, path helps normalize and manipulate file paths across operating systems, and os offers insights into the host machine—useful for monitoring and optimization.
Beyond these, the crypto module introduces hashing and encryption techniques, which are increasingly relevant in authentication systems and secure data handling. Understanding these methods not only improves your technical fluency but also empowers you to build more robust and secure applications.
This reference also touches on common patterns like event-driven programming using EventEmitter, middleware chaining in Express.js, and modular exports—all of which are foundational to writing maintainable Node.js code. These patterns are especially useful when teaching learners how to structure applications logically and handle asynchronous behavior gracefully.
Whether you’re a backend developer refining your toolkit, an educator crafting tutorials, or a curious learner exploring Node.js for the first time, this guide aims to be your practical companion. It’s structured for clarity, rich with examples, and focused on real-world application—so you can spend less time deciphering documentation and more time building, teaching, and innovating.
Core Node.js Modules & Key Methods
Here’s a curated Node.js Methods Reference to help you navigate its core functionality, especially useful for backend development, educational content creation, and real-world project scaffolding. This reference focuses on built-in modules, commonly used methods, and patterns that are essential for writing clean, efficient Node.js code in 2025.
Core Node.js Modules & Key Methods
1. fs (File System)
Used for reading, writing, and manipulating files.
| Method | Description |
|---|---|
fs.readFile(path, callback) | Reads a file asynchronously |
fs.writeFile(path, data, callback) | Writes data to a file |
fs.appendFile(path, data, callback) | Appends data to a file |
fs.unlink(path, callback) | Deletes a file |
fs.mkdir(path, options, callback) | Creates a directory |
2. http
Used to create HTTP servers and handle requests/responses.
| Method | Description |
|---|---|
http.createServer((req, res) => {}) | Creates an HTTP server |
res.write(data) | Sends data to the client |
res.end() | Ends the response |
req.on('data', chunk) | Handles incoming data chunks |
req.on('end') | Signals end of data stream |
3. path
Used for handling and transforming file paths.
| Method | Description |
|---|---|
path.join(...paths) | Joins path segments |
path.resolve(...paths) | Resolves absolute path |
path.basename(path) | Gets the last portion of a path |
path.extname(path) | Gets the file extension |
4. os
Provides system-level information.
| Method | Description |
|---|---|
os.platform() | Returns OS platform |
os.cpus() | Returns CPU info |
os.totalmem() | Returns total memory |
os.freemem() | Returns free memory |
5. crypto
Used for encryption, hashing, and secure operations.
| Method | Description |
|---|---|
crypto.createHash('sha256') | Creates a hash object |
hash.update(data) | Adds data to hash |
hash.digest('hex') | Returns hashed output |
Common Patterns & Utility Methods
Event-Driven Pattern
Node.js uses the EventEmitter class to handle asynchronous events.
const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.on('start', () => {
console.log('Started!');
});
emitter.emit('start');
Module Pattern
Encapsulates logic and exports only what’s needed.
// user.js
const getUser = () => ({ name: 'Trish', role: 'Educator' });
module.exports = { getUser };
Middleware Pattern (Express.js)
Used to handle requests in layers.
app.use((req, res, next) => {
console.log('Request received');
next();
});