chaojidan

导航

verify验证插件的详解

使用此验证插件,我们只需要新建一个实例对象,同时传入一个json对象就行了,这里我们只传入了两个属性:checkItem和callback。下面的代码解析,我们就按照这个例子来。

var verify =new Validator({
  checkItem:[
    {"element":"#endTime","required":false,"rule":[{"reg":"int","errMsg":lang('org.userStrategy.end_with_int')}]},

    {"element":"#ruleMboxCapacity","required":true, "rule": [{"reg":"int","minValue":1,"maxValue":100}]},

    {"element":"#endTime","required":false,"rule":[{"reg":"int","errMsg":lang('org.userStrategy.int_gez'),"minValue":1}]},
    {"element":"#ruleIsMboxCapa","rule":[{"reg":"no","childElement":"#ruleMboxCapacity"}]}
  ],
  calback:function(){
      if($("#startTime").val()==""){
        return {
          "element":"#startTime",
          "status":false,
          "errMsg":lang('org.userStrategy.sdate_not_null')
        }
      }
      if($("#endTime").val()==""){
        return {
          "element":"#endTime",
          "status":false,
          "errMsg":lang('org.userStrategy.edate_not_null')
        }
      }
    
      return {
        "status":true
      }
  }
});

调用Validator实例对象verify.getVerifyStatus(),如果返回true,就代表你在checkItem传入的元素验证全部通过了,如果返回false,就代表还有元素验证没有通过。

