Node.js module.exports Explained: Complete Guide for Developers 🚀

Understanding module.exports in Node.js: A Complete Guide 🚀

When I was reading through a some.config.js file in a project, I came across this line:

module.exports = { ... }; 

At first glance, it looked ordinary. But then I asked myself:
👉 How does module.exports really work in Node.js?

This question sent me on a deep dive into Node’s module system — from how files are wrapped, to how require() works, and how exports differs from module.exports.
Here’s what I learned (and what every JavaScript/Node developer should know) 👇

🔹 What is module.exports in Node.js? 💡

In Node.js, every file is treated as a module.
When Node loads a file, it doesn’t run it directly. Instead, it wraps your code like this:

(function (exports, require, module, __filename, __dirname) { // your file content }); 

This wrapper gives each file access to:

• exports
• require
• module
• __filename
• __dirname

That’s why you can use module.exports anywhere in your file without explicitly importing it.

🔹 The Relationship Between exports and module.exports 🔄

At the beginning of every module, Node does this:

exports = module.exports = {}; 

This means:

• exports is just a reference to module.exports.
• By default, both point to the same object.
• Whatever you add to either (without reassigning) will be exported.

✅ Example:

exports.a = 10; // works module.exports.b = 20; // works 

Result:

{ a: 10, b: 20 } 

🔹 The Common Mistake ⚠️

If you reassign exports, you break the link:

// ❌ Won't work exports = function () {  console.log("Hello"); }; 

Now exports points to a new function, but module.exports is still {}.
So nothing gets exported.

✅ Correct way:

module.exports = function () {  console.log("Hello"); }; 

🔹 How Does require() Work? 🔍

When you write:

const myModule = require("./myModule"); 

Here’s the behind-the-scenes flow:

1. Node resolves the file path (./myModule.js)
2. Checks the module cache (modules load once per runtime)
3. Wraps and executes the file inside the function wrapper
4. Returns module.exports

💡 That’s why require() always gives you module.exports — not exports.

🔹 Example: Using module.exports in Practice 📝

// user.js module.exports = {  name: "Yogesh", greet() { console.log(`Hello, ${this.name}`); } }; 

// app.js const user = require("./user");  console.log(user.name); // Yogesh user.greet(); // Hello, Yogesh 

🔹 CommonJS vs ES Modules (CJS vs ESM) ⚡

Modern Node.js supports both CommonJS (CJS) and ES Modules (ESM).

✅ CommonJS (default in Node)

// math.js module.exports = {  add: (a, b) => a + b };  // app.js const math = require("./math"); console.log(math.add(2, 3)); 

✅ ES Modules (modern JS standard)

// math.mjs export function add(a, b) {  return a + b; }  // app.mjs import { add } from "./math.mjs"; console.log(add(2, 3)); 

🔑 Key differences:

• Syntax → module.exports vs export / import
• Loading → CommonJS is synchronous; ES Modules are asynchronous
• Exports → CommonJS typically exports a single object; ESM supports multiple named exports
• Future-proofing → ESM is the official JavaScript standard, better for modern apps

🔹 Best Practices ✅

• Use exports.x = … for adding multiple exports
• Use module.exports = … when exporting one main thing (function, class, or object)
• Prefer ES Modules (import/export) in new projects if supported

✨ Conclusion

That little module.exports line in some.config.js turned out to be a doorway into Node.js internals.

What looks simple —

module.exports = { ... }; 

— is backed by a powerful module system that:

• Wraps files in functions
• Links exports and module.exports
• Returns only module.exports through require()
• Supports both CommonJS and ES Modules

Next time you use module.exports, remember:
It’s not just boilerplate — it’s the heart of how Node.js manages modules.

✍️ Written by Yogesh Bamanier
🔗 LinkedIn