Node.js 开发人员应该掌握的 13个 面向对象设计模式

面向对象设计模式在软件开发中非常重要，尤其是在 Node.js 开发中。以下是 13 个面向对象设计模式，Node.js 开发人员应该熟悉它们：

1. 单例模式 (Singleton Pattern)

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

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

2. 工厂模式 (Factory Pattern)

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

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

class ProductFactory {
  createProduct(name) {
    return new Product(name);
  }
}

3. 抽象工厂模式 (Abstract Factory Pattern)

提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

class AbstractFactory {
  createProductA() {}
  createProductB() {}
}

class ConcreteFactory1 extends AbstractFactory {
  createProductA() { return new ProductA1(); }
  createProductB() { return new ProductB1(); }
}

4. 建造者模式 (Builder Pattern)

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

class Product {
  constructor(parts) {
    this.parts = parts;
  }
}

class Builder {
  buildPartA() {}
  buildPartB() {}
  getResult() { return new Product([this.partA, this.partB]); }
}

5. 原型模式 (Prototype Pattern)

通过复制现有对象来创建新对象，而不是通过实例化。

const prototype = {
  clone() {
    return Object.assign(Object.create(this), this);
  }
};

const instance = Object.assign(Object.create(prototype), { a: 1 });

6. 适配器模式 (Adapter Pattern)

允许不兼容的接口之间进行通信。

class Target {
  request() {}
}

class Adaptee {
  specificRequest() {}
}

class Adapter extends Target {
  constructor(adaptee) {
    super();
    this.adaptee = adaptee;
  }
  request() {
    return this.adaptee.specificRequest();
  }
}

7. 装饰器模式 (Decorator Pattern)

动态地给对象添加一些额外的职责。

function decorator(target, key, descriptor) {
  const originalMethod = descriptor.value;
  descriptor.value = function(...args) {
    console.log('Before method call');
    const result = originalMethod.apply(this, args);
    console.log('After method call');
    return result;
  };
  return descriptor;
}

class Example {
  @decorator
  method() {}
}

8. 代理模式 (Proxy Pattern)

为其他对象提供一个代理以控制对这个对象的访问。

const target = {
  name: 'target'
};

const handler = {
  get: function(target, prop, receiver) {
    console.log(`Getting ${prop}`);
    return Reflect.get(...arguments);
  }
};

const proxy = new Proxy(target, handler);

9. 观察者模式 (Observer Pattern)

定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。

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(data);
  }
}

10. 策略模式 (Strategy Pattern)

定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。

const strategies = {
  add(a, b) { return a + b; },
  subtract(a, b) { return a - b; }
};

function executeStrategy(strategy, a, b) {
  return strategies[strategy](a, b);
}

11. 命令模式 (Command Pattern)

将请求封装成对象，从而使你可以用不同的请求对客户进行参数化。

class Command {
  constructor(receiver, action) {
    this.receiver = receiver;
    this.action = action;
  }
  execute() {
    this.receiver[this.action]();
  }
}

const receiver = {
  action1() { console.log('Action 1'); },
  action2() { console.log('Action 2'); }
};

const command1 = new Command(receiver, 'action1');
command1.execute();

12. 外观模式 (Facade Pattern)

为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得子系统更加容易使用。

class Subsystem1 {
  operation1() {}
}

class Subsystem2 {
  operation2() {}
}

class Facade {
  constructor() {
    this.subsystem1 = new Subsystem1();
    this.subsystem2 = new Subsystem2();
  }
  operation() {
    this.subsystem1.operation1();
    this.subsystem2.operation2();
  }
}

13. 迭代器模式 (Iterator Pattern)

提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露其内部的表示。

class Aggregate {
  constructor() {
    this.items = [];
  }
  add(item) {
    this.items.push(item);
  }
  createIterator() {
    let index = 0;
    return {
      hasNext: () => index < this.items.length,
      next: () => this.items[index++]
    };
  }
}

掌握这些设计模式将有助于提高代码的可维护性、可扩展性和可重用性。在实际开发中，应根据具体需求选择合适的设计模式。