验证用户名、邮箱、密码----灵活的javascript

一、小白写法：

  function checkName(){
        // 验证名字
    }
    function checkEmail(){
        // 验证邮箱
    }
    function checkPassword(){
        // 验证密码
    }

创建了很多变量（函数也是变量）

二、函数的另一种形式

var checkName=function(){
        // 验证名字
    }
    var checkEmail=function (){
        // 验证邮箱
    }
    var checkPassword=function (){
        // 验证密码
    }

  提前声明变量，只是当团队合作中，其他人也定义了同样的方法就会覆盖掉原有的功能，如果定义了很多方法，这种相互覆盖的问题是很不容易察觉到的。如何避免：将他们放在一个变量里保存，这样就可减少覆盖或被覆盖的风险，当然一旦被覆盖，所有功能都会失效，这种现象也是很明显的，很轻易察觉到。

三、用对象收编变量

对象：有属性和方法，如果我们要访问它的属性或者方法时，通过点语法向下遍历查询得到。可以创建一个检测对象，然后把我们的方法放在里面

 var CheckObject={
        checkName:function(){
            // 验证名字
        },
        checkEmail:function (){
            // 验证邮箱
        },
        checkPassword:function (){
            // 验证密码
        }
    }

此时，我们只有一个对象，只需要checkObject.checkName()检测名字

四、对象的另一种形式

 var CheckObject=function(){};
    CheckObject.checkName=function(){
        // 验证名字
    }
    CheckObject.checkEmail=function (){
        // 验证邮箱
    }
    CheckObject.checkPassword=function (){
        // 验证密码
    }

使用方法更前面的方式一样，比如checkObject.checkName()检测名字，但别人想要用这个对象方法时就会有麻烦，因为这个对象不能复制一份，或者说这个对象类在用new关键字创建新对象时，新对象的对象是不能继承这些方法的。（就比如你买了一本书，你的小伙伴也觉得有用，书就一本，那只能答应，那么多人那需要答应很多本呢。）

五、真假对象
如果想要简单的复制一下，可以将这些方法放在一个函数对象中。

var CheckObject=function(){
        return {
            checkName:function(){
                // 验证名字
            }
            checkEmail:function (){
                // 验证邮箱
            }
            checkPassword:function (){
                // 验证密码
            }
        }
    };

每次调用这个函数时，明面上是CheckOject对象，可实际上是返回的新对象，这样每个人使用时就互不影响了，比如：

 var a=CheckObject();
   a.checkEmail();

六、类也可以

上面那种方式不是一个真正意义上的类的创建方式，并且创建的对象a和对象CheckObject没有任何一点关系

var CheckObject=function(){
        this.checkName=function(){
            // 验证名字
        }
        this.checkEmail=function (){
            // 验证邮箱
        }
        this.checkPassword=function (){
            // 验证密码
        }
    };

怎样的对象就可以看成类，但他的创建方式用new来创建

var a=new CheckObject();
   a.checkEmail();

如果跟小伙伴们都对类实例化，那么每个人多会有一套属于自己的方法。

七、一个检测类

像上面那样，把所有类放在函数内部，通过this定义，所以每一次通过new关键字创建新对象时，新对象都会对类的this进行复制，但有时候这么做会造成消耗，做一下处理：

var CheckObject=function(){};
    CheckObject.prototype.checkName=function(){
        // 验证名字
    }
    CheckObject.prototype.checkEmail=function (){
        // 验证邮箱
    }
    CheckObject.prototype.checkPassword=function (){
        // 验证密码
    }

这样创建对象实例的时候，创建出来的对象说拥有的方法就都是一个了，因为他们都要依赖prototype原型依次寻找，而找到的方法都是同一个，但是这样要写很多CheckObject.prototype:

 var CheckObject=function(){};
    CheckObject.prototype={
        checkName:function(){
            // 验证名字
        },
        checkEmail:function (){
            // 验证邮箱
        },
        checkPassword:function (){
            // 验证密码
        }
    }

但这样，如果为对象的原型对象赋值新对象是，那么他将覆盖掉之前对prototype对象赋值的方法。

 var a=new CheckObject();
   a.checkName();
   a.checkEmail();
   a.checkPassword();

八、方法还可以这样用

上面的写法调用3个方法时，会对对象a书写3次。这是可以避免的，在声明的每个地方末尾处将当前对象返回，在javascript中this指向的就是当前对象。

var CheckObject=function(){};
    CheckObject.prototype={
        checkName:function(){
            // 验证名字
            return this;
        },
        checkEmail:function (){
            // 验证邮箱
            return this;
        },
        checkPassword:function (){
            // 验证密码
            return this;
        }
    }
   CheckObject.checkName().checkEmail().checkPassword();

九、函数的祖先

prototype.js：一款javascript框架，里面为我们方便的封装了很多方法，最大的特点就是对原生对象（Function,Array,Object）的拓展,如先给每个函数都添加一个检测邮箱的方法就可以这么做：

 Function.prototype.checkEmail=function(){
        // 验证邮箱
    }
    var f=function(){};
    f.checkEmail();
    // 不过这样污染了原生对象Function，所以别人创建的函数也会有检测对象，造成不必要的开销，但可以抽象出一个统一添加方法的功能方法。
    Function.prototype.addMethod=function(name,fn){
        this[name]=fn;
    }
    // 这样就可以添加验证邮箱和验证姓名的方法：
    // var methods=function(){};
    var methods=new Function();
    methods.addMethod('checkName',function(){
        // 验证名字
    })
    methods.addMethod('checkEmail',function(){
        // 验证邮箱
    })
    methods.checkName();
    methods.checkEmail();

------javascript 设计模式（张容铭 著）