1、灵活的语言----javascript

当我们接到新的需求时，感觉一切都很简单，不就是几个函数的事吗？可能会像下面这样，其实不然。

function checkAddress(){
    //检测地址 
}

function checkPhone(){
    //检测手机号码
}

function checkPassword(){
    //检测密码
}

 

 这样写，相当创建了很多个全局变量，你很惊讶的问，我就写几个函数怎么会是变量哪？别急你在往下看

函数的另一种形式

 

var checkAddress = function(){
    //检测地址 
}

var checkPhone = function(){
    //检测手机号码
}

var checkPassword = function(){
    //检测密码
}

 

一样的，只不过。。。。。

对，只不过在用的时候提前声明，但你会看到你创建的三个函数保存在变量里来实现你的功能，其实也是创建了全局的变量，加入一个团队要根据团的规范来写。

这个写法会有弊端的存在，同样的方法别人也定义了，就会出现覆盖原有的功能，这并不是我们期望的结果，该如何解决哪：

 

用对象存储变量

　　

var checkInfo = {
    checkAddress : function(){
        //code
    },
    checkPhone : function(){
        //code
    },
    checkPassword : function(){
        //code
    }
}

这样我们把所有函数作为checkInfo对象方法，这样我们就有一个对象，使用也很简单：

checkInfo.checkAddress();

　　

对象的另一种形式

首先，要声明一个对象，然后给它添加方法，当然javascript中的函数也是对象，so......

var checkInfo = function(){};
checkInfo.checkPassword = function(){};
checkInfo.checkPhone = function(){};
checkInfo.checkAddress = function(){};

使用方法跟前边的一样，checkInfo.checkPhone();

当别人想用你写的对象方法就有些麻烦了，因为这个对象不能复制一份或者说这个对象类在用new关键字创建新的对象时，新创建的对象是不能继承这些方法的

真假对象

如果你是简单的复制一下，可以将这些方法放在一个函数对象中。

var checkInfo = function(){
    return {
        checkAddress : function(){},
        checkPhone : function(){},
        checkPassword : function(){}
    }
}

这样每次调用都会返回一个新的对象，对于其他人的使用互补影响。

调用：var test = checkInfo();

         test.checkAddress();

 

类也可以

通过创建新的对象完成了新的需求，但它不是真正意义上的类，并且创建的对象a 和对象checkInfo没有任何关系，so...

var checkInfo = function(){
    this.checkAddress = function(){};
    this.checkPassword = function(){};
    this.checkPhone = function(){};
}

这样的对象我们可以看成是类了，既然是类，那就用关键字new 来创建

var tt = new checkInof();

tt.checkAdress();

 

值得注意的，通过this定义的，所以没一次通过new 关键字创建新对象的时候，新创建的对象都会有类的this上的属性进行复制，新创建的对象都有自己的一套方法，

这样造成消耗时奢侈的，so...

var checkInfo = function(){
    checkInfo.prototyp.checkAddress = function(){};
    checkInfo.prototyp.checkPhone = function(){};
    checkInfo.prototyp.checkPassword = function(){};

}

这样创建对象实例的时候，创建出来的对象所拥有的方法都时一个，因为他们都是依赖prototype原型依次寻找，而找到的方法都是同一个，

这种方式我们要将prototype写很多遍，所以我们可以这样处理：

var checkInfo = function(){};
checkInfo.prototyp = {
    checkPassword : function(){};
    checkPhone : function(){};
    checkAddress : function(){};
}

有一点这两种方式不能混着用，那么将会覆盖掉之前对prototype对象赋值的方法。

 

方法还可以这样用

var checkInfo = {
    checkAddress : function(){
        //code
        return this;
    },
    checkPhone : function(){
        //code
        return this;
    },
    checkPassword : function(){
        //code
        return this;
    }
}

checkInfo.checkAddress().checkPhone();

 

同样方式也可以放到原型中。。。。

var checkInfo = function(){};
checkInfo.prototyp = {
    checkPassword : function(){
        return this;
    };
    checkPhone : function(){
        return this;
    };
    checkAddress : function(){
        return this;
    };
}

使用的时候要创建一下

var a = new checkInfo();

a.checkPassword().checkAddress();

　

函数的祖先

　　如果你看过prototy.js代码，你就会想到下边的写法

Function.prototyp.checkAddress = function(){
    //code
}

这样你在使用这个方法就会比较方便

var f = function(){};

f.checkPassword();

 

这样会污染了原生的Function，统一抽出一个公共的方法

Function.prototyp.addMendthod = function(name,fn){
    //code
    this[name] = fn;
}

var methods = new Function();

or 

var methods = new Function();
methods.addMendthod('checkAddress',function(){
    //CODE
})


methods.checkAddress();

 

先到这吧，已深夜窗外的野狗又在叫了。。。。。夜难眠。