var Validator = function(options){
  options = options || {"checkItem":null,"verifyCallback":null};    //options = {checkItem:[], callback: function(){}}
  this.barColor = ["#aa0033", "#ffcc33", "#6699cc", "#008000"];
  this.levelTitle = ["不符合规则","弱","中","强"];
  this.checkItem = options.checkItem || this.html2Json();  //这里我们有checkItem属性,因此不会调用html2Json方法
  this.showPosition=options.showPosition || "right";    //默认为right
  this.verifyCallback = options.calback ;//自定义验证的回调函数;
  this.init();
};
var hash_rule={};
Validator.prototype = {
  init:function(){
    var p = this;
    for(var i = 0 ;i<this.checkItem.length;i++){   //遍历checkItem数组
      var ruleInfo = this.checkItem[i];
      var input = $(ruleInfo.element);    //数组中的每一项是一个json对象,其中element属性值是页面上元素节点的id
      input.off();            //移除此元素上通过on绑定的所有事件
      var inputType = input.attr("type");    //得到此元素的类型
      if(!ruleInfo.rule){       //查看此json对象是否有rule属性值,如果没有,就忽略,如果有,就继续判断
        continue;
      }
      //绑定文本框的失去焦点事件,当失去焦点后判断文本框的内容是否合法
      if ((inputType == "text" || inputType == "password")) {   //如果元素的类型是text或是密码框
        input.bind("blur", function(){    //就给此元素绑定blur事件
          p.event._blur(this, p)
        });
      }
      if(inputType =="checkbox" || inputType=="radio"){   //如果元素的类型是checkbox多选框或者是radio单选框
        var childElementList = ruleInfo.rule[0].childElement;  //rule属性也是数组,选取它的第一项,看它是否有childElement属性值
        if(typeof(childElementList)=="string"){     //这里只有checkItem数组中的第四项有
          childElementList=[childElementList];
          ruleInfo.rule[0].childElement = childElementList;   //把字符串转换成数组:"childElement":["#ruleMboxCapacity"]
        }
        if(!input.is(":checked")){    //如果元素checkbox或radio没有被选中,就进入if语句
          for (var j = 0; j < childElementList.length; j++) {    //就把设置它的子元素的属性disabled和noVerify
            $(childElementList[j]).attr("disabled", "true");   //这里的意思其实就是如果父元素没有被选上,那么子元素当然是不可用的,同时也不需要验证
            $(childElementList[j]).attr("noVerify","1");
          }
        }
        input.bind("click",function(){    //给元素checkbox或radio绑定click事件
          var _ruleInfo = hash_rule[$(this).attr("guid")];  
          if(!_ruleInfo){
            return;
          }
          var childElementList = _ruleInfo.rule[0].childElement;
          if(typeof(childElementList)=="string"){
            childElementList=[childElementList];
          }
          if(!$(this).is(":checked")){   //如果点击radio或checkbox后,元素没有被选择上

            for (var z = 0; z < childElementList.length; z++) {
              $(childElementList[z]).attr("noVerify","1");    //就设置它的子元素全部为不可用,并且不验证
              $(childElementList[z]).attr("disabled","true");
              p._hideMessage($(childElementList[z]));    //隐藏错误信息
            }
          }else{
            for (var z = 0; z < childElementList.length; z++) {
              $(childElementList[z]).removeAttr("noVerify");
              $(childElementList[z]).removeAttr("disabled");
            }
          }
        })
      }
      //判断当前元素是否是密码框
      if(inputType=="password" ){
        var isCompare= false;
        for(var z = 0 ;z<ruleInfo.rule.length;z++){
          if(ruleInfo.rule[z].reg =="compare"){   //看一下checkItem中的reg的值是否是compare,如果是,就代表是密码比较框,也就是你的确认密码框
            isCompare=true;
 
          }
        }
        if (!isCompare) {           //如果就是密码框
          if (ruleInfo.isAddTitle != false) {    //如果checkItem中有isAddTitle属性值,并且不为false
            p._addPasswordHtml(input);//给密码框加上强\弱\中的提示HTML
            input.attr("maxLength","30");   //最多输入30个字符
            input.bind("keyup", function(){//绑定事件,判断每次输入后的密码等级
              p.event._bindPassWord(this, p)
            });

          }
        }
      }
      if (ruleInfo.title) {        //如果checkItem数组中的每一个json对象中有title属性,就给此元素绑定click事件。
        $(input).bind("click", this._click);
      }
      //生成一个时间戳,复制给元素节点的guid属性中.然后将每个元素节点对应的验证规则存储在Hash中,后面就只要在hash中就能知道此元素需要验证的规则了.
      var guid = new Date().getTime()+Math.floor(Math.random()*1000);
      input.attr("guid",guid);
      hash_rule[guid]=ruleInfo;
    }
  },

  //文本框的事件处理
  event:{
    _click :function(){
      var guid = $(this).attr("guid");
      var inputObj = hash_checkObj[guid];
      _showMessage($(this),inputObj.title);
    },
    //所有文本框的失去焦点的事件处理
    _blur :function(element,This){       //元素节点的类型为text或password时,当给此元素触发blur事件时,会触发此方法的执行
      if($(element).attr("noVerify")=="1"){      //判断此元素是否需要验证,等于1,就代表不用验证
        This._hideMessage($(element));    //不需要验证,就代表需要隐藏此元素的错误提示
        return true;
      }
      if($(element).parents("div:eq(0)").is(":hidden")){   //如果此元素的祖先元素中第一个div元素是隐藏的,就不用验证,直接隐藏错误提示
        This._hideMessage($(element));
        return true;
      }
      var result = {};
      switch($(element).attr("type")){
        case "text":
          result = This.check._Input(element);    //验证此框填的内容是否合法
          break;
        case "checkbox":
        case "radio":
          result = This.check._Checkbox(element,This);
          break;
        case "password":
          result = This.check._Passwod(element,This);   //如果是密码框
          break;
      }
      if(!result.status){    //如果返回的状态为false,就代表错误,然后把错误信息显示出来
        This._showMessage($(element),result.errMsg);
      }else{
        This._hideMessage($(element));
      }
      return result.status;
    },
    //密码框的文本输入处理
    _bindPassWord:function(element,This){
      var options = {pwdMinLen: 6, pwdMaxLen: 30, pwdCheckType:1};
      var paswordInfo = This.PwdCheck($(element).val(),options);
      if(!paswordInfo.status){   //如果返回的状态为false,就提示用户有什么问题
        $(".pass_str_tips").html(paswordInfo.msg);
        $(".pass_str_tips").show();
      }else{   //如果返回的状态是true
        $(".pass_str_tips").html("长度"+options.pwdMinLen+"-"+options.pwdMaxLen+"位半角字符(字母、数字、符号)组成,区分大小写");
      }
      var levelTitle = $(".pass_str_txt").find("strong");
      levelTitle.html(This.levelTitle[paswordInfo.SafeLevel]);      //这里的levelTitle = ["不符合规则","弱","中","强"];
      levelTitle.css("color",This.barColor[paswordInfo.SafeLevel]);  //不同的提示,有不同的颜色

      $(".pass_str_bar").css({"width":(paswordInfo.SafeLevel+1)*45+"px","background-color":This.barColor[paswordInfo.SafeLevel]});
    }
  },
  addItem:function(item){   //增加验证的元素
    item= item || this.html2Json();
    this.checkItem = this.checkItem.concat(item);
    this.init();
  },
  //对所有类型的文本框的检查
  check:{
  //多选框
    _Checkbox:function(element,This){
      var result ={status:true,errMsg:""};
      //return result;
      if ($(element).is(":checked")) {
        var guid = $(element).attr("guid");
        var ruleInfo = hash_rule[guid];
        if (ruleInfo.rule[0].childElement) {
          var childList = ruleInfo.rule[0].childElement;
          for (var i = 0; i < childList.length; i++) {
            if (!This.event._blur(childList[i], This)) {
              result.status = false;
            }
          }
        }
        result.errMsg = ruleInfo.rule[0].errMsg;
      }
      return result;
    },
    //密码框有2种验证 一种是密码的规则校验,一种是密码的比较,因为要确认密码,所以有两个密码框
    _Passwod:function(element,This){
      var result ={ status:true , errMsg:"" };
      var guid = $(element).attr("guid");
      var ruleInfo = hash_rule[guid];
      if (ruleInfo) {
        if (ruleInfo.isAddTitle != false) {   //如果设置了isAddTitle属性,并且不为false
          var isCompare = false, compareId = "";
          for (var z = 0; z < ruleInfo.rule.length; z++) {
            if (ruleInfo.rule[z].reg == "compare") {    //如果是确认密码框
              isCompare = true;
              compareId = ruleInfo.rule[z].compare;    //如果是密码比较框,这里的compare的属性值就是被比较的那个密码框的id
              result.errMsg = ruleInfo.rule[z].errMsg || "两次输入的密码不一致";
            }
          }
          if (!isCompare) {   //如果是正常的密码输入框
            var options = {
              pwdMinLen: 6,
              pwdMaxLen: 30,
              pwdCheckType: 1
            };
            var paswordInfo = This.PwdCheck($(element).val(), options);
            result.status = paswordInfo.status;
            result.errMsg = "密码不符合规则";
          }
          else {
            result.status = ($(compareId).val() == $(element).val() ? true : false);   //如果两个密码框的值一样,就返回true
          }
        }
        else{
          return This.check._Input(element,ruleInfo);
        }
      }
      return result;
    },
    //自定义的列表框
    _List:function(element){
      var result ={ status : false , errMsg : "" };
      var guid = $(element).attr("guid");
      var ruleInfo = hash_rule[guid];
      if($(element).children().length>0){
        result.status=true;
      }
      result.errMsg=ruleInfo.rule[0].errMsg;
      return result;
    },
    //普通文本框
    _Input:function(element,rule){          
      var result ={ status : true , errMsg : "" };
      var guid = $(element).attr("guid");
      var ruleInfo = rule ? rule : hash_rule[guid];   //取到此元素在checkItem中的验证规则
      if(!ruleInfo){    
        return;
      }
      var inputType = $(element).attr("type");
      var val = $.trim($(element).val());
      var required =true;
      if(ruleInfo.required==false){    //是否必须存在值,默认为true,也就是默认文本框必须存在值
        required=false;
      }
      if (required && val == "") {
        result.status = false;
        result.errMsg = "该项不能为空";
        return result;
      }
      if(util.Reg.isLegitimacy(val) && inputType != 'password'){  //如果不是密码框,同时输入框中的值有非法符号
        result.status = false;
        result.errMsg = "输入值中含有非法符号"+$.unique(val.match(/[%\/\\\'\"&<\>|\^]/igm)).join("");
        return result;
      }
      if (val!="") {
        var rule = ruleInfo.rule;
        for (var i = 0; i < rule.length; i++) {
          switch (rule[i].reg) {
            case "empty":
              result.status = !util.Reg.isEmpty(val);
              break;
            case "int":
              result = this._int(val,rule[i]);     //必须为int型
              break;
            case "number":
              result.status = !isNaN(val);
              break;
            case "username":
              result = this._userName(val);
              break;
            case "chinesename":
              result.status = util.Reg.isInt(val);
              break;
            case "mobile":
              result.status = util.Reg.isMobile(val);
              break;
            case "tel":
              result.status = util.Reg.isTel(val);
              break;
            case "email":
              result.status = util.Reg.isEmail(val);
              break;
            case "demail":
              result.status = util.Reg.isDomainEmail(val);
              break;
            case "domain":
              result.status = util.Reg.isDomain(val);
              break;
            case "ip":
              result.status = util.Reg.isIp(val);
              break;
            case "smtp":
              result.status = util.Reg.isSmtp(val);
              break;
            case "compare":
              result.status =(val==$(rule[i].compare).val()?true:false);
              break;
          }
          result.errMsg = !result.errMsg?rule[i].errMsg:result.errMsg;   //如果没有错误信息,就用用户传入的错误信息
        }
      }
      return result;
    },
    _int:function(val,rule){
      var result = {
        "status":true
      };
      if(!util.Reg.isInt(val)){    //如果不是数字,就直接返回false
        result.status=false;
        return result;
      }
      if (val!="" && (rule.maxValue || rule.minValue)) {   //数字不能大于最大值,小于最小值
        var iVal = parseInt(val);
        if (iVal > rule.maxValue) {
          result.errMsg = "最大值不能超过" + rule.maxValue;
          result.status = false;
        }
        else if (iVal < rule.minValue) {
          result.errMsg = "最小值不能小于" + rule.minValue;
          result.status = false;
        }
      }
      return result;
    },
    _userName:function(val){
      var result ={status:true,errMsg:""};
      if(val.length<2){
        result.status=false;
        result.errMsg="用户名最小长度为2";
      }else if(val.length > 20){
        result.status=false;
        result.errMsg="用户名最大长度为20";
      }else if(util.Reg.isHaveChinese(val)){
        result.status=false;
        result.errMsg="用户名不能包含中文";
      }
      else if(!util.Reg.netname(val)){
        result.status = false;
        result.errMsg = "帐号不合法";
      }
      return result;
    }
  },  
    //添加密码框下面的安全级别提示的HTML
  _addPasswordHtml:function(element){
    var passwordHtml = '<div class="verify-message pass_str" data-role="message">'
      +'<div class="pass_str_txt"><strong></strong>密码安全度:</div>'
        +'<div class="pass_str_line"><div class="pass_str_bar"></div></div>'
          +'<div class="pass_str_tips"></div></div>'
    element.after(passwordHtml);
  },
  //显示错误信息
  _showMessage:function(element,message,position){
    element.addClass("erro-input");
    var rule = hash_rule[element.attr("guid")] || {"position":"right"};
    var position = position?position:(rule.position || "right");
    if (!element.next().hasClass("errortip")) {   //如果元素的下一个元素没有errortip类
      element.parents("div:eq(0)").addClass("p_relative");
      var top ="px";
      var left ="0px";
      if(position=="down"){
        top = element.position().top+element.height()+10+"px";   //position() 方法返回匹配元素相对于父元素的位置(偏移)。该方法返回的对象包含两个整型属性:top 和 left,以像素计。此方法只对可见元素有效。

        left = (element.position().left-5)+"px";
      }else{
        top = element.position().top+"px";
        left = (element.position().left+element.width()+20)+"px";
      }
      element.after('<div class="errortip ml_5" style="top:'+top+';left:'+left+'">'+message+'</div>');

    }else{
      element.next().hasClass("errortip")?element.next().html(message):"";
    }
  },
  //隐藏错误信息
  _hideMessage:function(element){
    if (element.prop("tagName") == "UL") {
      element.parent().removeClass("erro-input");
      element.parents("div:eq(1)").find(".errortip").remove();
    }
    else {
      element.parent().find(".errortip").remove();
      element.removeClass("erro-input");
    }
  },
  //得到整个验证的状态,是否验证通过
  getVerifyStatus:function(){
    var status =true;;
    for(var i = 0 ;i<this.checkItem.length;i++){
      var _element = $(this.checkItem[i].element);
      if(this.checkItem[i].rule[0].reg == "no"){   //如果元素本身不需要验证,那么验证它的子元素
        _element = $(this.checkItem[i].rule[0].childElement);
      } //过滤掉本身不需要检验的元素
      if (_element.attr("type")) {
        if (!this.event._blur(_element, this)) {   //如果元素没有通过验证,就返回false
          status = false;
        }
      }
      else{
        var tarName = _element.prop("tagName");
        switch(tarName){
          case "UL":
            var checkResult = this.check._List(_element) ;   //如果验证的元素是ul,则需要验证它是否有子元素,如果有,就返回true,没有就返回false
            if(!checkResult.status){
              this._showMessage(_element.parents("div:eq(0)"),checkResult.errMsg);
              status =false;
            }
            break;
          case "DIV":
            break;
        }
      }
    }
    if(this.verifyCallback){   //如果有回调函数
      var result = this.verifyCallback();   //就执行此回调函数
      if(!result.status){    //如果回调函数返回的状态为false,就显示错误
        this._showMessage($(result.element),result.errMsg);
        status = false;
      }
    }
    return status
  },
  //得到指定文本框的验证状态,第一个参数是验证的对象,第二个参数代表是否显示错误信息
  getSingStatus :function(element,isShowErr){
    var result = this.check._Input(element,hash_rule[$(element).attr("guid")]);
    if(!result.status && isShowErr){
      this._showMessage($(element),result.errMsg);
    }
    return result.status;
  },
  //将写在文本框上的验证转换成JSON 然后解析;
  html2Json:function(){
    var checkItem = [];
    $("[reg]").each(function(){    //对页面上所有具有reg属性的元素进行处理
      var other = {
        "reg":$(this).attr("reg"),
        "errMsg":$(this).attr("errmsg")
      }
      if($(this).attr("maxValue")){
        other.maxValue=$(this).attr("maxValue");
      }
      if($(this).attr("minValue")){
        other.minValue=$(this).attr("minValue");
      }
      if($(this).attr("compare")){
        other.compare = $(this).attr("compare");
      }
      var rule = {
        "element":$(this),
        "position":$(this).attr("position") || "right",
        "required":!($(this).attr("required")?true:false),  //如果此元素的required = false,那么就设置rule.required = true,就规定此元素不能为空。如果此元素的required = true,那么就设置rule.required = false。
        "rule":[other]
      }
      if(other.reg=="empty"){   //如果元素的reg属性值为empty,那么就规定此元素不能为空
        rule.required=true;
      }
      checkItem.push(rule);
    })
    return checkItem;
  },
  //密码的处理机制
  PwdCheck: function (spwd, o) {      //这里的o = {pwdMinLen: 6,pwdMaxLen: 30,pwdCheckType: 1},spwd为密码框中的值

    var p = this;
    var NotContains = p.NotContains;   //密码框中的值不能包括NotContains对象中定义的属性值

    p.sLevel = o.pwdCheckType;     //1
    p.VdPassword = {};

    p.VdPassword.pwdMinLen = o.pwdMinLen;     //6
    p.VdPassword.pwdMaxLen = o.pwdMaxLen;    //30
    p.VdPassword.level = o.pwdCheckType;    //1
    //获取密码框中的值
    var spwd = spwd;
    var dic = [
      "123456",
      "12345",
      "123456789",
      "password",
      "iloveyou",
      "rockyou",
      "1234567",
      "12345678",
      "abc123",
      "654321",
      "iloveu",
      "111111",
      "0"
    ];     

    String.prototype.LTrim = function () {
      return this.replace(/(^\s*)/g, "");
    }
    String.prototype.RTrim = function () {
      return this.replace(/(\s*$)/g, "");
    }
    String.prototype.Trim = function () {
      return this.replace(/(^\s*)|(\s*$)/g, "");
    }
    String.prototype.replaceAll = function (s1, s2) {
      return this.replace(new RegExp(s1, "gm"), s2);
    }
    function getReturnValue(sLevel, sNcode) {   //当密码框为空时,这里传入的是0,1。如果密码长度小于6,大于30,传入0,9。如果密码是常用的简单密码,传入0,2。密码为纯数字,传入1,0.密码包含中文,传入0,6.如果密码包含了空格,传入0,10.如果都不属于前面的情况,那么就传入undefined,0,这时sLevel为2或者3.
      if (sLevel == 0) {
        sLevel = 0;
      }
      else if (sLevel != 0) {
        //如果合法, 根据[字母,特殊字符,数字]得到密码的强度
        sLevel = getStrongLevel(spwd);    //如果密码有字母,特殊字符,数字三种,就返回3,有两种,就返回2,只有一种就返回1
      }
      var ret = {
        SafeLevel: sLevel,
        NotifyCode: sNcode
      };
      p.VdPassword.SafeLevel = sLevel;
      p.VdPassword.NotifyCode = sNcode;
      return setMsg(sNcode, sLevel);

    }

    //设置密码验证后的提示信息
    function setMsg(sNcode, sLevel) {    //如果密码框为空,这里传入的是1,0。如果密码长度小于6大于30,这里是9,0。如果输入的密码是常用的简单密码,就传入2,0.如果密码为纯数字,这里传入0,1.如果密码包含中文,传入6,0.如果密码包含空格,传入10,0.如果前面的都不匹配,就代表密码没问题,传入0,2(或3)。

      if(sNcode<9 || sNcode==10){
        p.VdPassword.msg = App.$LANG("control.verify.pass_msg"+sNcode);
      }
      else if(sNcode == 9){
        p.VdPassword.msg =util.text.format(App.$LANG("control.verify.pass_msg9"),p.VdPassword.pwdMinLen, p.VdPassword.pwdMaxLen);
      }
      if (sNcode != 0) {     
        p.VdPassword.status = false;    //返回false状态

        return p.VdPassword;
      }

      //如果没有错误,但安全强度没有达到我们设置的要求,则返回false,并且提示用户,你输入的密码太简单了,等级太低了。
      if (sNcode == 0 && sLevel < p.sLevel) {
        var mustLevel = p.sLevel;
        p.VdPassword.msg = App.$LANG("control.verify.pass_type_"+mustLevel);
        p.NotifyCode = 10;
        p.VdPassword.status = false;
        return p.VdPassword;
      } else if (sNcode == 0) {
        p.NotifyCode = 0;
        p.VdPassword.msg = "";
        p.VdPassword.status = true;     //返回true
        return p.VdPassword;
      }

    }

    function isTrim(s){
      if(s.replace(/ /g,"").length!=s.length){
        return true;
      }else return false;
    }

    function getPwdProperty(pwd) {
      var hasNum = false;
      var hasLetter = false;
      var hasSymbol = false;
      var s = pwd.toLowerCase();
      var numStrs = "0123456789";
      var letterStrs = "abcdefghijklmnopqrstuvwxyz";
      var symbolStrs = "~!@#$%^&*()_-=+{}[]:\"|<>?,./;'\\";
      var ch = "";
      //判断是否有数字
      for (var i = 0; i < s.length; i++) {
        ch = s.substr(i, 1);
        if (numStrs.indexOf(ch) != -1) {
          hasNum = true;
          break;
        }
      }
      //判断是否有字母
      for (var i = 0; i < s.length; i++) {
        ch = s.substr(i, 1);
        if (letterStrs.indexOf(ch) != -1) {
          hasLetter = true;
          break;
        }
      }
      //判断是否有特殊符号
      for (var i = 0; i < s.length; i++) {
        ch = s.substr(i, 1);
        if (symbolStrs.indexOf(ch) != -1) {
          hasSymbol = true;
          break;
        }
      }
      var ret = {
        HasNum: hasNum,
        HasLetter: hasLetter,
        HasSymbol: hasSymbol
      };
      return ret;
    };

    function getStrongLevel(pwd) {
      var pro = getPwdProperty(pwd);
      var hasNum = pro.HasNum;
      var hasLetter = pro.HasLetter;
      var hasSymbol = pro.HasSymbol;

      //没有数字,没有特殊字符,
      if ((!hasNum) && (!hasSymbol)) {
        return 1;
      }
      //没有数字,没有字母
      if ((!hasNum) && (!hasLetter)) {
        return 1;
      }

      //没有字母, 没有特殊字符
      if (!(hasSymbol) && !(hasLetter)) {
        return 1;
      }
      //有数字,有字母,没特殊字符
      if ((hasNum) && (hasLetter) && (!hasSymbol)) {
        return 2;
      }
      //有数字,没有字母,有特殊字符
      if ((hasNum) && (!hasLetter) && (hasSymbol)) {
        return 2;
      }
        //没有数字,有字母,有特殊字符
      if ((!hasNum) && (hasLetter) && (hasSymbol)) {
        return 2;
      }
      if (hasNum && hasLetter && hasSymbol) {
        return 3;
      }
      return 3;
    };

    var level; //密码的安全度 [ 弱 普通 安全 ]

    /* 1.输入为空,直接返回安全度为 [ 0 ] */
    if (spwd == "") {
      level = 0;
      ncode = 1;
      return getReturnValue(level, ncode);
    }
    /* 2.如果小于6或者大于30,密码长度不对,返回安全度为[ 0 ] */
    if (spwd.length < parseInt(p.VdPassword.pwdMinLen) || spwd.length > parseInt(p.VdPassword.pwdMaxLen)) {

      level = 0;
      ncode = 9;

      return getReturnValue(level, ncode);
    }

    var smppwd = spwd;   //密码框中的值
    var dicpwd; 
    for (var i = 0; i < dic.length; i++) {
      smppwd = spwd;
      dicpwd = dic[i];
      // 3.如果密码为常用的简单密码, 返回安全度为[ 0 ]
      if (smppwd == dicpwd) {
        level = 0;
        ncode = 2;
        return getReturnValue(level, ncode);
      }
    }

      /* 4.[ NotContains : 密码不能等于这个对象的属性 ] */
    if (NotContains) {
      if (NotContains.Account) {
        if (spwd == NotContains.Account) {
          level = 0;
          ncode = 3;
          return getReturnValue(level, ncode);
        }
      }
      if (NotContains.Mobile) {
        if (spwd == NotContains.Mobile) {
          level = 0;
          ncode = 3;
          return getReturnValue(level, ncode);
        }
      }
      if (NotContains.Alias) {
        if (spwd == NotContains.Alias) {
          level = 0;
          ncode = 3;
          return getReturnValue(level, ncode);
        }
      }
    }

    if (!/\D/.test(spwd)) { //5.密码为纯数字
      level = 1;
      ncode = 0;
      return getReturnValue(level, ncode);
    }

    if (/.*[\u4e00-\u9fa5]+.*$/.test(spwd)) {     // 6.包含了中文
      level = 0;
      ncode = 6;
      return getReturnValue(level, ncode);
    }

    if(isTrim(spwd)){   //7.包含空格
      level=0;
      ncode=10;
      return getReturnValue(level, ncode);
    }
    getReturnValue(level, 0);
    return p.VdPassword;
  }
};

代码中有一些调用了工具类util中的方法,将在下一个插件util中讲解。

 

 

 

加油!

posted on 2015-01-14 13:49  chaojidan  阅读(4449)  评论(0编辑  收藏  举报