JavaScript「创建型」设计模式

JavaScript「创建型」设计模式

Tags
单例模式
工厂模式
面向对象编程
CreatedTime
Aug 17, 2022 02:48 AM
Slug
2018-10-23-singleton-pattern
UpdatedTime
Last updated August 17, 2022
创建型模式:创建对象的模式,抽象了实例化的过程

单例模式

什么是单例模式?

单例模式定义:保证一个类仅有一个实例,并提供访问此实例的全局访问点。

单例模式用途

如果一个类负责连接数据库的线程池、日志记录逻辑等等,此时需要单例模式来保证对象不被重复创建,以达到降低开销的目的。

代码实现

需要指明的是,以下实现的单例模式均为“惰性单例”:只有在用户需要的时候才会创建对象实例。

python3 实现

class Singleton: # 将实例作为静态变量 __instance = None @staticmethod def get_instance(): if Singleton.__instance == None: # 如果没有初始化实例,则调用初始化函数 # 为Singleton生成 instance 实例 Singleton() return Singleton.__instance def __init__(self): if Singleton.__instance != None: raise Exception("请通过get_instance()获得实例") else: # 为Singleton生成 instance 实例 Singleton.__instance = self if __name__ == "__main__": s1 = Singleton.get_instance() s2 = Singleton.get_instance() # 查看内存地址是否相同 print(id(s1) == id(s2))

javascript 实现

const Singleton = function() {}; Singleton.getInstance = (function() { // 由于es6没有静态类型,故闭包: 函数外部无法访问 instance let instance = null; return function() { // 检查是否存在实例 if (!instance) { instance = new Singleton(); } return instance; }; })(); let s1 = Singleton.getInstance(); let s2 = Singleton.getInstance(); console.log(s1 === s2);

工厂模式

什么是工厂模式?

工厂方法模式的实质是“定义一个创建对象的接口,但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。”
简单来说:就是把 new 对象的操作包裹一层,对外提供一个可以根据不同参数创建不同对象的函数

工厂模式的优缺点

优点显而易见,可以隐藏原始类,方便之后的代码迁移。调用者只需要记住类的代名词即可。
由于多了层封装,会造成类的数目过多,系统复杂度增加。

ES6 实现

调用者通过向工厂类传递参数,来获取对应的实体。在这个过程中,具体实体类的创建过程,由工厂类全权负责。
/** * 实体类:Dog、Cat */ class Dog { run() { console.log("狗"); } } class Cat { run() { console.log("猫"); } } /** * 工厂类:Animal */ class Animal { constructor(name) { name = name.toLocaleLowerCase(); switch (name) { case "dog": return new Dog(); case "cat": return new Cat(); default: throw TypeError("class name wrong"); } } } /** * 以下是测试代码 */ const cat = new Animal("cat"); cat.run(); const dog = new Animal("dog"); dog.run();

抽象工厂模式

抽象工厂模式就是:围绕一个超级工厂类,创建其他工厂类;再围绕工厂类,创建实体类。
相较于传统的工厂模式,它多出了一个超级工厂类

什么是抽象工厂模式?

抽象工厂模式就是:围绕一个超级工厂类,创建其他工厂类;再围绕工厂类,创建实体类。
相较于传统的工厂模式,它多出了一个超级工厂类
它的优缺点与工厂模式类似,这里不再冗赘它的优缺点,下面直接谈一下实现吧。

如何实现抽象工厂模式?

为了让目标更清晰,就实现下面的示意图:
notion image

准备实体类

按照之前的做法,这里我们实现几个实体类:Cat 和 Dog 一组、Male 和 Female 一组。
class Dog { run() { console.log("狗"); } } class Cat { run() { console.log("猫"); } } /*************************************************/ class Male { run() { console.log("男性"); } } class Female { run() { console.log("女性"); } }

准备工厂类

假设 Cat 和 Dog,属于 Animal 工厂的产品;Male 和 Female 属于 Person 工厂的产品。所以需要实现 2 个工厂类:Animal 和 Person。
由于工厂类上面还有个超级工厂,为了方便工厂类生产实体,工厂类应该提供生产实体的方法接口。
为了更好的约束工厂类的实现,先实现一个抽象工厂类:
class AbstractFactory { getPerson() { throw new Error("子类请实现接口"); } getAnimal() { throw new Error("子类请实现接口"); } }
接下来,Animal 和 Dog 实现抽象工厂类(AbstractFactory):
class PersonFactory extends AbstractFactory { getPerson(person) { person = person.toLocaleLowerCase(); switch (person) { case "male": return new Male(); case "female": return new Female(); default: break; } } getAnimal() { return null; } } class AnimalFactory extends AbstractFactory { getPerson() { return null; } getAnimal(animal) { animal = animal.toLocaleLowerCase(); switch (animal) { case "cat": return new Cat(); case "dog": return new Dog(); default: break; } } }

实现“超级工厂”

超级工厂的实现没什么困难,如下所示:
class Factory { constructor(choice) { choice = choice.toLocaleLowerCase(); switch (choice) { case "person": return new PersonFactory(); case "animal": return new AnimalFactory(); default: break; } } }

看看怎么使用超级工厂

实现了那么多,还是要看用例才能更好理解“超级工厂”的用法和设计理念:
/** * 以下是测试代码 */ // 创建person工厂 const personFactory = new Factory("person"); // 从person工厂中创建 male 和 female 实体 const male = personFactory.getPerson("male"), female = personFactory.getPerson("female"); // 输出测试 male.run(); female.run(); // 创建animal工厂 const animalFactory = new Factory("animal"); // 从animal工厂中创建 dog 和 cat 实体 const dog = animalFactory.getAnimal("dog"), cat = animalFactory.getAnimal("cat"); // 输出测试 dog.run(); cat.run();