使用此验证插件，我们只需要新建一个实例对象，同时传入一个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 = "[email protected]#$%^&*()_-=+{}[]:\"|<>?,./;‘\\";
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中讲解。
加油！