关于设计模式:设计模式

“ 设计模式 ” (Design Patterns) 是软件工程中的一种解决方案的通用办法。它们提供了一种可重复使用的办法来解决软件开发中的常见问题。设计模式通常是由经验丰富的软件工程师提出的，并在大量我的项目中进行了实践证明。

一共有 23 种常见的设计模式，它们分为三个类别：创立型模式、结构型模式和行为型模式。

1. 创立型模式：

   • 单例模式 (Singleton)
   • 工厂模式 (Factory)
   • 形象工厂模式 (Abstract Factory)
   • 建造者模式 (Builder)
   • 原型模式 (Prototype)

2. 结构型模式：

   • 适配器模式 (Adapter)
   • 桥接模式 (Bridge)
   • 组合模式 (Composite)
   • 装璜器模式 (Decorator)
   • 外观模式 (Facade)
   • 享元模式 (Flyweight)
   • 代理模式 (Proxy)

3. 结构型模式：

   • 责任链模式 (Chain of Responsibility)
   • 命令模式 (Command)
   • 解释器模式 (Interpreter)
   • 迭代器模式 (Iterator)
   • 中介者模式 (Mediator)
   • 备忘录模式 (Memento)
   • 观察者模式 (Observer)
   • 状态模式 (State)
   • 策略模式 (Strategy)
   • 模板办法模式 (Template Method)
   • 访问者模式 (Visitor)

单例模式 (Singleton)

单例模式是一种罕用的设计模式，该模式确保一个类只有一个实例，并且提供了一个全局的拜访点来拜访该实例。

实现单例模式的办法：

// 单例模式的外围代码
class Singleton {
    static instance = null;

    static getInstance() {if (Singleton.instance === null) {Singleton.instance = new Singleton();
        }
        return Singleton.instance;
    }
}

// 应用单例模式
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();
console.log(instance1 === instance2); // 输入：true

理论场景代码示例：

一个利用只须要一个数据库连贯，那么单例模式就能够确保该连贯惟一。

class Database {
    static instance = null;

    static getInstance() {if (Database.instance === null) {Database.instance = new Database();
        }
        return Database.instance;
    }
}

const db1 = Database.getInstance();
const db2 = Database.getInstance();
console.log(db1 === db2); // 输入：true

工厂模式 (Factory)

工厂模式是一种创立型设计模式，它通过工厂办法创建对象。工厂模式将对象的创立与客户代码隔离，把对象的创立委托给工厂类。

工厂模式的几种罕用实现办法：

简略工厂模式：一个工厂类创立所有类型的对象。

class SimpleFactory {static createProduct(type) {if (type === 'A') {return new ProductA();
        } else if (type === 'B') {return new ProductB();
        }
        return null;
    }
}

工厂办法模式：每个子类对应一个工厂类，该工厂类只创立该子类的对象。

class FactoryMethod {createProduct() {throw new Error('This method must be overridden');
    }
}

class ProductAFactory extends FactoryMethod {createProduct() {return new ProductA();
    }
}

class ProductBFactory extends FactoryMethod {createProduct() {return new ProductB();
    }
}

形象工厂模式：创立多个产品的工厂类。

class AbstractFactory {createProductA() {throw new Error('This method must be overridden');
    }

    createProductB() {throw new Error('This method must be overridden');
    }
}

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

    createProductB() {return new ProductB1();
    }
}

class ConcreteFactory2 extends AbstractFactory {createProductA() {return new ProductA2();
    }

    createProductB() {return new ProductB2();
    }
}

形象工厂模式 (Abstract Factory)

形象工厂模式是一种创立型设计模式，通过形象工厂类创立相干的多个对象。它是工厂办法模式的降级版本，把对象的创立委托给多个工厂子类。

与工厂办法模式的不同之处在于，工厂办法模式只有一个工厂类，而形象工厂模式则有多个工厂类。形象工厂模式容许客户端应用形象工厂来按需创建对象，而不须要关怀对象的具体类型。

代码实现：

// 形象工厂
class AbstractFactory {createProductA() {throw new Error("This method must be overridden");
  }

  createProductB() {throw new Error("This method must be overridden");
  }
}

// 具体工厂 1
class ConcreteFactory1 extends AbstractFactory {createProductA() {return new ProductA1();
  }

  createProductB() {return new ProductB1();
  }
}

// 具体工厂 2
class ConcreteFactory2 extends AbstractFactory {createProductA() {return new ProductA2();
  }

  createProductB() {return new ProductB2();
  }
}

// 形象产品 A
class AbstractProductA {operationA() {throw new Error("This method must be overridden");
  }
}

// 具体产品 A1
class ProductA1 extends AbstractProductA {operationA() {console.log("ProductA1 operationA");
  }
}

// 具体产品 A2
class ProductA2 extends AbstractProductA {operationA() {console.log("ProductA2 operationA");
  }
}

// 形象产品 B
class AbstractProductB {operationB() {throw new Error("This method must be overridden");
  }
}

// 具体产品 B1
class ProductB1 extends AbstractProductB {operationB() {console.log("ProductB1 operationB");
  }
}

// 具体产品 B2
class ProductB2 extends AbstractProduct2 {operationB() {console.log("ProductB2 operationB");
  }
}