js (七) 设计模式

单例模式

 //单例模式
      class Storage {
        //静态方法
        //Storage.Instance 静态属性
        static GetInstance() {
          if (!Storage.Instance) {
            console.log("等于空")
            Storage.Instance = new Storage();
          }
          return Storage.Instance;
        }
        GetItem = function (key) {
          return localStorage.getItem(key);
        };

        SetItem = function (key, val) {
          localStorage.setItem(key, val);
        };
      }

      let storage = Storage.GetInstance();
      let storage1 = Storage.GetInstance();
      let storage2 = Storage.GetInstance();

      storage.SetItem("name", "xxx");
      console.log("storage.GetItem('name')", storage.GetItem("name"));

 

简单工厂

 class Car {
        constructor(name) {
          this.name = name;
        }
        Drive = function () {
          console.log(this.name + "在行驶");
        };
      }
      //奥迪车
      class Audi extends Car {
        constructor(name) {
          super(name);
        }
      }
      //宝马车
      class BMW extends Car {
        constructor(name) {
          super(name);
        }
      }

      //车型
      class CarType {
        static Audi = "奥迪";
        static BMW = "宝马";
      }
      //汽车工厂
      class Factory {
        static GetInstance() {
          if (!Factory.Instance) {
            console.log("factory 为空");
            Factory.Instance = new Factory();
          }
          return Factory.Instance;
        }
        GetCar(type, name) {
          switch (type) {
            case "BMW":
              return new BMW(name);
            case "Audi":
              return new Audi(name);
            default:
              return new Car(name);
          }
        }
      }
      let car1 = Factory.GetInstance();
      let car = Factory.GetInstance();
      Factory.GetInstance().GetCar(CarType.Audi, "奥迪汽车").Drive();
      Factory.GetInstance().GetCar(CarType.BMW, "宝马汽车").Drive();

抽象工厂

 //汽车父类
      class Car {
        constructor(name) {
          this.name = name;
        }
        Drive = function () {
          console.log(this.name + "在行驶");
        };
      }
      //奥迪车
      class Audi extends Car {
        constructor(name) {
          super(name);
        }
      }
      //宝马车
      class BMW extends Car {
        constructor(name) {
          super(name);
        }
      }
      //工厂类型
      class FactoryType {
        static AudiFactory = "AudiFactory";
        static BMWFFactory = "BMWFactory";
      }
      //奥迪工厂
      class AudiFactory {
        static GetInstance() {
          if (!AudiFactory.Instance) {
            AudiFactory.Instance = new AudiFactory();
          }
          return AudiFactory.Instance;
        }
        CreateCar(name) {
          return new Audi(name);
        }
      }
      //宝马工厂
      class BMWFactory {
        static GetInstance() {
          if (!BMWFactory.Instance) {
            BMWFactory.Instance = new BMWFactory();
          }
          return BMWFactory.Instance;
        }
        CreateCar(name) {
          return new BMW(name);
        }
      }

      //抽象工厂
      class AbstractFactory {
        static GetInstance() {
          if (!AbstractFactory.Instance) {
            AbstractFactory.Instance = new AbstractFactory();
          }
          return AbstractFactory.Instance;
        }
        GetFactory(factoryType) {
          switch (factoryType) {
            case FactoryType.AudiFactory:
              return AudiFactory.GetInstance();
            case FactoryType.BMWFFactory:
              return BMWFactory.GetInstance();
            default:
              break;
          }
        }
      }

      AbstractFactory.GetInstance()
        .GetFactory(FactoryType.AudiFactory)
        .CreateCar("奥迪汽车")
        .Drive();

        AbstractFactory.GetInstance()
        .GetFactory(FactoryType.BMWFFactory)
        .CreateCar("宝马汽车")
        .Drive();