1. Singleton Pattern
What is it?
A design pattern that restricts the instantiation of a class to a single instance.
When was it created?
Introduced as part of the GoF (Gang of Four) design patterns in 1994.
Node.js Support:
All versions of Node.js.
Why use it?
Prevents multiple instances and manages global state efficiently.
Best Practices:
• Use it for shared configurations or resource-heavy classes.
Example:
class Singleton {
static instance;
constructor() {
if (!Singleton.instance) {
Singleton.instance = this;
}
return Singleton.instance;
}
}
const singletonA = new Singleton();
const singletonB = new Singleton();
console.log(singletonA === singletonB); // true
Pros:
• Global access point.
• Easy to manage shared state.
Cons:
• Harder to test and refactor due to global reliance.
2. Factory Pattern
What is it?
Encapsulates object creation logic, returning objects from a shared interface.
When was it created?
Another GoF pattern from the 1990s.
Node.js Support:
Supported across all versions.
Why use it?
Simplifies complex object creation.
Best Practices:
• Useful when dealing with large-scale applications needing multiple object types.
Example:
class Car {
constructor(model) { this.model = model; }
}
class CarFactory {
createCar(type) {
switch(type) {
case 'sedan': return new Car('Sedan');
case 'suv': return new Car('SUV');
default: return null;
}
}
}
const factory = new CarFactory();
const sedan = factory.createCar('sedan');
console.log(sedan.model); // 'Sedan'
Pros:
• Encapsulates object creation logic.
• Supports easy object extension.
Cons:
• Overhead for simple objects.
3. Observer Pattern
What is it?
Allows one object (subject) to notify observers about state changes.
When was it created?
First formalized in the 1970s; adopted into JS in event-driven systems.
Node.js Support:
Supported by event-driven architecture.
Why use it?
Ideal for decoupling objects in event-based systems.
Best Practices:
• Use it in pub/sub messaging systems.
Example:
class Observer {
update(data) { console.log(`Observer received: ${data}`); }
}
class Subject {
constructor() { this.observers = []; }
addObserver(observer) { this.observers.push(observer); }
notify(data) { this.observers.forEach(o => o.update(data)); }
}
const subject = new Subject();
const observer = new Observer();
subject.addObserver(observer);
subject.notify('Event Fired'); // Observer received: Event Fired
Pros:
• Promotes loose coupling.
Cons:
• Can be complex to manage with many observers.
4. Strategy Pattern
What is it?
Encapsulates algorithms and allows them to be interchangeable within a class.
When was it created?
Part of GoF’s 1994 design patterns.
Node.js Support:
Supported in all modern versions.
Why use it?
Allows flexibility by changing algorithms dynamically.
Best Practices:
• Ideal for scenarios requiring multiple approaches to the same problem.
Example:
class Context {
setStrategy(strategy) { this.strategy = strategy; }
executeStrategy(a, b) { return this.strategy.doOperation(a, b); }
}
class Add {
doOperation(a, b) { return a + b; }
}
class Subtract {
doOperation(a, b) { return a - b; }
}
const context = new Context();
context.setStrategy(new Add());
console.log(context.executeStrategy(5, 3)); // 8
context.setStrategy(new Subtract());
console.log(context.executeStrategy(5, 3)); // 2
Pros:
• Easy to switch algorithms.
Cons:
• Increases class complexity.
5. Decorator Pattern
What is it?
Dynamically adds responsibilities to objects.
When was it created?
From GoF’s pattern library.
Node.js Support:
Supported in all versions with ES6 classes.
Why use it?
Provides flexible object functionality without subclassing.
Best Practices:
• Use it for adding extra features or responsibilities to objects.
Example:
class Car {
getDescription() { return 'Car'; }
}
class SportsCarDecorator {
constructor(car) { this.car = car; }
getDescription() { return `${this.car.getDescription()} with sports package`; }
}
const car = new Car();
const sportsCar = new SportsCarDecorator(car);
console.log(sportsCar.getDescription()); // 'Car with sports package'Pros:
• Extends functionality dynamically.
Cons:
• Can make the code harder to read if overused.
