Node.js: Code Outside the Browser / Node.js Internals and How it Works

How Requiring Modules Really Works

📦 Node.js Module System

  • 📄 In Node, every file is its own module.

  • ⚙️ Node's module system is CommonJS — built around require() and module.exports, designed for server-side use.

  • 🌐 JavaScript also has a native ES Module system (import/export), mostly used in browsers.

  • ⚠️ These are two separate, unrelated systems — don't mix them up.

  • 🧪 Node does support native ES modules via .mjs files, but it hasn't caught on as the default — CommonJS is still what you'll use most in Node.

  • 📄 In Node, every file is its own module.

  • ⚙️ Node's module system is CommonJS — built around require() and module.exports, designed for server-side use.

  • 🌐 JavaScript also has a native ES Module system (import/export), mostly used in browsers.

  • ⚠️ These are two separate, unrelated systems — don't mix them up.

  • 🧪 Node does support native ES modules via .mjs files, but it hasn't caught on as the default — CommonJS is still what you'll use most in Node.

❓ Where Does require() Actually Come From?

require isn't part of standard JavaScript — it's not a global language feature. So how does every file get access to it automatically? Node does 4 things behind the scenes every time require() runs:

  1. 📂 Resolve the file path

  2. 🎁 Wrap the code

  3. ▶️ Execute it

  4. 💾 Cache the result

📂 Step 1: Resolving the Path

When you call require('moduleName'), Node figures out which of 3 categories it falls into:

Type

How Node identifies it

Example

⚙️ Core module

Built-in name, no path needed

require('fs')

👨‍💻 Your own file

Path starts with . or ..

require('./lib/controller')

📦 npm package

Not a core module, not a relative path

require('express')

  • ✂️ You can drop the .js extension — Node adds it automatically.

  • 📁 For your own modules: if ./lib/controller isn't a file, Node checks for a folder named controller and loads its index.js.

  • 📦 For npm packages: Node looks inside node_modules to find and load them.

  • ❌ Can't find the module anywhere? Node throws an error and the app stops.

❌ If the module can't be found anywhere → an error is thrown and the app stops.

🎁 Step 2: Wrapping (the actual "magic")

This step explains why require, module, etc. just exist in every file without you importing them.

Node never runs your file's code directly. Instead, it wraps it inside a function — specifically an IIFE (a function that runs immediately):

(function (exports, require, module, __filename, __dirname) {
// your code goes here
});

Node then calls this wrapper, passing in 5 values as arguments:

  • 📤 exports

  • 📥 require

  • 📦 module

  • 📄 __filename

  • 📁 __dirname

That's the whole trick — these aren't global variables, they're just function parameters your code happens to receive automatically.

💡 Two reasons this wrapping matters

  1. ✅ Access — every module gets require, module, __filename, __dirname for free, injected as arguments.

  2. 🔒 Isolation — top-level variables stay scoped to that file instead of leaking into the global object. Without this, if you declared let x and some npm package also had its own top-level x, they could collide and overwrite each other. Wrapping keeps each file's variables private to itself.

📚 What each injected value is

  • 📥 require — imports other modules

  • 📦 module — reference to this module; mainly used to export data via module.exports

  • 📤 exports — a shortcut that points to module.exports

  • 📄 __filename — absolute path to the current file

  • 📁 __dirname — absolute path to the current file's folder

▶️ Step 3: Execution

Once wrapped, the module's code (inside that wrapper function) is simply executed by the Node runtime. Nothing special here — just normal code execution at this point.

📤 Step 4: What require() Returns

After execution, require() hands back whatever was assigned to module.exports.

🅰️ Exporting one thing (a single class/function/value):

module.exports = SomeClassOrFunction;

🅱️ Exporting multiple named things:

exports.add = (a, b) => a + b;
exports.multiply = (a, b) => a * b;
exports.divide = (a, b) => a / b;

  • 📦 One export → module.exports = ...

  • 🏷️ Multiple exports → exports.name = ...

  • 💡 This is why you always assign require()'s result to a variable — you're capturing whatever got exported.

💾 Step 5: Caching

  • The first time a module is required, Node runs it and caches the result.

  • Every later require() of that same module returns the cached result — the file's code does not run again.

  • This means module-level code executes exactly once per app, no matter how many files require it.

✅ Key Takeaway

Every require() call goes through the same pipeline:

  1. 📂 Resolve — figure out if it's core / your file / npm, and locate it

  2. 🎁 Wrap — inject exports, require, module, __filename, __dirname via a wrapper function

  3. ▶️ Execute — run the wrapped code normally

  4. 📤 Return — hand back module.exports

  5. 💾 Cache — store the result so future require() calls skip re-running the code