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功能–检测没问题再返回给用户(前提是这个生产车的工厂已经规定有哪些车的类型和车的功能)。
这是我看了视频后学到的,理解但还是比较生疏这种模式。大佬们,有什么需要修改或建议的地方欢迎来评论区逛逛哈。