javascript设计模式-（八）

组合模式

• 组合模式将对象组合成树形结构，以表示“部分-整体”的层次结构。 除了用来表示树形结 构之外，组合模式的另一个好处是通过对象的多态性表现，使得用户对单个对象和组合对象的使 用具有一致性，下面分别说明。
• 表示树形结构。通过回顾上面的例子，我们很容易找到组合模式的一个优点：提供了一 种遍历树形结构的方案，通过调用组合对象的 execute 方法，程序会递归调用组合对象下 面的叶对象的 execute 方法，所以我们的万能遥控器只需要一次操作，便能依次完成关门、 打开电脑、登录 QQ这几件事情。组合模式可以非常方便地描述对象部分-整体层次结构。
• 利用对象多态性统一对待组合对象和单个对象。利用对象的多态性表现，可以使客户端 忽略组合对象和单个对象的不同。在组合模式中，客户将统一地使用组合结构中的所有 对象，而不需要关心它究竟是组合对象还是单个对象。
• 这在实际开发中会给客户带来相当大的便利性，当我们往万能遥控器里面添加一个命令的时 候，并不关心这个命令是宏命令还是普通子命令

组合模式例子----扫描文件夹

    /*文件夹对象*/

    var Folder=function(name){
        this.name=name;
        this.files=[];
    };

    Folder.prototype.add=function(file){
        this.files.push(file);
    };

    Folder.prototype.scan=function(){
        console.log("开始扫描文件夹："+this.name);
        for(var i=0,file,files=this.files;file=files[i++];){
            file.scan();
        }
    }

    /*文件对象*/

    var File=function(name){
        this.name=name;
    };

    File.prototype.add=function(){
        throw Error("文件不能添加文件");
    };

    File.prototype.scan=function(){
        console.log("开始扫描文件："+this.name);
    }

    /*创建一个文件树*/

    var folder=new Folder("学习资料");
    var folder1=new Folder("javascript");
    var folder2=new Folder("jQuery");

    var file=new File("js开发实践");
    var file1=new File("js入门到放弃");
    var file2=new File("jQuery 源码解析");

    folder.add(file);
    folder1.add(file1);
    folder2.add(file2);

    folder.add(folder1);
    folder.add(folder2);

    console.log(folder);

    folder.scan();

模版方法模式

模板方法模式是一种只需使用继承就可以实现的非常简单的模式。

模板方法模式由两部分结构组成，第一部分是抽象父类，第二部分是具体的实现子类。通常 在抽象父类中封装了子类的算法框架，包括实现一些公共方法以及封装子类中所有方法的执行顺 序。子类通过继承这个抽象类，也继承了整个算法结构，并且可以选择重写父类的方法

Coffee or Tea

        // 泡一杯饮料的抽象过程
        var Beverage=function(){

        };

        Beverage.prototype.boilWater=function(){
            console.log("把水煮开");
        };

        Beverage.prototype.brew=function(){
            throw Error("这个方法需要被实现");
        };

        Beverage.prototype.pourInCup=function(){
            throw Error("这个方法需要被子类实现");
        };

        Beverage.prototype.addCondiments=function(){
            throw Error("这个方法需要被子类实现");
        };

        Beverage.prototype.init=function(){

            try{
                this.boilWater();
                this.brew();
                this.pourInCup();
                this.addCondiments();

            }catch(e){
                throw e;
                console.log(this.constructor.name+"");
            }           
        };

        // 泡一杯咖啡
        var Coffee=function(){

        };

        Coffee.prototype=new Beverage();

        Coffee.prototype.brew=function(){
            console.log("用沸水冲泡咖啡");
        };

        Coffee.prototype.pourInCup=function(){
            console.log("把咖啡倒进杯子");
        };

        Coffee.prototype.addCondiments=function(){
            console.log("加糖和牛奶");
        };

        var coffee=new Coffee();
        coffee.init();

        console.log("  ");
        console.log("  ");
        console.log("  ");

        var Tea = function() {};
        Tea.prototype = new Beverage();
        Tea.prototype.brew = function() {
            console.log('用沸水浸泡茶叶');
        };
        Tea.prototype.pourInCup = function() {
            console.log('把茶倒进杯子');
        };
        Tea.prototype.addCondiments = function() {
            console.log('加柠檬');
        };
        var tea = new Tea();
        tea.init();

享元模式

享元（flyweight）模式是一种用于性能优化的模式，“fly”在这里是苍蝇的意思，意为"蝇量级"。享元模式的核心是运用共享技术来有效支持大量细粒度的对象。

如果系统中因为创建了大量类似的对象而导致内存占用过高，享元模式就非常有用了。在 JavaScript 中，浏览器特别是移动端的浏览器分配的内存并不算多，如何节省内存就成了一件非 常有意义的事情。

享元模式是为解决性能问题而生的模式，这跟大部分模式的诞生原因都不一样。在一个存在 大量相似对象的系统中，享元模式可以很好地解决大量对象带来的性能问题。

职责链模式

职责链模式的定义是：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间 的耦合关系，将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

职责链模式的名字非常形象，一系列可能会处理请求的对象被连接成一条链，请求在这些对 象之间依次传递，直到遇到一个可以处理它的对象，我们把这些对象称为链中的节点。

转载于:https://www.cnblogs.com/hlere/p/6748768.html