1. 单例模式(Singleton Pattern)
确保一个类只有一个实例,并提供一个全局访问点。
示例代码:
class Singleton {
constructor() {
if (Singleton.instance) {
return Singleton.instance;
}
Singleton.instance = this;
this.data = [];
}
addData(value) {
this.data.push(value);
}
getData() {
return this.data;
}
}
const singleton1 = new Singleton();
const singleton2 = new Singleton();
singleton1.addData('value1');
console.log(singleton1.getData()); // ['value1']
console.log(singleton2.getData()); // ['value1'] - Both are the same instance
2. 策略模式(Strategy Pattern)
定义一系列算法,把它们一个个封装起来,并且使它们可以互换。
示例代码:
class Context {
constructor(strategy) {
this.strategy = strategy;
}
executeStrategy(a, b) {
return this.strategy.execute(a, b);
}
}
class AdditionStrategy {
execute(a, b) {
return a + b;
}
}
class SubtractionStrategy {
execute(a, b) {
return a - b;
}
}
const context = new Context(new AdditionStrategy());
console.log(context.executeStrategy(5, 3)); // 8
context.strategy = new SubtractionStrategy();
console.log(context.executeStrategy(5, 3)); // 2
3. 代理模式(Proxy Pattern)
为其他对象提供一种代理以控制对这个对象的访问。
示例代码:
class RealObject {
request() {
console.log('Request made to RealObject');
}
}
class Proxy {
constructor(realObject) {
this.realObject = realObject;
}
request() {
console.log('Request intercepted by Proxy');
this.realObject.request();
}
}
const realObject = new RealObject();
const proxy = new Proxy(realObject);
proxy.request(); // Request intercepted by Proxy
// Request made to RealObject
4. 原型模式(Prototype Pattern)
通过复制现有的实例来创建新对象,而不是通过实例化新对象。
示例代码:
class Prototype {
constructor() {
this.primitive = 0;
this.object = { a: 1 };
}
clone() {
const clone = Object.create(this);
clone.object = Object.assign({}, this.object);
return clone;
}
}
const original = new Prototype();
original.primitive = 1;
original.object.a = 2;
const copy = original.clone();
console.log(copy.primitive); // 1
console.log(copy.object.a); // 2