Node.js Modules

Node.js modules are the building blocks of a Node.js application. They allow you to organize and reuse your code efficiently. In simple terms, a module is a reusable piece of code that can be easily imported into other parts of your application.

What Are Node.js Modules?

A module in Node.js is a file or package that contains a set of related functionalities. These functionalities can be exported from one file and imported into another, enabling code reuse across different parts of an application.

For example, you can create a module for handling database operations and reuse it in multiple files.

Types of Node.js Modules

Node.js modules are categorized into three main types:

1. Built-In Modules
   These are the modules provided by Node.js itself. Examples include fs for file operations, http for creating servers and path for working with file paths.
2. Custom Modules
   These are user-defined modules created by developers to handle specific tasks within an application.
3. Third-Party Modules
   These are modules created by the Node.js community and available via npm (Node Package Manager). Examples include express for web servers and mongoose for MongoDB operations.

Built-In Modules

Node.js comes with several built-in modules that provide core functionalities. Let’s explore some popular ones:

1. fs (File System) Module

The fs module is used for handling file operations like reading and writing files.

Example:

const fs = require('fs');

// Write to a file
fs.writeFile('example.txt', 'Hello, Node.js!', (err) => {
    if (err) throw err;
    console.log('File created and data written!');
});

// Read the file
fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) throw err;
    console.log(data);
});

2. http Module

The http module is used to create HTTP servers and handle requests.

Example:

const http = require('http');

// Create a server
const server = http.createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Hello, this is a Node.js server!');
});

// Listen on port 3000
server.listen(3000, () => {
    console.log('Server running at http://localhost:3000');
});

3. path Module

The path module helps you work with file and directory paths.

Example:

const path = require('path');

// Get the base file name
console.log(path.basename(__filename));

// Join paths
console.log(path.join(__dirname, 'folder', 'file.txt'));

Custom Modules

You can create your own modules in Node.js to keep your code modular and organized.

How to Create a Custom Module

Create a File: Create a new file (e.g., math.js) with the following code:

// math.js
const add = (a, b) => a + b;
const subtract = (a, b) => a - b;

// Export the functions
module.exports = { add, subtract };

Use the Custom Module: In another file, import and use the math.js module:

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

console.log('Addition:', math.add(5, 3)); // Output: 8
console.log('Subtraction:', math.subtract(5, 3)); // Output: 2

Third-Party Modules

Node.js has a vast ecosystem of third-party modules available via npm.

Installing a Third-Party Module

Use npm to install a module. For example, to install lodash:

npm install lodash

Use the installed module in your application:

const _ = require('lodash');

const numbers = [10, 20, 30, 40];
const sum = _.sum(numbers);

console.log('Sum:', sum); // Output: 100

The module.exports and require

Node.js uses module.exports to define what a module exports and require to import those exports into another file.

Example:

// module.js
const greet = (name) => `Hello, ${name}!`;

module.exports = greet;

// app.js
const greet = require('./module');

console.log(greet('John')); // Output: Hello, John!

Common Mistakes with Modules

1. Forgetting to Export: Ensure you export the required functions or variables using module.exports.
2. Incorrect Path: Use relative paths ( ./ ) when importing custom modules.
3. Not Using npm: Always install third-party modules using npm to manage dependencies properly.

Real-World Example

Let’s create a real-world example using built-in, custom, and third-party modules together:

Create a utils.js File:

const os = require('os');

const getSystemInfo = () => {
    return {
        platform: os.platform(),
        cpuCount: os.cpus().length,
        memory: os.totalmem(),
    };
};

module.exports = getSystemInfo;

Main Application:

const getSystemInfo = require('./utils');
const _ = require('lodash');

const info = getSystemInfo();
console.log('System Info:', info);

const numbers = [10, 20, 30];
console.log('Sum of numbers:', _.sum(numbers));