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.")
                }
            }
        }
    }

　　

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

　　

三：封装和信息隐藏：

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