有哪些开发者模式？

news2024/12/26 9:56:51

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 executed

context.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