本回内容介绍

上一回聊到JS单例模式(singleton)，做了一道题，内容不多，比较容易理解。
介一回嘞，聊聊工厂模式，之前聊到过工厂模式，这回聊深入点儿，可能会比较抽象，不过好在实际开发中使用还算广泛，理解起来会比较容易，开始咯：

1. 简单工厂

比如我们创建一个会员系统，有会员和管理员两种角色，每种角色有登录，注销的功能，
这里需要引入之前讲过的接口类，如下：

// 用户类
function User(){};// 用户工厂模式
User.prototype = {// 还原构造器，指向Userconstructor:User,// 创建用户的方法，传入的type是用户类型createUser:function(type){// 这里建一个变量，用于返回实例var user;// 判断传入的用户类型，返回该类型的实例switch(type){case 'Member':user = new Member();break;case 'Admin' :user = new Admin();break;};// 这里之前讲过的，检测接口Interface.ensureImplements(user,UserInterface)return user;}
}// 创建一个用户接口，而且必须实现该接口的login，logout两个方法
var UserInterface = new Interface('UserInterface',['login','logout']);// 会员类，包括实现的接口方法
function Member(){}
Member.prototype.login = function(){alert('会员登录');}
Member.prototype.logout = function(){alert('会员注销');}// 管理员类，包括实现的接口方法
function Admin(){}
Admin.prototype.login = function(){alert('管理员登录');}
Admin.prototype.logout = function(){alert('管理员注销');}// new一个用户工厂
var o = new User();
// 创建一个管理员
var a = o.createUser("Admin");
// 调用login方法
a.login();// 下面一堆是会员的实现，不用多说了吧
var o2 = new User();
var m = o.createUser("Member");
m.logout();

这就是一个简单工厂模式实现了，应该很多盆友已经看出来了，同样的方法要实现两次，好像有点冗余了吧，那么就可以用到之前的继承了，改吧改吧，帅狐show time：

2. 简单工厂之解耦

这里要用到之前写的继承类了，写一个用户基类，还要考虑到每个用户和管理员分别有不同的权限，那么我们可以再做一次工厂解耦，细化粒度，如下：

function User(){};User.prototype = {constructor:User,// 给用户配置权限,type是用户类型assignRole:function(type){// 创建用户，这里还可以做很多扩展，这里先留...var user = UserFactory.createUser(type);return user;}
}// 创建用户的工厂(还记的上一回的单例模式吗，这也是个单例模式哟)
var UserFactory = {// 这里为了解耦，跟上面的代码对比一下，换了个位置createUser:function(type){var user;switch(type){case 'Member':user = new Member();break;case 'Admin' :user = new Admin();break;};Interface.ensureImplements(user,UserInterface)return user;}
}var UserInterface = new Interface('UserInterface',['login','logout']);
// User的基类，如果有疑惑，看看之前讲的继承
function BaseUser(){};
BaseUser.prototype = {constructor:BaseUser,login:function(){alert(this.constructor.name + ' 登录');},logout:function(){alert(this.constructor.name + ' 注销');}
}
// 用户类，继承基类，这样就有了两个方法
function Member(){}
extend(Member,BaseUser);// 管理员类，这样就避免了重复创建的冗余
function Admin(){}
extend(Admin,BaseUser);// 这里没什么好说的，实例测试
var o = new User();
var a = o.assignRole("Admin");
a.login();var o2 = new User();
var m = o.assignRole("Member");
m.logout();

这个例子稍微开始有点复杂了，结合了之前聊的接口，继承，单例等，在配置权限的地方其实还可以做很多扩展，比如:
有会员有不同等级的会员，管理有不同等级的管理员，不同的级别存在不同的方法，要做到这样的话，我们可以通过抽象类，让每个类覆盖方法，动态的创建工厂，来吧，继续帅狐show time：

3. 简单工厂之抽象类

不同的用户组有不同的角色，不同的角色拥有不同的权限，如下：

