All 15 Architecture & Design Patterns questions
More in Architecture & Design Patterns
How is the Factory pattern commonly applied in Node.js applications, and what problem does it solve? What is the Singleton pattern, and what are the specific risks of using it in a Node.js application? What is the Middleware (Chain of Responsibility) pattern as implemented by Express, and how does the 'next()' function drive it? What is Dependency Injection, and how is it typically implemented in Node.js given the language has no built-in DI container? What is the Strategy pattern, and how would you apply it to support multiple payment providers in a Node.js checkout service? What is a layered (n-tier) architecture in a Node.js/Express application, and what are its typical layers? What is the Repository pattern, and how does it help decouple business logic from a specific database technology? What is the Observer pattern, and how does Node.js's EventEmitter class implement it natively? What is Domain-Driven Design (DDD), and how do its concepts of entities, value objects, and aggregates apply to a Node.js codebase? What is a Hexagonal Architecture (Ports and Adapters), and what specific benefit does it provide for a Node.js API?
Advertisement
Back to results for “OOP & Classes”
Node.js › Architecture & Design Patterns

What is the Module pattern in Node.js, and how does it enable encapsulation?

Intermediate

Answer

The Module pattern uses each file's own function scope (whether via CommonJS's implicit wrapper function or ESM's module scope) to keep variables and functions private by default, exposing only what's explicitly attached to module.exports or exported via 'export' -- this gives every Node.js file natural encapsulation without needing IIFEs or closures written by hand, unlike plain browser scripts sharing a single global scope.
// counter.js
let count = 0; // private, invisible outside this file

function increment() { count += 1; return count; }
function getCount() { return count; }

module.exports = { increment, getCount };
Real-world example A payment library exposes only a processPayment() function while keeping its internal retry logic, API keys, and validation helpers completely private to the module, preventing consuming applications from accidentally depending on or mutating implementation details that might change between versions.

Common follow-ups: How does this differ from using a class with private fields (#field) for the same encapsulation goal?;What happens to module-level state when the same module is required from multiple files?

Modules (CommonJS/ESM);OOP & Classes
All 15 Architecture & Design Patterns questions