分类

编程语言按照数据类型大体可以分为两类一类是静态类型语言另一类是动态类型语言。静态类型语言在编译时便已确定变量的类型，而动态类型语言的变量类型要到程序运行的时候，待变量被赋予某个值之后，才会具有某种类型。

一些概念

多态

同一操作作用于不同的对象上面，可以产生不同的解释和不同的执行结果。

var makeSound = function( animal ){ 
    if ( animal instanceof Duck ){ 
        console.log( '嘎嘎嘎' ); 
    }else if ( animal instanceof Chicken ){ 
        console.log( '咯咯咯' ); 
    } 
}; 
var Duck = function(){}; 
var Chicken = function(){}; 
makeSound( new Duck() ); // 嘎嘎嘎
makeSound( new Chicken() ); // 咯咯咯

在 Java 中，可以通过向上转型来实现多态。而 JavaScript 的变量类型在运行期是可变的，因此 JavaScript 天生是多态的。

封装 封装的目的是将信息隐藏。一般而言，我们讨论的封装是封装数据和封装实现。

JavaScript 原型编程基本规则。

• 所有的数据都是对象。
• 要得到一个对象，不是通过实例化类，而是找到一个对象作为原型并克隆它。
• 对象会记住它的原型。
• 如果对象无法响应某个请求，它会把这个请求委托给它自己的原型。

设计模式

单例模式

单例模式的定义是：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

    var Singleton = function( name ){ 
        this.name = name; 
    }; 
    Singleton.prototype.getName = function(){ 
        alert ( this.name ); 
    }; 
    Singleton.getInstance = (function(){ 
        var instance = null; 
        return function( name ){ 
            if ( !instance ){ 
            instance = new Singleton( name ); 
            } 
            return instance; 
        } 
    })(); 

但 JavaScript 其实是一门无类（class-free）语言，也正因为如此，生搬单例模式的概念并无意义。在 JavaScript 中创建对象的方法非常简单，既然我们只需要一个"唯一"的对象. 通用的惰性单例：

    var createIframe= (function(){ 
        var iframe; 
        return function(){ 
            if ( !iframe){ 
                iframe= document.createElement( 'iframe' ); 
                iframe.style.display = 'none'; 
                document.body.appendChild( iframe); 
            } 
            return iframe; 
        } 
    })();

策略模式

定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。将不变的部分和变化的部分隔开是每个设计模式的主题，策略模式也不例外，策略模式的目的就是将算法的使用与算法的实现分离开来。

    var strategies = { 
        "S": function( salary ){ 
            return salary * 4; 
        }, 
        "A": function( salary ){ 
            return salary * 3; 
        }, 
        "B": function( salary ){ 
            return salary * 2; 
        } 
    }; 
    var calculateBonus = function( level, salary ){ 
        return strategies[ level ]( salary ); 
    }; 
    console.log( calculateBonus( 'S', 20000 ) ); // 输出：80000 
    console.log( calculateBonus( 'A', 10000 ) ); // 输出：30000 

策略模式的优点：

• 策略模式利用组合、委托和多态等技术和思想，可以有效地避免多重条件选择语句。
• 策略模式提供了对开放—封闭原则的完美支持，将算法封装在独立的 strategy 中，使得它们易于切换，易于理解，易于扩展。
• 策略模式中的算法也可以复用在系统的其它地方，从而避免许多重复的复制粘贴工作。
• 在策略模式中利用组合和委托来让 Context 拥有执行算法的能力，这也是继承的一种更轻便的替代方案。

缺点：

使用策略模式，必须了解所有的 strategy，必须了解各个 strategy 之间的不同点，这样才能选择一个合适的 strategy。比如，我们要选择一种合适的旅游出行路线，必须先了解选择飞机、火车、自行车等方案的细节。此时 strategy 要向客户暴露它的所有实现，这是违反最少知识原则的。

代理模式

代理模式是为一个对象提供一个代用品或占位符，以便控制对它的访问。 例子：

    var proxyMult = (function(){ 
    var cache = {}; 
    return function(){ 
    var args = Array.prototype.join.call( arguments, ',' ); 
    if ( args in cache ){ 
    return cache[ args ]; 
    } 
    return cache[ args ] = mult.apply( this, arguments ); 
    } 
    })(); 
    proxyMult( 1, 2, 3, 4 ); // 输出：24 
    proxyMult( 1, 2, 3, 4 ); // 输出：24 

代理模式包括许多小分类，在 JavaScript 开发中最常用的是虚拟代理和缓存代理。虽然代理 模式非常有用，但我们在编写业务代码的时候，往往不需要去预先猜测是否需要使用代理模式。 当真正发现不方便直接访问某个对象的时候，再编写代理也不迟。

迭代器模式

迭代器模式是指提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。迭代器模式可以把迭代的过程从业务逻辑中分离出来，在使用迭代器模式之后，即使不关心对象的内部构造，也可以按顺序访问其中的每个元素。

例：

    var iteratorUploadObj = function(){ 
        for ( var i = 0, fn; fn = arguments[ i++ ]; ){ 
            var uploadObj = fn(); 
            if ( uploadObj !== false ){ 
                return uploadObj; 
            } 
        } 
    }; 
    var uploadObj = iteratorUploadObj( getActiveUploadObj, getFlashUploadObj, getFormUpladObj ); 