function User(){};
User.prototype = {constructor:User,// 这里是个抽象方法，每个类可以根据不同的需求来重载assignRole:function(type){// 调用自身的抽象方法，意义是在无重载的时候执行this.abs(type);},// 这里是在无重载的时候执行abs:function(){throw new Error('the abstract class can override the virtual method with an abstract method.');}
};// 单独定义Member组
function MemberGroup(){}
extend(MemberGroup,User);
MemberGroup.prototype = {constructor:MemberGroup,// 分配权限方法，根据传入的角色来创建不同的实例assignRole:function(type){var role;// 这里定义两个角色，会员和高级会员var group = ['Member','SeniorMember'];// indexOf眼熟吧，第一回的时候聊过的ES5的新玩意if(group.indexOf(type)>-1){// 调用用户工厂的创建用户方法role = UserFactory.createUser(type);}else{alert('无该'+type+'角色!');}return role;}
}// 跟上面一样，这里定义Admin
function AdminGroup(){}
extend(AdminGroup,User);
AdminGroup.prototype = {constructor:AdminGroup,assignRole:function(type){var role;// 这里定义两个角色，管理员和高级管理员var group = ['Admin','SeniorAdmin'];if(group.indexOf(type)>-1){role = UserFactory.createUser(type);}else{alert('无该'+type+'角色!');}return role;}
}// 创建用户的工厂(跟上一个例子一样，只是这里是动态创建工厂)
var UserFactory = {createUser:function(type){// eval()直接执行var user = eval('new '+type+'()');Interface.ensureImplements(user,UserInterface)return user;}
}var UserInterface = new Interface('UserInterface',['login','logout']);
// User的基类，如果有疑惑，看看之前讲的继承
function BaseUser(){};
BaseUser.prototype = {constructor:BaseUser,login:function(){alert(this.constructor.name + ' 登录');},logout:function(){alert(this.constructor.name + ' 注销');}
}
// 会员类，继承基类，这样就有了两个方法
function Member(){}
extend(Member,BaseUser);// 高级会员类，有自己特有的高级方法
function SeniorMember(){}
extend(SeniorMember,BaseUser);
SeniorMember.prototype.seniorM = function(){alert('高级会员的权限')};// 管理员类，这样就避免了重复创建的冗余
function Admin(){}
extend(Admin,BaseUser);// 高级管理员类，有自己特有的高级方法
function SeniorAdmin(){}
extend(SeniorAdmin,BaseUser);
SeniorAdmin.prototype.seniorA = function(){alert('高级管理员的权限')};// 这里其实可以回忆一下装饰者模式，把高级管理员的实例做一次包装
var obj = new SeniorAdmin();
// 超级管理员类，装饰高级管理员的实例
function SuperAdmin(obj){}
SuperAdmin.prototype.superA = function(){obj.seniorA();alert('再弹一个窗，特效，特效，加特效！因为我是超级管理员！哟呼~~');
};// 这里没什么好说的，实例测试
var o = new MemberGroup();
var a = o.assignRole("SeniorMember");
a.seniorM();var o2 = new AdminGroup();
var m = o2.assignRole("SeniorAdmin");
m.seniorA();var o3 = new SuperAdmin(obj);
o3.superA();

这个例子有点略复杂，在上一个例子的基础上做了抽象类，还复习了装饰者模式，如果感觉晕菜，可以跳过。
这里其实还可以进一步优化，达到高聚类低耦合，这里工厂模式就告一段落了。

装个逼先。今天看优酷放出了新版嘻哈四重奏，一看没有了原版人马，就算是笑点也笑不起来了，算了换一个剧看，啊呃~~

这一回聊的内容比较绕脑袋，反正感觉晕菜的话就启动囫囵吞枣模式，想不通的先停下，以后再回过来看或许就恍然大悟，
下面的内容，跟上一回一样，就一道题好了。

题目：快速排序

这个快速排序比较基础，网上很多，这里我就把注释写清楚一点，方便大家理解：

var arr = [12,5,36,6,22,66];
// 快速排序
function quickSort(arr){// 判断数组长度，只有小等于1的时候返回if(arr.length<=1){return arr;}// 向下取整，也就是取一半的长度var num = Math.floor(arr.length/2);// 取中间的那个数var numValue = arr.splice(num,1);// 定义两个数组做容器var left = [];var right = [];// 循环数组for(var i=0;i<arr.length;i++){// 当小于中间数的时候，放到left数组，大于中间数则放到right数组if(arr[i]<numValue){left.push(arr[i]);}else{right.push(arr[i]);}}// 递归调用，再将left数组，中间数还有right数组合并成一个新数组，然后返回这个新数组return quickSort(left).concat([numValue],quickSort(right));
};
alert(quickSort(arr));  // 5,6,12,22,36,66

网上找的例子，注释写的还算清楚吧，难度不大，跟上一回一样，当娱乐消遣。

这一回，主要聊了工厂模式，并且将前面的内容融合了进去，复习了继承，接口，单例模式，装饰者模式，涉及了一些简单的业务逻辑，对于刚接触面向对象，设计模式的童鞋稍微有点难度~~
下一回，就聊用的比较频繁的一个设计模式，门面模式。

客观看完点个赞，推荐推荐呗，嘿嘿~~

注：此系飞狐原创，转载请注明出处