JavaScript设计模式---工厂模式

JavaScript设计模式—工厂模式

工厂模式概念一：就是把参数传进去后，经过一系列的处理，然后得到想要的结果。

工厂模式概念二：就是用面向对象的方法，把一些对象封装， 使一些占用空间多的、重复的代码封装起来的一种模式。

看下面代码：

在开头要先插入CommonUtil.js文件，里面包含检测接口的鸭式辩型法，和继承的方法

CommonUtil.js文件

// 这里是公共的Js文件

// 命名空间
var BH={};
  
// 3.鸭式辩型法 (最完美的JavaScript实现接口的方法)
    //鸭式辩型法核心: 一个类实现接口的主要目的:把接口里的方法都实现(检测方法)
    //  优点：完全面向对象 代码也统一了 也解耦了 等...

    // 步骤
    // 一. 定义一个接口类Interface ==> 去实例化N多个接口
    // 接口类需要两个参数吗？
    // 参数1：接口的名称
    //参数2：接受接口所有方法名称的集合(数组 Array)
   BH.Interface=function(name,methods){
    //判断接口的参数个数(判断是不是传进来两个参数，不能多，也不能少) 否则就抛出异常
           if(arguments.length !=2){ //arguments对象 获得函数的实际参数
             throw new Error('this interface interface constructor arguments must be 2 lenght!');
         }
         this.name=name;
         this.methods=[]; //定义一个内置的空函数对象，等待接收methods里的元素(方法名称)
         for(var i=0,len=methods.length;i<len;i++){
              if(typeof methods[i] !== 'string'){  //方法名称必须是字符串
                    throw new Error('the Interface menthod name is error');
              }
              this.methods.push(methods[i]);
         }
    }


      // 三. 检测接口的方法
    // 如果通过不做任何操作 不通过 抛出异常
    // 定义一个ensureImplements 方法：检测接口的方法是否都实现了
    BH.Interface.ensureImplements=function(object){
        // 如果检测方法接收的参数小于 2  参数传递失败  传递的参数是接口的实例对象
        if(arguments.length<2){ //因为必须要有的参数有 至少一个接口
            throw new Error('Interface.ensureImplements methods constructor argumrnts must be > 2 !');
        }
        // 获取接口的实例对象
        for(var i=1,len=arguments.length;i<len;i++){
           var instanceInterface=arguments[i];
          //    判断拿到的参数 是不是接口类 的类型
            if(instanceInterface.constructor !== BH.Interface){
                throw new Error('the arguments construcotr not be Interface Class!');
           }
        //    循环接口实例化的每一个方法
            for(var j=0;j<instanceInterface.methods.length;j++){
               // 用一个临时变量接受每一个方法的名称 （注意是字符串）
                var methodName=instanceInterface.methods[j];
               //object[menthodName] 就是方法 判断方法是否存在 如果它不存在 或者存在但不是一个方法来的 就抛出异常
               if(!object[methodName] || typeof object[methodName] !=='function'){
                   throw new Error('the method name '+ methodName +' is not found');
               }
            }
        }
    }

    //  继承方法
     //    参数：子类，父类
     BH.extend=function (sub,sup){
        //  目的：  实现只继承父类的原型对象
        // 1.创建一个空函数 进行中转
        var F=new Function();
        F.prototype=sup.prototype;  //2.实现空函数的原型对象和父类的原型行对象进行装换
        sub.prototype=new F();  //3.原型继承(这是sub的构造器是F)(实现了sub只继承了sup的原型) 
        sub.prototype.constructor=sub;//4.还原构造器
        // 保存一下父类的原型对象：一方面方便解耦，另一方面方便获得父类的原型对象
        sub.superClass=sup.prototype;//自定义一个子类的静态属性
        //判断父类的原型对象的构造器(加保险)
        if(sup.prototype.constructor == Object.prototype.constructor){
            sup.prototype.constructor=sup;
        }
    }

工厂模式

  // 一。假设有一个卖车的商店  
    //      function CarShop(){};
    //      CarShop.prototype={
    //          constructor:CarShop,
    //          sellCar:function(type){//这里只是买车
    //             // 1.可能有销售人员
    //              var car=CarFactory.createCar(type);  //2.获得顾客要买的类型，调用方法生产出来
    //             // 3.可能还有保险 等相关的售后服务 我们这儿省略
    //              return car;//返回
    //          },

    //      };

    //     // 二。 但是卖车的商店只是买车，不会生产车，所以我们应该把生产车的方法提出来
    //     // 放到生产车的工厂  目的就只是为了生产车
    //     var CarFactory={  //简单单体模式 不能再new实例
    //         createCar:function(type){
    //             var car;
    //             switch(type){  //这是生产车的方法 
    //                  case 'Benz' : car=new Benz();break;
    //                  case 'Bmw'  : car=new Bmw();break;
    //                  case 'Audi' : car=new Audi();break;
    //                  default : 'not buy it!';
    //              }
    //             //  检测接口的方法  判断得到的车是否有start run 的功能
    //             BH.Interface.ensureImplements(car,carInterface);
    //              return car;  //返回
    //         }

    //     };


    //     //  接口类的实现
    //     var carInterface=new BH.Interface(carInterface,['start','run']);
    
    //     //  把公共的方法放到父类里面去(继承)
    //     function BaseCar(){};
    //     BaseCar.prototype={
    //         constructor:BaseCar,
    //         start:function(){alert(this.constructor.name+'...start');},
    //         run:function(){alert(this.constructor.name+'...run');},
    //     };

    //     //  车的类型
    //     function Benz(){};  //把自己特殊的方法在家在自己身上
    //     BH.extend(Benz,BaseCar);  //调用继承的方法实现继承
    //     Benz.prototype.driveBenz=function(){alert('Benz...drive');};
    //     // Benz.prototype.start=function(){alert('Benz...start');};
    //     // Benz.prototype.run=function(){alert('Benz...run');};
     
    //     function Bmw(){};   //记住一定要先继承在添加私有的方法，原型的动态特性
    //     BH.extend(Bmw,BaseCar);  //调用继承的方法实现继承
    //     Bmw.prototype.driveBmw=function(){alert('Bmw...drive');};
    //     // Bmw.prototype.start=function(){alert('Bmw...start');};
    //     // Bmw.prototype.run=function(){alert('Bmw...run');};
    
    //     function Audi(){};
    //     BH.extend(Audi,BaseCar);  //调用继承的方法实现继承
    //     Audi.prototype.driveAudi=function(){alert('Audi...drive');};
    //     // Audi.prototype.start=function(){alert('Audi...start');};
    //     // Audi.prototype.run=function(){alert('Audi...run');};

    //     // 三。 检测
    //    var shop=new CarShop();
    //    var car=shop.sellCar('Benz');
    //    car.start();

    //    var car2=shop.sellCar('Audi');
    //    car2.start();

总结：先有一个卖车的店里面有卖车的方法—通过获得用户买车的类型—调用生产车的工厂里面的方法–判断是否能生产这种车能就生产出来–检测该车是否有正常的start run功能–检测没问题再返回给用户(前提是这个生产车的工厂已经规定有哪些车的类型和车的功能)。
这是我看了视频后学到的，理解但还是比较生疏这种模式。大佬们，有什么需要修改或建议的地方欢迎来评论区逛逛哈。