有哪些开发者模式？

1、单例开发模式（Singleton Pattern）

单例模式是一种创建型设计模式，目的是确保在程序运行期间，某个类只有一个实例，并提供一个全局访问点来访问该实例。

核心特点

唯一实例：一个类只能创建一个对象实例。
全局访问：通过一个静态方法或变量来访问该实例。
延迟初始化：实例通常在第一次使用时才会被创建（懒加载）。

class Singleton {constructor() {if (Singleton.instance) {return Singleton.instance;}Singleton.instance = this;}showMessage() {console.log("This is a singleton!");}
}const instance1 = new Singleton();
const instance2 = new Singleton();console.log(instance1 === instance2); // true

2、工厂模式（Factory Pattern）

特点

通过一个工厂方法创建对象，而不是直接使用 new 操作符。
子类可以通过工厂方法决定实例化的具体类。

适用场景

创建复杂对象时，希望隐藏其创建细节。
需要在运行时动态确定创建哪种对象。

class Product {constructor(name) {this.name = name;}
}class ProductFactory {static createProduct(type) {if (type === "A") {return new Product("Product A");} else if (type === "B") {return new Product("Product B");} else {throw new Error("Unknown product type");}}
}const productA = ProductFactory.createProduct("A");
console.log(productA.name); // Product A

3、观察者模式（Observer Pattern）

特点

定义对象间的一对多依赖关系。
当一个对象的状态改变时，所有依赖者都会收到通知并更新。

适用场景

事件驱动的系统，例如 UI 事件监听。
多个模块需要同步某个数据的变化。

class Subject {constructor() {this.observers = [];}addObserver(observer) {this.observers.push(observer);}notifyObservers(data) {this.observers.forEach((observer) => observer.update(data));}
}class Observer {update(data) {console.log("Observer received:", data);}
}const subject = new Subject();
const observer1 = new Observer();
const observer2 = new Observer();subject.addObserver(observer1);
subject.addObserver(observer2);subject.notifyObservers("Hello Observers!"); // All observers will log the message

4、策略模式（Strategy Pattern）

特点

定义一系列算法，将它们封装成独立的策略类，并使它们可以互换。
避免了使用大量 if-else 或 switch 语句。

适用场景

动态选择算法，或者让算法的行为对客户端透明。

class StrategyA {execute() {console.log("Strategy A executed");}
}class StrategyB {execute() {console.log("Strategy B executed");}
}class Context {setStrategy(strategy) {this.strategy = strategy;}executeStrategy() {this.strategy.execute();}
}const context = new Context();
context.setStrategy(new StrategyA());
context.executeStrategy(); // Strategy A executedcontext.setStrategy(new StrategyB());
context.executeStrategy(); // Strategy B executed

5、代理模式（Proxy Pattern）

特点

为某个对象提供代理，以控制对该对象的访问。
可以用作缓存、权限控制、延迟加载等。

适用场景

需要在访问对象前后执行额外的操作。

class RealSubject {request() {console.log("RealSubject: Handling request.");}
}class Proxy {constructor(realSubject) {this.realSubject = realSubject;}request() {console.log("Proxy: Logging access.");this.realSubject.request();}
}const realSubject = new RealSubject();
const proxy = new Proxy(realSubject);
proxy.request();
// Proxy: Logging access.
// RealSubject: Handling request.

6、装饰器模式（Decorator Pattern）

特点

动态地给对象添加新功能，而不影响其他对象。

适用场景

需要扩展类的功能，而不需要创建子类。

class Coffee {cost() {return 5;}
}class MilkDecorator {constructor(coffee) {this.coffee = coffee;}cost() {return this.coffee.cost() + 2;}
}class SugarDecorator {constructor(coffee) {this.coffee = coffee;}cost() {return this.coffee.cost() + 1;}
}let coffee = new Coffee();
coffee = new MilkDecorator(coffee);
coffee = new SugarDecorator(coffee);console.log(coffee.cost()); // 8