JavaScript中常见的十五种设计模式

JavaScript中常见的十五种设计模式

在编程过程中，我们经常会遇到一些重复的问题，这些问题往往可以通过使用设计模式来解决，设计模式是一种在特定环境下解决特定问题的通用可重用方案，本文将介绍15种在JavaScript开发中常见的设计模式，帮助你更好地理解和应用这些设计模式。

1、单例模式(Singleton)

单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个全局访问点，在JavaScript中，可以通过以下方式实现单例模式：

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

2、工厂模式(Factory)

工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，在JavaScript中，可以通过以下方式实现工厂模式：

class Product {
  constructor(name) {
    this.name = name;
  }
}
const factory = new function() {
  this.createProduct = function(type) {
    switch (type) {
      case 'A':
        return new Product('A');
      case 'B':
        return new Product('B');
      default:
        throw new Error('Invalid product type');
    }
  };
};

3、抽象工厂模式(Abstract Factory)

抽象工厂模式是一种创建型设计模式，它提供了一种创建一系列相关或相互依赖对象的接口，而不需要指定它们具体的类，在JavaScript中，可以通过以下方式实现抽象工厂模式：

class AbstractFactory {
  createProductA() {}
  createProductB() {}
}
class ConcreteFactory extends AbstractFactory {
  createProductA() { return new ProductA(); }
  createProductB() { return new ProductB(); }
}

4、建造者模式(Builder)

建造者模式是一种创建型设计模式，它可以将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示，在JavaScript中，可以通过以下方式实现建造者模式：

class ProductBuilder {
  addPartA() {}
  addPartB() {}
}
class Director {
  constructor(builder) {}
  construct() {}
}

5、原型链模式(Prototype Chain)

原型链模式是一种结构型设计模式，它允许你继承一个对象的属性和方法，在JavaScript中，对象通过引用其他对象来继承属性和方法：

function Person() {}
Person.prototype.sayHello = function() {};
const person = new Person(); // person.__proto__ === Person.prototype; // true

6、适配器模式(Adapter)

适配器模式是一种结构型设计模式，它将一个类的接口转换成客户希望的另一个接口，在JavaScript中，可以通过以下方式实现适配器模式：

class TargetInterface {}
class SourceInterface {}
class TargetAdapter extends TargetInterface implements SourceInterface {} // TargetAdapter is an adapter between TargetInterface and SourceInterface. It implements both interfaces. It can be used to adapt a source object to work with a target interface or vice versa. The client of the program does not need to be aware that it is using an adapter because the methods and properties of the adapter are implemented in terms of those of the target interface. The only difference is that the methods and properties of the adapter are wrapped in a try-catch block that handles any exceptions thrown by the target methods. This allows the client to use the adapter as if it were a regular object without needing to know anything about the internals of the adapter." />', // TargetAdapter is an adapter between TargetInterface and SourceInterface. It implements both interfaces. It can be used to adapt a source object to work with a target interface or vice versa. The client of the program does not need to be aware that it is using an adapter because the methods and properties of the adapter are implemented in terms of those of the target interface. The only difference is that the methods and properties of the adapter are wrapped in a try-catch block that handles any exceptions thrown by the target methods. This allows the client to use the adapter as if it were a regular object without needing to know anything about the internals of the adapter." />', // TargetAdapter is an adapter between TargetInterface and SourceInterface. It implements both interfaces. It can be used to adapt a source object to work with a target interface or vice versa. The client of the program does not need to be aware that it is using an adapter because the methods and properties of the adapter are implemented in terms of those of the target interface. The only difference is that the methods and properties of the adapter are wrapped in a try-catch block that handles any exceptions thrown by the target methods. This allows the client to use the adapter as if it were a regular object without needing to know anything about the internals of the adapter." />', // TargetAdapter is an adapter between TargetInterface and SourceInterface. It implements both interfaces. It can be used to adapt a source object to work with a target interface or vice versa. The client of the program does not need to be aware that it is using an adapter because the methods and properties of the adapter are implemented in terms of those of the target interface. The only difference is that the methods and properties of the adapter are wrapped in a try-catch block that handles any exceptions thrown by the target methods. This allows the client to use the adapter as if it were a regular object without needing to know anything about the internals of the adapter." />', // TargetAdapter is an adapter between TargetInterface and SourceInterface. It implements both interfaces. It can be used to adapt a source object to work with a target interface or vice versa. The client of the program does not need to be aware that it is using an adapter because the methods and properties of the adapter are implemented in terms of those of the target interface. The only difference is that the methods and properties of the adapter are wrapped in a try-catch block that handles any exceptions thrown by the target methods. This allows the client to use the adapter as if it were a regular object without needing to know anything about the internals of the adapter." />', // TargetAdapter is an adapter between TargetInterface and SourceInterface. It implements both interfaces. It can be used to adapt a source object to work with a target interface or vice versa. The client of the program does not need to be aware that it is using an adapter because the methods and properties of the adapter are implemented in terms of those of the target interface. The only difference is that