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

Requiring Modules in Practice

🧪 Part 1: Proving the Wrapper Function Exists

📄Create a File modules.js

🔹 Step 1: Log the arguments object

console.log(arguments);

  • arguments is a special array-like object available inside any regular function — it contains all values passed into that function.

  • If logging arguments at the top level of a module shows real values, it proves the module's code is actually running inside a function.

▶️ Run: node modules.js

Result: The logged arguments array contains 5 values — matching the wrapper function's 5 parameters:

  1. 📤 exports — empty object (nothing exported yet)

  2. 📥 require — the require function

  3. 📦 module — contains module.exports

  4. 📄 __filename — full path to modules.js

  5. 📁 __dirname — full path to the containing directory

✅ This confirms: all module code really is wrapped inside a function behind the scenes.

🔹 Step 2: View the Actual Wrapper Function Template

Node has an internal module literally called module that exposes the wrapper template:

console.log(require('module').wrapper);

  • This prints Node's actual wrapper function template — showing exports, require, module, __filename, __dirname as parameters, with a body where your module's code gets inserted.

  • ✅ Confirms exactly what was explained conceptually in the previous lecture.

📤 Part 2: Exporting with module.exports (Single Export)

📄 Create a File test-module-1.js

🔹 Step 1: Create a class

class Calculator {
  add(a, b) {
    return a + b;
  }
  multiply(a, b) {
    return a * b;
  }
  divide(a, b) {
    return a / b;
  }
}

🔹 Step 2: Export it

module.exports = Calculator;

📦 module.exports is used when exporting one single value — here, the whole Calculator class.

📄 File: modules.js — Import and Use It

const C = require('./test-module-1');

const calc1 = new C();
console.log(calc1.add(2, 5));

Run: node modules.js and see the output

  • Since it's your own module (not core, not npm), use a relative path starting with ./.

  • .js extension can be dropped.

  • You can name the imported variable anything (C here) — the name on the exporting side doesn't have to match.

  • ✅ Result: 7 (2 + 5) ✔

✨ Shorthand: Class Expression Directly in module.exports

Instead of declaring a named class then exporting it separately, assign the class expression directly:

module.exports = class {
  add(a, b) {
    return a + b;
  }
  multiply(a, b) {
    return a * b;
  }
  divide(a, b) {
    return a / b;
  }
};

  • ✅ Same result, fewer lines — no need to name the class at all since you're exporting it immediately.

📚 Part 3: Exporting with exports Shorthand (Multiple Named Exports)

📄 Create a File: test-module-2.js

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

📤 Instead of module.exports = ... (one value), add properties directly onto the exports object — useful for exporting multiple named things (here, three separate functions).

📄 File: modules.js — Import and Use It

const calc2 = require('./test-module-2');

console.log(calc2.add(2, 5));       // 7
console.log(calc2.multiply(2, 5));  // 10

📦 calc2 becomes an object containing all the properties added to exports (add, multiply, divide).

🔓 Using Destructuring on the Import

Since require() returns an object here, ES6 destructuring can pull out only the pieces you need:

const { add, multiply, divide } = require('./test-module-2');

console.log(add(2, 5));       // 7
console.log(multiply(2, 5));  // 10

  • Variable names inside { } must exactly match the property names on the exports object.

  • You can also import only what you need:

const { add, multiply } = require('./test-module-2');

✅ This destructuring-on-import pattern is very common in Node and will be used throughout the course.

💾 Part 4: Module Caching in Practice

📄 Create a File test-module-3.js

console.log("Hello from the module");

module.exports = () => console.log("Log this beautiful text 😍")

  • The console.log('Hello from the module') is top-level code — it runs immediately when the module is first loaded.

  • module.exports here is a single function (not called yet, just defined).

📄 File: modules.js — Require and Call It 3 Times

require('./test-module-3')();
require('./test-module-3')();
require('./test-module-3')();

  • ⚡ Each line requires the module (which returns the exported function) and immediately calls it (()), all in one line — equivalent to saving it to a variable first and calling it separately.

🖥️ Result when run:

Hello from the module
Log this beautiful text 😍
Log this beautiful text 😍
Log this beautiful text 😍

  • 'Log this beautiful text' prints 3 times — because the exported function itself was genuinely called 3 times.

  • 'Hello from the module' prints only once — because of caching:

    • The module's top-level code only executes on the first require() call.

    • On the 2nd and 3rd require() calls, Node just returns the cached exports (the function) — it does not re-run the module's code.

✅ Key Takeaways

  • 🎁 Every module's code genuinely runs inside a hidden wrapper function — provable by logging arguments or inspecting require('module').wrapper.

  • 📦 module.exports = value → for exporting a single value (class, function, object).

  • 📤 exports.name = value → for exporting multiple named values as properties of an object.

  • 🔓 Imports of multi-property exports can be destructured to pull out only what's needed.

  • 💾 Modules are cached after their first load — top-level code runs once only; later require() calls reuse the cached exports instead of re-executing the module.