JavaScript设计模式——前奏

     Function.prototype.method = function(name,fn){
         this.prototype[name] = fn;
     }
     var Anim = function(){
         //----
     };
     Anim.method("start",function(){
         //----
     })
     Anim.method("stop",function(){
         //----
     })

     //方法的链式调用

     Function.prototype.method = function(name,fn){
         this.prototype[name] = fn;
         return this;
     }
     var Anim = function(){
         //----
     };
     Anim.
         method("start",function(){
             //----
         }).
         method("stop",function(){
             //----
         })

一：首先，再回顾一下JavaScript：

1.数据类型

　　原始类型：布尔型、数值型、字符串类型

　　在就包括：对象类型（数组是一种特殊的对象）、函数类型

　　最后就是：空类型（null）、未定义类型（undefind）

　　注意：原始类型按值传送，其他数据类型则按引用传送。

　　

　　toString() 数值或者布尔类型转换成字符串类型。

　　parseInt()   parseFloat() 把字符串转换成数值。

　　双重非（var bool = !! num;） 把字符串转换成布尔值。

2. 闭包：

　　闭包是一个受保护的变量空间，由内嵌函数生成。JavaScript具有函数级的作用域。这意味着函数内部的变量函数外部不能访问。JavaScript的作用域是词法性质的。这意味着函数运行在定义它的作用域中，而不是在调用它的作用域中。这样就可以创建私有变量：

     var baz;
     (function(){
         var foo = 1;
         var bar = 2;
         baz = function(){
             retrun foo*bar;
         }
     })

     baz();

3. 对象的易变性：

　　对实例化的对象进行扩展。比如给一个实例加一个方法或者给一个函数加一条属性。

　　与之相关的还有内省的概念：可以在运行时检查对象所具有的属性和方法，还可以使用这种信息动态实例化类和执行其方法。（这种技术称为反射）---（我对此的概念有点模糊，日后补充。嘿嘿......）

二：接口：

　　JavaScript模仿接口的三种方法：注释法、属性检查法、鸭式辨型法。

　　1.注释法：

　　注释法简单，但是，嘿嘿。效果最差。

     /*
     interface jk{
         function add(child);
         function remove(child);
         function get(child);
     }
     */
     var sx = function(){
         //------
     }
     sx.prototype.add = function(){
         //------
     }
     sx.prototype.remove = function(){
         //------
     }
     sx.prototype.get = function(){
         //------
     }

　　看懂了吧。。加个注释你就想让人家按你的规范了。我才不呢。。。。任性，反正不安你的来不会报错，而且对测试和调试没什么卵用！！

　　2.属性检查法：

     /*
      interface jk{
         function add(child);
         function remove(child);
         function get(child);
      }
      interface jk_two{
         function save(child);
      }
      */
     var sx = function(id,method,action){
         this.impletementsInterfaces = ['jk','jk_two'];
     }

     function addForm(formInstance){
         if(!impletements(formInstance,'jk','jk_two')){
             throw new Error("Object does not implement a required interface.")
         }
     }

     function impletements(object){
         for(var i = 1; i<arguments.length; i++){
             var interfaceName = arguments[i];
             var interfaceFound = fale;
             for(var j = 0; j<object.impletementsInterfaces.length; j++){
                 if(object.impletementsInterfaces[j] == interfaceName){
                     interfaceFound = true;
                     break;
                 }
             }

             if(!interfaceFound)
              return false;
         }
         return true;
     }

　　3.鸭式辨型法：

     var Composite = new Interface('Composite',['add','remove','getChild']);
     var FormItem = new Interface('FormItem',['save']);

     var CompositeForm = function(id, method, action){
         //.......
     }

     //.......

     function addForm(formInstance){
         ensureImplements(formInstance, Composite, FormItem);
         //如果有一个接口的方法没有被继承，这个方法会抛出一个错误。。。。
     }

　　

　　接下来说一下结合第一种和第三种方法的接口实现：

　　

     var Composite = new Interface('Composite',['add','remove','getChild']);
     var FormItem = new Interface('FormItem',['save']);

     var CompositeForm = function(id, method, action){
         //.......
     }

     //.......

     function addForm(formInstance){
         Interface.ensureImplements(formInstance, Composite, FormItem);
         //如果有一个接口的方法没有被继承，这个方法会抛出一个错误。。。。
     }

     //----下面是Interface类

     var Interface = function (name, methods) {
         if(arguments.length !=2){
             throw new Error("Interface constructor called with " + arguments.length + "arguments, but expected exactly 2.")
         }

         this.name = name;
         this.methods = [];
         for(var i = 0, len = methods.length; i < len; i++){
             if(typeof methods[i] !== 'string'){
                 //接口构造函数希望将方法名称传递给字符串
                 throw new Error("Interface constructor expects method names to be" + "passed in as a string")
             }
             this.methods.push(methods[i])
         }
     };
     //静态类方法
     Interface.ensureImplements = function(object){
         if(arguments.length < 2){
             //函数 interface.ensureimplements 称有2个参数，但预计至少2。
             throw new Error("Function Interface.ensureImplements called with " + arguments.length + "arguments, but expected at least 2.")
         }
         for(var i = 1, len = arguments.length; i < len; i++){
             var interface = arguments[i];
             if(interface.constructor !== Interface){
                 throw new Error("Function Interface.ensureImplements expects arguments" + "two and above to be instances of Interface.")
             }
             for(var j = 0, methodsLen = interface.methods.length; j < methodsLen; j++){
                 var method = interface.methods[j];
                 if(!object[method] || typeof object[method] !== 'function'){
                     //没有继承 xx 接口，方法 xx 没有发现
                     throw new Error("Function Interface.ensureImplements:object does not implement the " + interface.name + " interface.Method" + method + " was not found.")
                 }
             }
         }
     }

　　

关于使用接口，自己权衡利弊

　　

三：封装和信息隐藏：

　　后续补充----------请期待........