Node.js Modules in Depth with Examples

This guide shows Node.js modules, how they work, how to import and export them, and why you use them.

What are Node.js Modules?

A module in Node.js holds code in one file. It hides that code from other files. You can load it and use its code inside another file.

Here is an example:

// math.js
function add(a, b) { return a + b; }
module.exports = add;

// index.js
const add = require('./math');
console.log(add(2, 3));

This code saves one function in math.js and then loads it in index.js to use it.

You can use modules to break code into parts. That helps code stay simple, and you can reuse it in other parts of the app.

How to Import and Export Modules in Node.js

You export a value or function from one file. You import that value into another file with require.

Here is an example:

// greet.js
module.exports = function(name) {
  return 'Hello ' + name;
};

// app.js
const greet = require('./greet');
console.log(greet('Ali'));

This code makes the greet function and exports it. Then it loads it in app.js and runs it.

Here is another example:

// user.js
exports.name = 'Sara';
exports.age = 22;

// app.js
const user = require('./user');
console.log(user.name + ' ' + user.age);

This code exports two values from user.js and then imports them in app.js.

Types of Node.js Modules (Core, Local, Third-party)

Node.js has three types of modules. Core modules come with Node.js. Local modules are files you create. Third-party modules come from npm.

Core Example:

const fs = require('fs');
fs.writeFileSync('note.txt', 'Hello');

This code uses the core fs module to write a file.

Local Example:

// data.js
module.exports = { city: 'Riyadh' };

// main.js
const data = require('./data');
console.log(data.city);

This code exports one value from data.js and loads it in main.js.

Third-party Example:

const _ = require('lodash');
console.log(_.upperCase('hello world'));

This code loads lodash from npm and uses it to change a string to upper-case words.

Use Built-In Core Modules (fs, http, path, etc.)

fs module:

const fs = require('fs');
fs.appendFileSync('log.txt', 'new line\n');

This code adds a line to a file named log.txt.

http module:

const http = require('http');
const server = http.createServer((req, res) => {
  res.end('Hi');
});
server.listen(3000);

This code creates a web server on port 3000.

path module:

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

This code makes a full path to a file.

Create a Custom Module in Node.js

You make your own module by writing code in one file and exporting it. You then load that file in another part of the app.

Here is an example:

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

// index.js
const calc = require('./calc');
console.log(calc.add(5, 3));

This code creates a custom module, calc.js, with two functions. It loads that module in index.js to use its functions.

To work with NPM Packages as Modules:

You need to install a package with this command:

npm install package-name

Then you load it in your code with require. It acts like any other module.

Examples of Node.js Modules

Read JSON file with fs module:

const fs = require('fs');
const data = JSON.parse(fs.readFileSync('data.json'));
console.log(data);

This code loads a JSON file and shows its data on the console. It reads the file in sync and parses it to an object.

Build a small server with http module:

const http = require('http');
const server = http.createServer((req, res) => {
  res.write('Welcome');
  res.end();
});
server.listen(4000);

This code starts a server on port 4000 and sends text to any client that connects.

Use axios to call an API:

const axios = require('axios');
axios.get('https://api.github.com/users/octocat')
  .then(res => console.log(res.data));

This code uses axios from npm to fetch user data from GitHub API and prints it.

Wrapping Up

You learned what Node.js modules are and how you import and export them. You also saw built-in modules, custom modules, npm packages, and several examples.

Here is a quick recap:

• The modules split code into parts and allow you to load them with require.
• The core modules come with Node.js
• Local modules are your own files
• The third-party modules come from npm.

FAQs

// math.js  
function add(a, b) {  
   return a + b;  
}  

module.exports = add;  

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

const fs = require('fs');  
fs.writeFileSync('test.txt', 'Hello Node.js Modules!');  

// Install express  
npm install express  

const express = require('express');  
const app = express();  

app.get('/', (req, res) => {  
   res.send('Hello from Express Module!');  
});  

app.listen(3000, () => console.log('Server running on 3000'));  

Similar Reads