听飞狐聊JavaScript设计模式系列07

360 查看

本回内容介绍

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

1. 简单工厂

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

// 用户类
function User(){};

// 用户工厂模式
User.prototype = {
    // 还原构造器,指向User
    constructor: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

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

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

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


注:此系飞狐原创,转载请注明出处


2018 - 知识虫 - 我的知识库 渝ICP备16002641号-2

渝公网安备 50010702501581号