JavaScript 设计模式大全：代码实现

设计模式是解决特定问题的通用解决方案，在 JavaScript 开发中也起着重要的作用。本文将介绍一系列常用的设计模式，并提供每个模式的代码实现示例，帮助读者更好地理解和应用这些模式。

一、单例模式（Singleton Pattern）

简介： 确保一个类只有一个实例，并提供一个全局访问点。

代码实现：

class Singleton {
  constructor() {
    if (!Singleton.instance) {
      Singleton.instance = this;
    }
    return Singleton.instance;
  }
}

const instance1 = new Singleton();
const instance2 = new Singleton();

console.log(instance1 === instance2); // 输出 true

二、工厂模式（Factory Pattern）

简介： 定义一个用于创建对象的接口，但让子类决定实例化哪个类。

代码实现：

class ShapeFactory {
  createShape(type) {
    switch (type) {
      case 'circle':
        return new Circle();
      case 'rectangle':
        return new Rectangle();
      case 'triangle':
        return new Triangle();
      default:
        throw new Error('Invalid shape type');
    }
  }
}

三、观察者模式（Observer Pattern）

简介： 定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知并自动更新。

代码实现：

class Subject {
  constructor() {
    this.observers = [];
  }

  addObserver(observer) {
    this.observers.push(observer);
  }

  notify() {
    this.observers.forEach(observer => observer.update());
  }
}

class Observer {
  constructor(name) {
    this.name = name;
  }

  update() {
    console.log(`${this.name} received notification and updated.`);
  }
}

四、适配器模式（Adapter Pattern）

简介： 适配器模式用于将一个接口转换成客户希望的另一个接口。它通常用于解决接口不兼容的问题。

代码实现：

class OldCalculator {
  constructor() {
    this.operations = function(term1, term2, operation) {
      switch (operation) {
        case 'add':
          return term1 + term2;
        case 'subtract':
          return term1 - term2;
        default:
          return NaN;
      }
    };
  }
}

class NewCalculator {
  constructor() {
    this.add = function(term1, term2) {
      return term1 + term2;
    };
    this.subtract = function(term1, term2) {
      return term1 - term2;
    };
  }
}

class CalculatorAdapter {
  constructor() {
    const newCalculator = new NewCalculator();

    this.operations = function(term1, term2, operation) {
      switch (operation) {
        case 'add':
          return newCalculator.add(term1, term2);
        case 'subtract':
          return newCalculator.subtract(term1, term2);
        default:
          return NaN;
      }
    };
  }
}

const adapter = new CalculatorAdapter();
console.log(adapter.operations(5, 3, 'add')); // 输出 8
console.log(adapter.operations(5, 3, 'subtract')); // 输出 2

五、装饰器模式（Decorator Pattern）

简介： 装饰器模式允许向对象动态添加新功能。它是通过将对象包装在另一个对象中来实现的，从而使得每个装饰器对象都只关注于添加自己的特定功能。

代码实现：

class Coffee {
  cost() {
    return 10;
  }
}

class MilkDecorator {
  constructor(coffee) {
    this.coffee = coffee;
  }

  cost() {
    return this.coffee.cost() + 5;
  }
}

class SugarDecorator {
  constructor(coffee) {
    this.coffee = coffee;
  }

  cost() {
    return this.coffee.cost() + 2;
  }
}

const myCoffee = new Coffee();
console.log(myCoffee.cost()); // 输出 10

const milkCoffee = new MilkDecorator(myCoffee);
console.log(milkCoffee.cost()); // 输出 15

const sugarMilkCoffee = new SugarDecorator(milkCoffee);
console.log(sugarMilkCoffee.cost()); // 输出 17

六、策略模式（Strategy Pattern）

简介： 策略模式定义了一系列的算法，并将每个算法封装起来，使它们可以相互替换。这使得算法可以独立于其客户而变化。

代码实现：

class PaymentStrategy {
  pay(amount) {
    throw new Error('This method should be overridden');
  }
}

class CreditCardPayment extends PaymentStrategy