迭代器模式是一种相对简单的模式，简单到很多时候我们都不认为它是一种设计模式。目前 的绝大部分语言都内置了迭代器。

发布—订阅模式

发布—订阅模式又叫观察者模式，它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知。在 JavaScript 开发中，我们一般用事件模型来替代传统的发布—订阅模式。

基本模式：

   const Event = {
       const handler = {}
       tap:(name,fn)=>{
           if(handler[name]){
               handler[name].push(fn)
           }
           handler[name] = [fn]
       }
       remove:(name)=>{
           ...
       }
       fire:(name)=>{
           handler[name].forEach((cb)=>{
               cb()
           })
       }
   }

命令模式

命令模式是最简单和优雅的模式之一，命令模式中的命令（command）指的是一个执行某些特定事情的指令。命令模式在 JavaScript 语言中是一种隐形的模式。 宏命令是一组命令的集合，通过执行宏命令的方式，可以一次执行一批命令。 例：

var closeDoorCommand = { 
   execute: function(){ 
       console.log( '关门' ); 
   } 
}; 
var openPcCommand = { 
   execute: function(){ 
       console.log( '开电脑' ); 
   } 
}; 
var openQQCommand = { 
   execute: function(){ 
       console.log( '登录 QQ' ); 
   } 
}; 
return { 
   commandsList: [], 
   add: function( command ){ 
   this.commandsList.push( command ); 
}, 
       execute: function(){ 
           for ( var i = 0, command; command = this.commandsList[ i++ ]; ){ 
               command.execute(); 
           } 
       } 
   } 
}; 
var macroCommand = MacroCommand(); 
macroCommand.add( closeDoorCommand ); 
macroCommand.add( openPcCommand ); 
macroCommand.add( openQQCommand ); 
macroCommand.execute(); 

组合模式

组合模式将对象组合成树形结构，以表示“部分-整体”的层次结构。 除了用来表示树形结构之外，组合模式的另一个好处是通过对象的多态性表现，使得用户对单个对象和组合对象的使用具有一致性。

组合模式如果运用得当，可以大大简化客户的代码。一般来说，组合模式适用于以下这两种情况：

• 表示对象的部分-整体层次结构。组合模式可以方便地构造一棵树来表示对象的部分-整体结构。特别是我们在开发期间不确定这棵树到底存在多少层次的时候。在树的构造最终完成之后，只需要通过请求树的最顶层对象，便能对整棵树做统一的操作。在组合模式中增加和删除树的节点非常方便，并且符合开放封闭原则。
• 客户希望统一对待树中的所有对象。组合模式使客户可以忽略组合对象和叶对象的区别，客户在面对这棵树的时候，不用关心当前正在处理的对象是组合对象还是叶对象，也就不用写一堆 if、else 语句来分别处理它们。组合对象和叶对象会各自做自己正确的事情，

模板方法模式

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

模板方法模式是一种典型的通过封装变化提高系统扩展性的设计模式。在传统的面向对象语言中，一个运用了模板方法模式的程序中，子类的方法种类和执行顺序都是不变的，所以我们把这部分逻辑抽象到父类的模板方法里面。而子类的方法具体怎么实现则是可变的，于是我们把这部分变化的逻辑封装到子类中。通过增加新的子类，我们便能给系统增加新的功能，并不需要改动抽象父类以及其他子类，这也是符合开放封闭原则的。

但在 JavaScript 中，我们很多时候都不需要依样画瓢地去实现一个模版方法模式，高阶函数是更好的选择。

享元模式

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

享元模式带来的好处很大程度上取决于如何使用以及何时使用，一般来说，以下情况发生时便可以使用享元模式。

• 一个程序中使用了大量的相似对象。
• 由于使用了大量对象，造成很大的内存开销。
• 对象的大多数状态都可以变为外部状态。
• 剥离出对象的外部状态之后，可以用相对较少的共享对象取代大量对象

职责链模式

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

无论是作用域链、原型链，还是 DOM 节点中的事件冒泡，我们都能从中找到职责链模式的影子。职责链模式还可以和组合模式结合在一起，用来连接部件和父部件，或是提高组合对象的效率。

中介者模式

中介者模式是迎合迪米特法则的一种实现。迪米特法则也叫最少知识原则，是指一个对象应该尽可能少地了解另外的对象（类似不和陌生人说话）。如果对象之间的耦合性太高，一个对象发生改变之后，难免会影响到其他的对象。

装饰者模式

装饰者模式可以动态地给某个对象添加一些额外的职责，而不会影响从这个类中派生的其他对象。

状态模式

允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它。

适配器模式

适配器模式主要用来解决两个已有接口之间不匹配的问题，它不考虑这些接口是怎样实现的，也不考虑它们将来可能会如何演化。适配器模式不需要改变已有的接口，就能够使它们协同作用。

设计原则和编程技巧

• 单一职责原则
• 最少知识原则
• 开放-封闭原则
• 接口和面向接口编程