yctb-SpringBoot/web/js/v2/fw/fw.valid.js

/**
 * @author herong
 * 通用校验组件
 */
var CFWValid = _FW.fCreateClass();

/**
 * 通用校验组件
 */
CFWValid.prototype = {
      
   /**
    * 初始化
    * */
   fInitialize : function(options) {
      
   },
   
   /**
    * 判断是否为正数或负数，如果不符合判断，则弹出提示对话框
    * @param Object oName (必需) 控件对象
    * @param int iFlag (必需) 正负标志:1 正数,-1 负数
    * <pre>
    * 使用举例：
    *     CFW.oValid.fnZfpd(_iSz, 1);
    * </pre>
    */
   fnZfpd : function (oName,iFlag) {
	  //入参为必需项，需要先进行非空校验。
	  if(this.fnIsNull(oName,"CFW.oValid.fnZfpd 控件对象")){
	  	  return; 
	  };	  
	  
      var val = oName.value;
      var vldStr = oName.vldStr;
      var arr = vldStr.split("=");
      var name = arr[0];
      
      if(!this.fnIsFloat(val)) {
    	  CFW.oWin.fnAlert(name+"不为数字");
    	  return ;
      }
      
      if(!(iFlag == '1' || iFlag == '-1')) {
    	  CFW.oWin.fnAlert("正负判断标志不为1或-1");
    	  return ;
      }
      
      /*不能为负数*/
      if(iFlag == 1){
         if(val < 0){         
            oName.value = '';
            CFW.oWin.fnAlert(name+"不能为负数");
            setTimeout(function(){oName.focus();},0);
         }
      }
      /*不能为正数*/
      if(iFlag == -1){
         if(val > 0){
            oName.value = '';
            CFW.oWin.fnAlert(name + "不能为正数");
            setTimeout(function(){oName.focus();},0);
         }
      }   
   },
   
   /**
    * 判断输入是否为整数字
    * 主要是判断传入的字符串，是否为整数(0-9)
    * @param  String sInputs (必需) 入参字符串
    * @return boolean true/false：是整数则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnIsInteger(_sInputs);
    * </pre>
    */
   fnIsInteger : function (sInputs) {
	  var strlength,rslength; 
	      
      //入参为必需项，需要先进行非空校验。
      if(this.fnIsNull(sInputs,"CFW.oValid.fnIsInteger 入参字符串")){
    	  return false; 
      };
      sInputs = sInputs + "";
      
      var regx=/-?[0-9]+/; //正则表达式 ‘-’出现0次或一次 [0-9]出现一次或多次
      var rs=regx.exec(sInputs);
      
      if(this.fnIsNull(rs)) return false; 
      
      strlength = (sInputs + '').length; 
      rslength = (rs + '').length ;
      
      if(strlength == rslength) {
    	  return true ;
      }
      return false;
   },
   
   /**
    * 判断输入是否为数值(包括小数点) 
    * 主要是判断传入的字符串，是否为数值(包括小数点) 
    * @param  String sInputs (必需) 入参字符串
    * @returns boolean true/false：是数值则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnIsFloat(_sInputs);
    * </pre>
    */
   fnIsFloat : function (sInputs) {
	  var tmp;  
      var strlength,rslength ;
      
      tmp = sInputs; 
      
      if(this.fnIsNull(tmp,"CFW.oValid.fnIsFloat 入参字符串")) return false; 
      
      if(this.fnIsInteger(tmp)) return true;
      
      var regx = /-?[0-9]+\.?[0-9]+/; //正则表达式 ‘-’出现0次或一次 [0-9]出现一次或多次  小数点出现0次或1次 [0-9]出现一次或多次
      var rs = regx.exec(tmp);
      
      if(this.fnIsNull(rs)) return false; 
      
      strlength = (tmp + '').length; 
      rslength = (rs + '').length ;
      //CFW.oWin.fnAlert(strlength + '||' + rslength) ;
      if(strlength == rslength) {
    	  return true ;
      }else {
    	  regx = /-?[0-9]*\.?[0-9]+/; //正则表达式 ‘-’出现0次或一次 [0-9]出现0次或多次  小数点出现0次或1次 [0-9]出现一次或多次
          rs = regx.exec(tmp);
          
          if(this.fnIsNull(rs)) return false; 
          
          rslength = (rs + '').length ;
          
          if(strlength == rslength) {
        	  return true ;
          }
      }
      return false; 
   },
   
   /**
    * 判断输入是否为电话号码，可以包含数字0至9，符号+、-、/、(、)以及空格
    * 主要是判断传入的字符串，是否为电话号码
    * @param   String sInputs (必需)入参字符串
    * @returns boolean true/false：是电话号码则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSfdhhm = CFW.oValid.fnIsPhoneNumber(_sInputs);
    * </pre>
    */
   fnIsPhoneNumber : function (sInputs) {
      var i,tempchar;
      //入参为必需项，需要先进行非空校验。
      if(this.fnIsNull(sInputs,"CFW.oValid.fnIsPhoneNumber 入参字符串")){
    	  return false; 
      };
      sInputs = CFW.oStr.fnNub2Str(sInputs); 
      if(sInputs == "")
         return false; 
      strlength = sInputs.length; 
      for(i = 0 ; i < strlength ; i++) { 
         tempchar = sInputs.substring(i,i+1); 
         if(!(tempchar==0||tempchar==1||tempchar==2||tempchar==3||tempchar==4||tempchar==5||tempchar==6||tempchar==7||tempchar==8||tempchar==9||tempchar=='-'||tempchar=='+'||tempchar==' '||tempchar=='/'||tempchar=='('||tempchar==')')) 
         { 
            return(false); 
         } 
      } 
      return(true);
   },
   
   /**
    * 判断输入是否为Email
    * @param   String sInputs (必需) 入参字符串
    * @returns boolean true/false：是Email则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnIsEmail(_sInputs);
    * </pre>
    */
   fnIsEmail : function (sInputs) {
      var bflag = true;
      //入参为必需项，需要先进行非空校验。
      if(this.fnIsNull(sInputs,"CFW.oValid.fnIsEmail 入参字符串")){
    	  return false; 
      };
   
      var re = /^(\w-*\.*)+@(\w-?)+(\.\w{2,})+$/;
      if(!re.test(sInputs)){
    	  return false;
      }
      return bflag;
   },
   
   /**
    * 判断输入是否含有中文
    * @param   String sInputs (必需) 入参字符串
    * @returns boolean true/false：含有中文则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnHasChinese(_sParam);
    * </pre>
    */
   fnHasChinese : function (sInputs) {
	  var sInputs = sInputs || "";
      if(escape(sInputs).indexOf("%u") != -1) { 
         return true; 
      } 
      return false; 
   },
      
   /**
    * 判断输入是否全为中文 ，如果有空格则返回false并提示
    * @param   String sInputs (必需) 入参字符串
    * @returns boolean true/false：全为中文则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnIsAllChinese(_sParam);
    * </pre>
    */
   fnIsAllChinese : function (sInputs) {
	  //入参为必需项，需要先进行非空校验。
	  if(this.fnIsNull(sInputs,"CFW.oValid.fnIsAllChinese 入参字符串")){
	     return false; 
	  };
      if(/[^\u4E00-\u9FA5]/gi.test(sInputs)) {      
         return false;
      }
      return true;
   },
   
   /**
    * 判断输入是否含有空格，如果有空格则返回false并提示
    * @param   String sInputs (必需) 入参字符串
    * @returns boolean true/false：含有空格则返回false，否则返回true
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnHasBlank(_sParam);
    * </pre>
    */
   fnHasBlank : function (sInputs) {
      var strlength; 
      var k; 
      var ch;
      //入参为必需项，需要先进行非空校验。
	  if(this.fnIsNull(sInputs,"CFW.oValid.fnIsAllChinese fnHasBlank")){
		 return false; 
	  };
      strlength = sInputs.length; 
      for(k = 0 ; k <= strlength ; k++) { 
         ch = sInputs.substring(k,k+1); 
         if(ch == " ") { 
            CFW.oWin.fnAlert("对不起　不能输入空格　"); 
            return false; 
         } 
      } 
      return true; 
   },
   
   /**
    * 判断输入是否为年月(格式：YYYYMM)
    * @param   String sInputs (必需) 入参字符串
    * @returns boolean true/false：是年月则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnIsNY(_sParam);
    * </pre>
    */
   fnIsNY : function (sInputs) {
	  //入参为必需项，需要先进行非空校验。
	  if(this.fnIsNull(sInputs,"CFW.oValid.fnIsNY 入参字符串")){
         return false; 
	  };
	  //入参长度校验
	  if(!this.fnIsLen(sInputs,6)){
	     return false; 
	  };
      var yy = sInputs.substring(0,4);
      var mm = sInputs.substring(4,6);
      
      if(!this.fnIsInteger(yy)) return false;
      if(!this.fnIsInteger(mm)) return false;
      if(yy < "1900" || yy > "2999") return false;
      if(mm < "01" || mm > "12") return false;
      
      return true;
   },
   
   /**
    * 判断输入是否为日期
    * @param String sInputs (必需) 日期字符串，格式包括：yyyyMM,yyyy-MM,yyyymmdd,yyyy-mm-dd, yyy-MM-dd hh:mi:ss 且为合法的日期，
    * 以及去掉入参中-,/,空格后,为yyyyMMddhhmiss这种样式中的从左到右的6、7、8、10、19、14中的一种
    * @param String sFormat 日期格式字符串：可按指定格式校验传入的日期字符串 是否符合指定的格式，格式范围见上文。如果为空，则只要符合以上任意格式即可。
    * @returns boolean true/false：是日期则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnIsDate(_sParam);
    * </pre>
    */
   fnIsDate : function (sInputs,sFormat) {
	  //入参为必需项，需要先进行非空校验。
	  if(this.fnIsNull(sInputs,"CFW.oValid.fnIsDate 日期字符串")){
         return false; 
	  };
      var tempStrArr =sInputs.split(" ");
      var tempStr ;
      tempStr = sInputs.replace(/-/g,''); //去除入参 sInputs中的 - 
      tempStr = tempStr.replace(/\//g,'');//去除入参 sInputs中的 / 
      tempStr = tempStr.replace(/:/g,'');//去除入参 sInputs中的 :
      tempStr = tempStr.replace(/ /g,'');//去除入参 sInputs中的 空格
      
      var length = tempStr.length;//去除以上字符后，计算入参长度，根据长度调用不同的方法，进行相应判断
      if(this.fnIsNull(sFormat)){//日期格式为空时，
         if(length == 0) {
            return false ;
         } else if(length == 6) {//去除以上字符后，yyyyMM 格式
        	if (this._fnIsDateShort(sInputs)||this.fnIsNY(sInputs)){
               return true;
            }
         } else if(length == 8) {//去除以上字符后，yyyymmdd 格式
            return this._fnIsDate(sInputs) ;
         } else if(length == 14) {//去除以上字符后，yyyymmddhhmiss 格式
        	//yyy-MM-dd hh:mi:ss 
            if(this._fnIsDate(tempStrArr[0])){
               if(this._fnIsDate2(tempStrArr[0])){
                  if(this.fnIsTime(tempStrArr[1])){
                     return true;
                  }
               }
            }
            //yyyymmddhhmiss
            if(sInputs.length= 14 && this._fnIsDate(sInputs.substr(0,8))){
           	   if(this.fnIsTime(sInputs.substr(8,2) + ":" + sInputs.substr(10,2) + ":" + sInputs.substr(12,2))){
           		 return true;
               }
            }
         }
      }else{//如果日期格式字符串 不为空，则按指定的格式校验
         var _sFormat = sFormat.toLowerCase();
         if(_sFormat=="yyyy-mm-dd"){
            return this._fnIsDate2(sInputs) ;
         }else if( _sFormat=="yyyy/mm/dd" || _sFormat=="yyyymmdd"){
            return this._fnIsDate(sInputs) ;
         }else if( _sFormat=="yyyy-mm" ){
            return this._fnIsDateShort(sInputs) ;
         }else if( _sFormat=="yyyymm" ){
            return this.fnIsNY(sInputs) ;
         }else if( _sFormat=="yyyy-mm-dd hh:mi:ss"){//去除以上字符后，yyyymmddhhmiss 格式
            if(this._fnIsDate(tempStrArr[0])){
               if(this._fnIsDate2(tempStrArr[0])){
                  if(this.fnIsTime(tempStrArr[1])){
                     return true;
                  }
               }
            }
         }else if(_sFormat=="yyyymmddhhmiss"){//去除以上字符后，yyyymmddhhmiss 格式
        	 if(this._fnIsDate(sInputs.substr(0,8))){
            	 if(this.fnIsTime(sInputs.substr(8,2) + ":" + sInputs.substr(10,2) + ":" + sInputs.substr(12,2))){
            		 return true;
                  }
             }
          }else{
            CFW.oWin.fnAlert("日期格式"+_sFormat+"错误");
            return false;   
         }
      }
      return false;   
   },
   
   /**
    * 判断输入是否为时间
    * @param   String sInputTime (必需) 入参字符串 格式：hh:mm:ss，且为合法的24小时制时间
    * @returns boolean true/false：是时间则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnIsTime(_sInputs);
    * </pre>
    */
   fnIsTime : function (sInputTime) {
      var hStr;
      var mStr;
      var sStr;
      var h;
      var m;
      var s;
      //入参为必需项，需要先进行非空校验。
      if(this.fnIsNull(sInputTime,"CFW.oValid.fnIsTime 入参字符串")){
         return false; 
      };
      //入参长度校验
	  if(!this.fnIsLen(sInputTime,8)){
	     return false; 
	  };
      if(sInputTime.length == 8)
      {
         if((sInputTime.substring(2,3) == ":") && (sInputTime.substring(5,6) == ":"))
         {
            hStr = sInputTime.substring(0,2);
            mStr = sInputTime.substring(3,5);
            sStr = sInputTime.substring(6,8);
            
            if(!this.fnIsInteger(hStr)) return false ;
            if(!this.fnIsInteger(mStr)) return false ;
            if(!this.fnIsInteger(sStr)) return false ;
            
            h = parseInt(hStr);
            m = parseInt(mStr);
            s = parseInt(sStr);         
            if((h <= 23) && (m <= 59) && (s <= 59))
               return true;
            else
               return false;
         }
         return true; 
      }
      else
      {
         return false;
      }
   },
   
   /**
    * 判断输入是否为日期+时间 格式：yyyy-MM-dd hh:mm:ss，且为合法的日期和合法的24小时制时间
    * @param   String sInputs (必需) 入参字符串 格式：yyyy-MM-dd hh:mm:ss，且为合法的24小时制时间
    * @returns boolean true/false：是日期+时间则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnIsDateTime(_sInputs);
    * </pre>
    */
   fnIsDateTime : function (sInputs) {
      //入参为必需项，需要先进行非空校验。
	  if(this.fnIsNull(sInputs, "CFW.oValid.fnIsDateTime 入参字符串")){
	     return false; 
	  };
	  //入参长度校验
	  if(!this.fnIsLen(sInputs,19)){
	     return false; 
	  };
      var str1 = sInputs.split(" ");
      if(this._fnIsDate(str1[0])){
         if(this._fnIsDate2(str1[0])){
            if(this.fnIsTime(str1[1])){
               return true;
            }
         }
      }
      return false;
   },
   
   /**
    * 判断输入是否为空，
    * 如果sMsg不为空时，在检查sInputs非空失败时提示sMsg+" 不能为空!"，并返回true
    * @param   String sInputs (必需) 入参字符串
    * @param   String sMsg 提示信息 格式："api名称.参数名称"
    * @returns boolean true/false：为空则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnIsNull(_sInputs);
    *     或
    *     var _bSf = CFW.oValid.fnIsNull(_sInputs,sMsg);
    * </pre>
    */
   fnIsNull : function (sInputs,sMsg) {
	   if(sInputs == null){
		   if (sMsg != undefined && sMsg  != null && sMsg != '' ) {
	        	var sError = sMsg +" 不能为空!";
	  			CFW.oWin.fnAlert(sError);
	  	   }
		   return true;
	   }
       if (typeof sInputs == "object" ) {
	       return false;
       }
      var temp;  
      temp = CFW.oStr.fnNub2Str(sInputs);
      try{
        temp = $.trim(temp);
      }catch(e){}
      if(typeof(sInputs) == "undefined" || sInputs == null || (temp == "") || (temp.length == 0)) 
      {
         if (sMsg != undefined && sMsg  != null && sMsg != '' ) {
        	var sError = sMsg +" 不能为空!";
  			CFW.oWin.fnAlert(sError);
  			return true;
  			//throw new Error(sError);
  	     }
         return true;
      }
      return false; 
   },
   
   /**
    * 判断输入是否为数值(包括小数点)
    * @param   String sInputs (必需) 入参字符串
    * @param   int iLength (必需) 表示要判断的小数位数，如4,表示小数点后不能超过4位
    * @returns boolean true/false：是数值则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnCheckFloat(_sInputs);
    * </pre>
    */
   fnCheckFloat : function (sInputs,iLength) {
	  var tmp; 
      var temp;  
      var num;
      tmp = sInputs; 
      
      if(this.fnIsNull(tmp,"CFW.oValid.fnCheckFloat 入参字符串")) return false;
      
      if(this.fnIsNull(iLength,"CFW.oValid.fnCheckFloat 小数位数") || !this.fnIsInteger(iLength)) {
    	  return false;
      }
      
      if(!this.fnIsFloat(tmp)) return false;
      
      num = tmp.indexOf('.') ;
      if(num<0){
    	  return true;
      }
      temp = tmp.substr(num + 1) ;
      
      if((temp + '').length <= iLength) {
    	  return true ;
      }
      return false ; 
   },
   /**
    * 判断输入值长度是否符合要求，
    * 如果sMsg不为空时，在检查sInputs非空失败时提示sMsg +" 长度不等于"+nLen并返回false;
    * @param   String  sInputs (必需) 入参字符串
	* @param   String  iLen (必需)    长度
	* @param   String  sMsg           提示信息
	* @param   boolean bZW            是否为中文(默认为否)，如果选“是”则判断字符的字节长度，选“否”则取字符长度。
    * @returns boolean true/false：长度符合要求则返回true，否则返回false
    * <pre>
    * 使用举例：
    *     var _bSf = CFW.oValid.fnIsLen(_sInputs,_iLen,_sMsg,_bZW);
    * </pre>
    */
   fnIsLen : function (sInputs,iLen,sMsg,bZW){
      var ilenInputs;
      
      ilenInputs = sInputs.length;//默认取字符长度
      
      if (bZW){//如果是中文，则取sInputs的bit长度
    	  ilenInputs = CFW.oStr.fnLengthB(sInputs);
      }
      
      if (ilenInputs != iLen){
    	  if(!this.fnIsNull(sMsg)){
    		  var sError = sMsg +" 长度不等于"+iLen;
    		  CFW.oWin.fnAlert(sError);
    		  throw new Error(sError);
          }
    	  return false;
      }
	  return true;
   },
   /**
    *   (私有方法)判断输入是否为日期,录入的格式可以为yyyy-mm-dd,yyyymmdd,yyyy/mm/dd
    *   @param   String sInputs (必需) 入参字符串
    *   @returns boolean true/false：是日期则返回true，否则返回false
    * <pre>
    * 使用举例：(该组件内容调用)
    *     _fnIsDate(_sInputs);
    * </pre>
    */
   _fnIsDate : function (_sInputs){ 
      var sYear ='';
      var sMonth='';
      var sDay ='';
      var arry;
      var j =0;
      var i =0;
      var s="-";
      
      i = _sInputs.indexOf(s); 
      if(i==-1){s="/";}
      
      i = _sInputs.indexOf(s); 
      if(i==-1){s="";}
      
      if(i>-1){
         j = _sInputs.lastIndexOf(s);
      } 
        
      //yyyy-mm-dd 或  yyyy/mm/dd
      if(i>0 && _sInputs.length != 10){
        return false; 
      }
   
       if(i>0){ 
          
           if((i != 4)||(j != 7)) return false;
          
             arry = _sInputs.split(s);   
            sYear  =arry[0];
            sMonth =arry[1];
            sDay   =arry[2];  
        } 
       
       if(i==-1 && _sInputs.length != 8){
          return false;  
       }
       
      //yyyymmdd
       if(i==-1 && _sInputs.length == 8){
            sYear  =_sInputs.substr(0,4);
            sMonth =_sInputs.substr(4,2);
            sDay   =_sInputs.substr(6);  
       }
           
       if(sDay==""){return false;} 
         
       if(sDay!="" && !this._fnFWIsDate(sYear,sMonth,sDay)){
           return false; 
        }else{
           return true;
        } 
   },
   
   /**
    *   (私有方法)判断输入是否为日期 格式：yyyy-MM-dd，且为合法的日期
    *   @param   String sInputs (必需)
    *   @returns boolean true/false：为空则返回true，否则返回false
    * <pre>
    * 使用举例：(该组件内容调用)
    *     _fnIsDate2(_sInputs);
    * </pre>
    */
   _fnIsDate2 : function (_sInputs){
       _sInputs = _sInputs.replace(/(^\s+)?(\s+$)?/gi, "");
      var strSeparator = "-";
      var strDateArray;
      var intYear;
      var intMonth;
      var intDay;
      var boolLeapYear;
   
      var ln_len=_sInputs.length;
      if(ln_len<8||ln_len>10)  return false;//长度判断
   
      strDateArray = _sInputs.split(strSeparator);
   
      if(strDateArray.length!=3) return false;
   
      intYear = parseInt(strDateArray[0],10);
      intMonth = parseInt(strDateArray[1],10);
      intDay = parseInt(strDateArray[2],10);
   
      if(isNaN(intYear)||isNaN(intMonth)||isNaN(intDay)) return false;
      if(intYear<1900||intYear>2999) return false;
      if(intMonth>12||intMonth<1) return false;
   
      if((intMonth==1||intMonth==3||intMonth==5||intMonth==7||intMonth==8||intMonth==10||intMonth==12)&&(intDay>31||intDay<1)) return false;
   
      if((intMonth==4||intMonth==6||intMonth==9||intMonth==11)&&(intDay>30||intDay<1)) return false;
   
      if(intMonth==2){
         if(intDay<1) return false;
   
         boolLeapYear = false;
         if((intYear%100)==0){
            if((intYear%400)==0) boolLeapYear = true;
         }
         else{
            if((intYear%4)==0) boolLeapYear = true;
         }
   
         if(boolLeapYear){
            if(intDay>29) return false;
         }
         else{
            if(intDay>28) return false;
         }
      }
   
      return true;
   },
   
   /**
    *   (私有方法)判断输入是否为日期 格式：yyyy-MM，且为合法的日期
    *   @param   String sInputs (必需)
    *   @returns boolean true/false：为空则返回true，否则返回false
    * <pre>
    * 使用举例：(该组件内容调用)
    *     _fnIsDateShort(_sInputs);
    * </pre>
    */
   _fnIsDateShort : function (_sInputs){
      var strSeparator = "-";
      var strDateArray;
      var intYear;
      var intMonth;
   
      var ln_len=_sInputs.length;
      if(ln_len<6||ln_len>7)  return false;//长度判断
   
      strDateArray = _sInputs.split(strSeparator);
   
      if(strDateArray.length!=2) return false;
   
      intYear = parseInt(strDateArray[0],10);
      intMonth = parseInt(strDateArray[1],10);
   
      if(isNaN(intYear)||isNaN(intMonth)) return false;
      if(intYear<1900||intYear>2999) return false;
      if(intMonth>12||intMonth<1) return false;
   
   
      return true;
   },
   
   /**
    *   (私有方法)判断输入是否为正常的日期
    *   @param   String sYear (必需)
    *   		 String sMonth (必需)
    *   		 String sDay (必需)
    *   @returns boolean true/false：为空则返回true，否则返回false
    * <pre>
    * 使用举例：(该组件内容调用)
    *     _fnIsDateShort(_sInputs);
    * </pre>
    */
   _fnFWIsDate : function (sYear,sMonth,sDay) {
	   var iYear=0;
	   var iMonth=0;
	   var iDay=0;
		 
	   iYear  = parseInt(sYear,10);
	   iMonth = parseInt(sMonth,10);
	   iDay   = parseInt(sDay,10);
		 
	   var date = new Date(iYear, iMonth - 1, iDay);
	   if (date.getFullYear() != iYear || date.getMonth() + 1 != iMonth || date.getDate() != iDay) return false; // E.g. 31/02/*
				
	   return true;
   },
   /**
    * 身份证校验提示信息，供框架内部的身份证校验函数使用
    */
   _IDCARD_MSG : "",
   /**
    *   (私有方法)只能录入身份证号码。
    *   如果控件的值不合法，则给予提示；如果控件的值是15位，则升为18位
    *   @param   obj 控件dom对象
    *   @returns 
    * <pre>
    * 使用举例：(该组件内容调用)
    *     CFW.oValid._fnFWidcard(obj);
    * </pre>
    */
   _fnFWidcard : function(obj){
		 var str = obj.value;
		 if(str==''){return;}
		 if(_CHECK_IDCARD){
			 var flag=this._fnFWidcardCheck(str);
			 if(!flag){
				 CFW.oTip.fnValidateTip(obj,this._IDCARD_MSG);
			 }else{
				 if(str.length==15){
					 obj.value = this._IDCARD_TRANS;  
				 }
			 }
			 
		 }else{
			 if(!this._fnFWidcardCheck(str)){
				 CFW.oTip.fnValidateTip(obj,this._IDCARD_MSG);
			 }else{
				 if(str.length==15){
					 obj.value = this._fnFWidcar15to18(str);  
				 }
			 }
		 }
	},
	
	/**
	 * (私有方法)只能录入只能录入中文，如果不是中文则给予提示
	 * @param obj dom对象
	 * @returns boolean true/false：如果是中文返回true，否则返回false
	 * <pre>
     * 使用举例：(该组件内容调用)
     *     CFW.oValid._fnFWchiness(obj);
     * </pre>
	 */
	_fnFWchiness : function(obj){
		  var str = obj.value;
		  var sWord ="";
		  var strn ="";
		  var iLen = str.length;
		  if(str==''){return;}
		  if(/[^\u4E00-\u9FA5]/gi.test(str)){ 
			  CFW.oTip.fnValidateTip(obj,'此输入框只能录入中文!');
			  return false;
		  }
		 
		   for(i=0;i<iLen;i++){
			  sWord = str.substr(i,1);
			  if(!(/[^\u4E00-\u9FA5]/gi.test(sWord))){
				   strn=strn+''+sWord;
			  }
		   }
		   obj.value = strn;
		   return true;
	  },
	  _fnIschiness : function(str){
		  var sWord ="";
		  var strn ="";
		  var iLen = str.length;
		  if(str==''){return;}
		  if(/[^\u4E00-\u9FA5]/gi.test(str)){ 
			  return '不是中文!';
		  }
		 
		   for(i=0;i<iLen;i++){
			  sWord = str.substr(i,1);
			  if(!(/[^\u4E00-\u9FA5]/gi.test(sWord))){
				   strn=strn+''+sWord;
			  }
		   }
		   var value = strn;
		   return true;
	  },
	  
	  /**
		 * (私有方法)只能录入只能录入数值，如果不是数值则给予提示
		 * @param obj dom对象
		 * @returns boolean true/false：如果是数字返回true，否则返回false
		 * <pre>
	     * 使用举例：(该组件内容调用)
	     *     CFW.oValid._fnFWnumber(obj);
	     * </pre>
		 */
	  _fnFWnumber: function(obj){
	      var str;
	      var iValue=0;
	      var sWord='';
		  var reg;
		  str = obj.value;
		  
	     if(str==''||str== null){return;}
	     
	     sWord = str.substr(0,1);

	     if(sWord!='-'){
	    	 reg= /^(([1-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$/;
	     }
	     else{
	    	//负浮点数   
	    	 reg= /^(-(([1-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/;
	     }
	      if(!reg.test(str)){
	    	  CFW.oTip.fnValidateTip(obj,'此输入框只能录入数值!'); 
			  return false;
		  } 

		obj.value =parseFloat(str,10); 
		return true;
	  },
	  /**
		 * (私有方法)只能录入只能录入数值，如果不是数值则给予提示
		 * @param obj dom对象
		 * @returns boolean true/false：如果是数字返回true，否则返回false
		 * <pre>
	     * 使用举例：(该组件内容调用)
	     *     CFW.oValid._fnFWnumber(obj);
	     * </pre>
		 */
	  _fnIsNumber: function(str){
	     if(str==''||str== null){return;}
	     
	     sWord = str.substr(0,1);

	     if(sWord!='-'){
	    	 reg= /^(([1-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$/;
	     }
	     else{
	    	//负浮点数   
	    	 reg= /^(-(([1-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/;
	     }
	      if(!reg.test(str)){
	    	  return '不是数字!'; 
		  } 
          var value=parseFloat(str,10); 
		return true;
	  },
	  /**
		 * (私有方法)只能录入只能录入年月，如果不是年月则给予提示
		 * @param obj dom对象
		 * @returns boolean true/false：如果是年月返回true，否则返回false
		 * <pre>
	     * 使用举例：(该组件内容调用)
	     *     CFW.oValid._fnFWyearmonth(obj);
	     * </pre>
		 */
	  _fnFWyearmonth :function(obj){
		   var reg;
		   var str = obj.value; 

		   if(str==''){return true;}
		   if(str.length != 6){
			   CFW.oTip.fnValidateTip(obj,'此输入框只能录入年月!'); 
			      obj.value='';
				  return false;
			   }
		   reg= /^([1-9][0-9]{3}[0-1][0-9])$/;
		   if(!reg.test(str)){
			   CFW.oTip.fnValidateTip(obj,'此输入框只能录入年月!');
				    obj.value=''; 
				  return false;
			  }
			  
		   var mm=str.substring(4,6);	   
		   if(mm<"01"||mm>"12"){
			   CFW.oTip.fnValidateTip(obj,'此输入框只能录入年月!');
				    obj.value=''; 
				  return false;
		   } 
		   return true;
	   },
	   /**
		 * (私有方法)只能录入只能录入日期，如果不是日期则给予提示
		 * @param obj dom对象
		 * @param sFormat 日期格式，例如yyyy-mm-dd，dd/mm/yyyy等。
		 * @returns boolean true/false：如果是日期返回true，否则返回false
		 * <pre>
	     * 使用举例：(该组件内容调用)
	     *     CFW.oValid._fnFWdatebox(obj,sFormat);
	     * </pre>
		 */
	   _fnFWdatebox: function(obj,sFormat){
	  	   var reg;
	  	   var arry; 
	  	   var sYear,sMonth,sDay;
	  	   var str = obj.value; 
	  	   if(str==''){return true;}
	  	   if(sFormat==''){sFormat='yyyy-mm-dd';}
	   
	  	   if(sFormat=='yyyy-mm-dd'||sFormat=='YYYY-MM-DD'){
	  		   arry = str.split('-');	
	  		   if(arry.length==3){
	  			   sYear  =arry[0];
	  			   sMonth =arry[1];
	  			   sDay   =arry[2]; 
	  			   if(sDay.length==1){sDay='0'+sDay;}
	  			   if(sMonth.length==1){sMonth='0'+sMonth;}
	  			   str=sYear+'-'+sMonth+'-'+sDay;
	  		   } 
	  	   } 
	  	   if(sFormat=='yyyy/mm/dd'||sFormat=='YYYY/MM/DD'){
	  		   arry = str.split('/');	
	  		   if(arry.length==3){
	  			   sYear  =arry[0];
	  			   sMonth =arry[1];
	  			   sDay   =arry[2]; 
	  			   if(sDay.length==1){sDay='0'+sDay;}
	  			   if(sMonth.length==1){sMonth='0'+sMonth;}
	  			   str=sYear+'/'+sMonth+'/'+sDay;
	  		   } 
	  	   } 
	  	   if(sFormat=='dd-mm-yyyy'||sFormat=='DD-MM-YYYY'){
	  		   arry = str.split('-');	
	  		   if(arry.length==3){
	  			   sYear  =arry[2];
	  			   sMonth =arry[1];
	  			   sDay   =arry[0]; 
	  			   if(sDay.length==1){sDay='0'+sDay;}
	  			   if(sMonth.length==1){sMonth='0'+sMonth;}
	  			   str=sDay+'-'+sMonth+'-'+sYear;
	  		   } 
	  	   }   
	  	   if(sFormat=='dd/mm/yyyy'||sFormat=='DD/MM/YYYY'){
	  		   arry = str.split('/');	
	  		   if(arry.length==3){
	  			   sYear  =arry[2];
	  			   sMonth =arry[1];
	  			   sDay   =arry[0]; 
	  			   if(sDay.length==1){sDay='0'+sDay;}
	  			   if(sMonth.length==1){sMonth='0'+sMonth;} 
	  			   str=sDay+'/'+sMonth+'/'+sYear;
	  		   } 
	  	   } 
	  	 

	  	   if(!this._fnFWdateFormat(str,sFormat)){
	  		   CFW.oTip.fnValidateTip(obj,'输入的日期不正确 格式为 ' + sFormat);
	  		  obj.value=''; 
	  		  return false; 
	         }else{
	    	      obj.value = str;
	         } 
	  	   
	  	   return true;
	     },
	     
	    /**
		 * (私有方法)只能录入只能录入日期时间，如果不是日期时间则给予提示
		 * @param obj dom对象
		 * @returns boolean true/false：如果是日期时间返回true，否则返回false
		 * <pre>
	     * 使用举例：(该组件内容调用)
	     *     CFW.oValid._fnFWdatetime(obj);
	     * </pre>
		 */
	     _fnFWdatetime: function(obj){
	     	  var sFormat='yyyy-mm-dd';
	     	  var arry;
	     	  var str = obj.value;
	     	  var sDate ="";
	     	  var sTime ="";
	     	  if(str==''){return true;}
	     	  
	     	  arry =str.split(' ');
	     	  
	     	  if(arry.length!=2){
	     		  CFW.oTip.fnValidateTip(obj,'输入的时间不正确 格式为 yyyy-mm-dd hh:mm:ss');
	     		  obj.value=''; 
	     		  return false; 
	     	  }
	     	  
	     	  sDate = arry[0];
	     	  sTime = arry[1];
	     	  
	     	   if(!this._fnFWdateFormat(sDate,sFormat)){
	     		   CFW.oTip.fnValidateTip(obj,'录入的时间不正确 格式为 yyyy-mm-dd hh:mm:ss');
	     			  obj.value=''; 
	     			  return false; 
	     	   }
	     	 
	     	   if(!this._fnFWtimeFormat(sTime)){
	     		   CFW.oTip.fnValidateTip(obj,'时间不正确 格式为 yyyy-mm-dd hh:mm:ss');
	     			  obj.value=''; 
	     			  return false; 
	     	   }
	     	   
	     	   return true;
	       },
	       /**
			 * (私有方法)只能录入只能录入时间，如果不是时间则给予提示
			 * @param obj dom对象
			 * @returns boolean true/false：如果是时间返回true，否则返回false
			 * <pre>
		     * 使用举例：(该组件内容调用)
		     *     CFW.oValid._fnFWtimebox(obj);
		     * </pre>
			 */
	       _fnFWtimebox : function(obj){
	     	  var arry;
	     	  var reg;
	     	  var bTF=false;
	     	  var sHour ="";
	     	  var sMinute ="";
	     	  var str = obj.value;
	     	  
	     	  if(str==''){return;}
	     	  if(str.length<5||str.length>8){
	     		  bTF = false;   
	     	  }
	     	  if(str.length==5){
	     		str=str+":00";  
	     	  }
	     	  
	     	  if(bTF){
	     	    reg= /^([0-2][0-9][:][0-6][0-9][:][0-6][0-9])$/;
	     	    bTF = reg.test(str);
	     	  }	
	     	   
	     	  bTF = this._fnFWtimeFormat(str);
	     		  
	     	  if(!bTF){
	     		  CFW.oTip.fnValidateTip(obj,'时间不正确 格式为 hh:mm:ss');
	     		  obj.value=''; 
	     	     return false; 
	     	  }
	     	   
	     	  
	     	  obj.value= str;
	     	  return true;
	       },
	       /**
			 * 校验时间格式是否正确
			 * @param obj dom对象
			 * @returns boolean true/false：如果是合法时间返回true，否则返回false
			 * <pre>
		     * 使用举例：(该组件内容调用)
		     *     CFW.oValid._fnFWtimeFormat(str);
		     * </pre>
			 */
	       _fnFWtimeFormat : function(str){
	    		 var reg;
	    		 var arry;
	    		 
	    		 var sHour;
	    		 var sMinute;
	    		 var sSecond;
	    		 
	    		 var iHour=0;
	    		 var iMinute=0;
	    		 var iSecond=0;
	    		 
	    		 reg= /^([0-2][0-9][:][0-6][0-9][:][0-6][0-9])$/;
	    		 if(!reg.test(str)){
	    		     return false; 
	    	     } 
	    		 
	    		 arry = str.split(":");
	    		 sHour   = arry[0];
	    		 sMinute = arry[1];
	    		 sSecond = arry[2];
	    		 
	    		 iHour =  parseInt(sHour,10);
	    		 iMinute = parseInt(sMinute,10);
	    		 iSecond  = parseInt(sSecond,10);
	    		 
	    		 if(iHour<0||iHour>24){return false;}
	    		 if(iMinute<0||iMinute>60){return false;} 
	    		 if(iSecond<0||iSecond>60){return false;} 
	    		 
	    		 
	    		return true; 
	    	 },
	    	/**
			 * 校验日期格式是否正确
			 * @param str 字符串,日期
			 * 支持的校验日期的格式
	    	 * yyyy-mm-dd、yyyy/mm/dd、yyyymmdd、
	    	 * dd-mm-yyyy、 dd/mm/yyyy、ddmmyyyy
			 * @returns boolean true/false：如果是合法日期返回true，否则返回false
			 * <pre>
		     * 使用举例：(该组件内容调用)
		     *     CFW.oValid._fnFWdateFormat(str);
		     * </pre>
			 */
	    	 
	    	 _fnFWdateFormat:  function(str,sFormat){
	    		 var reg;
	    		 var arry;
	    		 var sYear,sMonth,sDay; 
	    		 
	    			//默认的格式
	    		 if(sFormat=='yyyy-mm-dd'||sFormat=='YYYY-MM-DD'||sFormat==''){
	    			   arry = str.split('-');	
	    			   if(arry.length==3){
	    				   sYear  =arry[0];
	    				   sMonth =arry[1];
	    				   sDay   =arry[2]; 
	    				   str=sYear+'-'+sMonth+'-'+sDay;
	    			   } 
	    			   reg= /^([1-9][0-9]{3}[-][0-1][0-9][-][0-3][0-9])$/;
	    			   if(sFormat==''){sFormat='yyyy-mm-dd';}
	    		   } 
	    		  
	    		   
	    	     //yyyymmdd
	    		   if(sFormat=='yyyymmdd'||sFormat=='YYYYMMDD'){
	    			   if(str.length==8){
	    				   sYear  =str.substr(0,4);
	    				   sMonth =str.substr(4,2);
	    				   sDay   =str.substr(6,2); 
	    			   } 
	    			   reg= /^([1-9][0-9]{3}[0-1][0-9][0-3][0-9])$/;
	    		   } 
	    		   
	    			// dd-mm-yyyy   
	    		   if(sFormat=='dd-mm-yyyy'||sFormat=='DD-MM-YYYY'){
	    			   arry = str.split('-');	
	    			   if(arry.length==3){
	    				   sYear  =arry[2];
	    				   sMonth =arry[1];
	    				   sDay   =arry[0]; 
	    				   str=sDay+'-'+sMonth+'-'+sYear;
	    			   } 
	    			   reg= /^([0-3][0-9][-][0-1][0-9][-][1-9][0-9]{3})$/;
	    		   } 

	    	 
	    		    
	    		    //ddmmyyyy
	    		   if(sFormat=='ddmmyyyy'||sFormat=='DDMMYYYY'){
	    			   if(str.length==8){
	    				   sYear  =str.substr(4,4);
	    				   sMonth =str.substr(2,2);
	    				   sDay   =str.substr(0,2); 
	    			   } 
	    			   reg= /^([0-3][0-9][0-1][0-9][1-9][0-9]{3})$/;
	    		   } 
	    		   
	    		   if(sFormat == 'yyyy-mm' || sFormat == 'YYYY-MM'){
	    			   if(str.length==7){
	    				   sYear  = str.substr(0,4);
	    				   sMonth = str.substr(5,2);
	    				   sDay   = 1+""; 
	    			   } 
	    			   str = str + "-01";
	    			   reg= /^([1-9][0-9]{3}[-][0-1][0-9][-][0-3][0-9])$/;
	    		   }

	    		  if(!reg.test(str)){
	    			     return false; 
	    		  } 
	    		 if(!this._fnFWIsDate(sYear,sMonth,sDay)){
	    			  return false; 
	    	     }else{
	    		      return true;
	    	     } 
	    	 },
	    	 /**
			 * 校验校验身份证号码是否正确
			 * @param str 身份证号码
			 * @returns boolean true/false：如果是合法日期返回true，否则返回false
			 * <pre>
		     * 使用举例：(该组件内容调用)
		     *     CFW.oValid._fnFWidcardCheck(str);
		     * </pre>
			 */
	    	 _fnFWidcardCheck: function(str){
	              if(_CHECK_IDCARD){//通过后台校验身份证号
	            	  var sGmsfz='';
	            	  var sFhz='';
	            	  var sMsg='';
	            		var mParams = {
	            	            "PI_GMSFZ" : str
	            	        };
	            		var obj=this;
	            		CFW.oAJax.doProc("PKG_FW_PUB.CHECK_GMSFZ", mParams, '',
	            	            function(mData) {
	            			       sFhz=mData[0].PO_FHZ;
	            			       if(sFhz=='1'){
	            			    	   sGmsfz=mData[0].PO_GMSFZ;
	            			       }else{
	            			    	   sMsg=mData[0].PO_MSG;
	            			       }
	            	            },
	            	            function(sMsg){
	            	            },
	            	            false
	            	        );
	            		if(sFhz=='1'){
	            			this._IDCARD_TRANS=sGmsfz;
	            			return true;
	            		}else{
	            			this._IDCARD_MSG=sMsg;
	            			return false;
	            		}
	              }else{
	            	  var i;
	 	    		 var reg;
	 	    		 var temp;
	 	    		 var format;
	 	    		 var year,month,day;
	 	    		   
	 	    		 format = str.length; 
	 	    		 
	 	    	     reg= /^([0-9]{15}|[0-9]{17}[0-9]|[0-9]{17}[xX])$/;
	 	    		 
	 	    		 if(!reg.test(str)){
	 	    			 this._IDCARD_MSG="公民身份号码输入不合法";
	 	    		     return false; 
	 	    	     }  
	 	    		  
	 	    		  if(format==18){

	 	    	          temp=str.substring(6,10);
	 	    	          year=parseInt(temp,10);
	 	    	          if(year<1900 || year>2200){
	 	    	        	 this._IDCARD_MSG="年份应介于1900与2200之间，请重新输入！";
	 	    	             return false;
	 	    	          }

	 	    	        }
	 	    	        else if(format==15){
	 	    	          temp=str.substring(6,8);
	 	    	          year=parseInt(temp,10);
	 	    	          if(year<00 || year>99){
	 	    	        	  this._IDCARD_MSG="年份应介于00与99之间，请重新输入！";
	 	    	             return false;
	 	    	          }
	 	    	        }
	 	    	 
	 	    	        if(format==18){
	 	    	          temp=str.substring(10,12);
	 	    	        }
	 	    	        else if(format==15){
	 	    	          temp=str.substring(8,10);
	 	    	        }

	 	    	        month=parseInt(temp,10);
	 	    	        
	 	    	        if(month<1 ||month>12){
	 	    	        	this._IDCARD_MSG="月份必须介于1与12之间！";
	 	    	            return false;
	 	    	        }


	 	    	        if(format==18){
	 	    	           temp=str.substring(12,14);
	 	    	        }
	 	    	        else if(format==15){
	 	    	          temp=str.substring(10,12);
	 	    	        }
	 	    	         
	 	    	        day=parseInt(temp,10);
	 	    	        
	 	    	        if((day==0)||(day>31)){
	 	    	        	this._IDCARD_MSG="日必须介于0与31之间！";
	 	    	            return false;
	 	    	        }else if(day>28 && day<31){
	 	    	                if(month==2){
	 	    	                        if(day!=29){
	 	    	                        	   this._IDCARD_MSG= year+"年"+month+"月无"+day+"日。";
	 	    	                                return false;
	 	    	                        }
	 	    	                        else {
	 	    	                                if((year%4)!=0){
	 	    	                                	this._IDCARD_MSG=year+"年"+month+"月无"+day+"日。";
	 	    	                                    return false;
	 	    	                                 }
	 	    	                                 else {
	 	    	                                        if((year%100==0)&&(year%400!=0)){
	 	    	                                        	   this._IDCARD_MSG=year+"年"+month+"月无"+day+"日。";
	 	    	                                               return false;
	 	    	                                        }
	 	    	                                 }
	 	    	                        }
	 	    	                }
	 	    	        } 
	 	    	        else if(day==31){
	 	    	                if((month==2)||(month==4)||(month==6)||(month==9)||(month==11)){
	 	    	                	  this._IDCARD_MSG=month+"月无"+day+"日";
	 	    	                      return false;
	 	    	                }
	 	    	        }
	 	    	  
	 	    		  //15位转18位
	 	    		  if(format==15){
	 	    			  str = this._fnFWidcar15to18(str);  
	 	    			  format = 18;
	 	    		  }
	 	    		 
	 	    		  //18位
	 	    		  if(format==18){
	 	    		   
	 	    			i=(str.substr(0,1)*7+str.substr(1,1)*9+str.substr(2,1)*10+str.substr(3,1)*5+str.substr(4,1)*8+str.substr(5,1)*4+str.substr(6,1)*2+str.substr(7,1)*1+str.substr(8,1)*6+str.substr(9,1)*3+str.substr(10,1)*7+str.substr(11,1)*9+str.substr(12,1)*10+str.substr(13,1)*5+str.substr(14,1)*8+str.substr(15,1)*4+str.substr(16,1)*2 )% 11 ;
	 	    		    if(i>2)i=12-i;
	 	    		    else if(i==2)i="X";
	 	    		    else if(i<2)i=1-i;
	 	    		    
	 	    		    if(str.substr(17,1)==i){ 
	 	    		    	return true;
	 	    		    }
	 	    		    else
	 	    		    {
	 	    		       this._IDCARD_MSG="公民身份号码输入不合法,校验位错误! ";
	 	    		       return false;
	 	    		    }
	 	    		    
	 	    		  }
	              }
		    		
		    		    
		    	},
	    	/**
			 * 身份证号码15位转18位
			 * @param str 身份证号码
			 * @returns 返回18位身份证
			 * <pre>
		     * 使用举例：(该组件内容调用)
		     *     CFW.oValid._fnFWidcar15to18(str);
		     * </pre>
			 */
	    	_fnFWidcar15to18 : function(str){
	    	              var getno=str;
	    	 
	    	 	           if(getno.length==15){
	    	 		           var wi=new Array(7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2,1); 
	    	 		           var ai=new Array(1,0,'X',9,8,7,6,5,4,3,2); 
	    	 		           var F1=getno.substr(0,6)+"19"+getno.substr(6,15); 
	    	 		           var F2=new Array();
	    	 		           
	    	 		           F2=F1.split("");
	    	 
	    	 		           var i=0;
	    	 		           var j=0;
	    	 		           var sum =0;
	    	 		           for(i = 0 ; i<17; i++)
	    	 					{
	    	 						j = wi[i]*F2[i];
	    	 						sum = sum + j; 
	    	 					}
	    	 
	    	 					sum=sum%11; 
	    	 					F2[17]=ai[sum];

	    	 					var F3=new String();
	    	 					for(i=0;i<18;i++){
	    	 						if(F2[i]=='X'){
	    	 							F3=F3+"X";
	    	 							break;
	    	 						}
	    	 						F3=F3+''+F2[i];
	    	 					}
	    	 					this._IDCARD_MSG="身份证自动升位为"+F3;
	    	 					return F3; 
	    	 	           }else{ 
	    	 	           		return str;
	    	 	           } 
	    	 },
	    	 /**
			 * 校验控件元素，供框架内部使用
			 * @param obj 控件元素对象
			 * @returns boolean 校验结果,true/false
			 * <pre>
		     * 使用举例：(该组件内容调用)
		     *     CFW.oValid._fnFWelementValidate(ele);
		     * </pre>
			 */
	    	 _fnFWelementValidate: function(obj){
	    	 	var readOnly = $(obj).attr('readOnly');
	    	 	if ( $(obj).attr('vldStr')==null){
	    	 		return null;
	    	 	}else if(readOnly){
	    	 		return null;
	    	 	}
	    	 	colName =  $(obj).attr('name');// 字段的名称
	    	 	validStrs = $(obj).attr('vldStr');
	    	 	
	    	 	if($(obj).hasClass('postbox')){
	    	 		var s = obj.value;
	    	 		if(s.length>0&&s.length!=6){
	    	 			return '邮政编码字段不合法！';
	    	 		} 
	    	 	}
	    	 	 
	    	 	name_validStrs = validStrs.split('=');// 得到字段的中文名称
	    	 	if (name_validStrs.length == 2){
	    	 		colName = name_validStrs[0];
	    	 		validStrs = name_validStrs[1];
	    	 		pint=parseInt(obj.value,10);
	    	 		pfloat=parseFloat(obj.value,10);
	    	 	}
	    	 	tmpArray = validStrs.split('+');
	    	 	for (j = 0; j < tmpArray.length; j ++){//检查该字段的校验类型
	    	 	
	    	 		if (tmpArray[j] == 'nn' && this.fnIsNull(obj.value) && obj.value == ''){//有非空却为空的字段
	    	 			return '不能为空！';
	    	 		}else if(tmpArray[j] == 'n' && !this.fnIsNull(obj.value) && !CFW.oValid.fnIsInteger(obj.value)){//有不合法的数字型字段
	    	 			return '数字不合法！';
	    	 		}else if(tmpArray[j] == 'h' && !this.fnIsNull(obj.value)){//有不合法的身高型字段
	    	 			if(CFW.oValid.fnIsInteger(obj.value) && (pint>0) && (pint<300)){
	    	 			}else{
	    	 				return '身高不合法！';
	    	 			}
	    	 		}else if(tmpArray[j] == 'w' && !this.fnIsNull(obj.value)){//有不合法的体重型字段
	    	 			if(CFW.oValid.fnIsInteger(obj.value) && (pint>0) && (pint<200)){
	    	 			}else{
	    	 				return '体重不合法！';
	    	 			}
	    	 		}else if(tmpArray[j] == 'a' && !this.fnIsNull(obj.value)){//有不合法的年龄型字段
	    	 			if(CFW.oValid.fnIsInteger(obj.value) && (pint>0) && (pint<200)){
	    	 			}else{
	    	 				return '年龄不合法！';
	    	 			}
	    	 		}else if(tmpArray[j] == 'alm' && !this.fnIsNull(obj.value)){//有不合法的法定男性年龄型字段
	    	 			if(CFW.oValid.fnIsInteger(obj.value) && (pint>=16) && (pint<=60)){
	    	 			}else{
	    	 				return '法定男性年龄(16~60)不合法！';
	    	 			}
	    	 		}else if(tmpArray[j] == 'alf' && !this.fnIsNull(obj.value)){//有不合法的法定女性年龄型字段
	    	 			if(CFW.oValid.fnIsInteger(obj.value) && (pint>=16) && (pint<=55)){
	    	 			}else{
	    	 				return '法定女性年龄(16~55)不合法！';
	    	 			}
	    	 		}else if(tmpArray[j] == 'p' && !this.fnIsNull(obj.value)){//有不合法的邮政编码型字段
	    	 			if(CFW.oValid.fnIsInteger(obj.value) && (obj.value.length == 6)){
	    	 			}else{
	    	 				return '邮政编码不合法！';
	    	 			}
	    	 		}else if(tmpArray[j]=='ml' && !this.fnIsNull(obj.value) && !CFW.oValid.fnIsEmail(obj.value)){//有不合法的邮箱字段
	    	 			return 'email地址不合法！';
	    	 		}else if(tmpArray[j] == 't' && !this.fnIsNull(obj.value) && !CFW.oValid.fnIsPhoneNumber(obj.value)){//有不合法的电话号码型字段
	    	 			return '电话号码不合法！(格式示例：+86020-12345678)';
	    	 		}else if(tmpArray[j] == 'd' && !this.fnIsNull(obj.value) && !CFW.oValid.fnIsDate(obj.value)){//有不合法的日期型字典
	    	 			return '日期不合法！(格式示例：2005-05-05)';
	    	 		}else if(tmpArray[j] == 'dl' && !this.fnIsNull(obj.value) && !CFW.oValid.fnIsDateTime(obj.value)){//有不合法的(YYYY-MM-DD HH24:MI:SS)日期型字典
	    	 			return '日期不合法！(格式示例：2005-05-05 23:59:59)';
	    	 		}else if(tmpArray[j] == 'ds' && !this.fnIsNull(obj.value) && !CFW.oValid._fnIsDateShort(obj.value)){//有不合法的(YYYY-MM)日期型字典
	    	 			return '日期不合法！(格式示例：2005-05)';
	    	 		}else if(tmpArray[j] == 'dc' && !this.fnIsNull(obj.value) && !CFW.oValid.fnIsDateClose(obj.value)){//有不合法的(YYYYMM)日期型字典
	    	 			return '日期不合法！(格式示例：200505)';
	    	 		}else if(tmpArray[j] == 'dt' && !this.fnIsNull(obj.value) && !CFW.oValid.fnIsTime(obj.value)){//有不合法的(HH24:MI:SS)时间型字典
	    	 			return '日期不合法！(格式示例：23:59:59)';
	    	         }else if(tmpArray[j] == 'ac' && !this.fnIsNull(obj.value) && !CFW.oValid.fnIsAllChinese(obj.value)){//不合法的纯中文字符串
	    	 			return '纯中文字符串不合法！';
	    	         }else if(tmpArray[j] == 'nc' && !this.fnIsNull(obj.value) && CFW.oValid.fnHasChinese(obj.value)){//不合法的非中文字符串
	    	 			return '非中文字符串不合法！';
	    	 		}else if(tmpArray[j] == 'sfz' && !this.fnIsNull(obj.value) && !CFW.oStr.fnValidSfzh(obj.value)){//有不合法的身份证型字段
	    	 			return '身份证不合法！';
	    	 		}else if(tmpArray[j] == 's'&& !this.fnIsNull(obj.value)){//有不合法的视力型字段
	    	 			if(this.fnCheckFloat(obj.value, 1) && (((pfloat>=0.1) && (pfloat<=1.5))||((pfloat>=4.0)&&(pfloat<=5.2))) ){
	    	 			}else{
	    	 			return '视力不合法！(示例：0.1~1.5 或者 4.0~5.2)';
	    	 			}
	    	 		}else if(tmpArray[j] == 'c'&& !this.fnIsNull(obj.value)){//有不合法的颜色型字段
	    	 			var c1=obj.value.substr(0,1);
	    	 			var c2=obj.value.substr(1,6);
	    	 			if((obj.value.length==7) && (c1=="#") && (parseInt(c2,16)>=0) && (parseInt(c2,16)<=16777215)){
	    	 			}else{
	    	 			return '颜色不合法！';
	    	 			}
	    	 		}else if(tmpArray[j].substr(0,1) == 'l'){
	    	 			var tmpA1=new String();
	    	 			tmpA=tmpArray[j];
	    	             var bitL;
	    	             if(arguments.length==2){
	    	                 if(options.valLenRule=='char'){
	    	                     bitL=(obj.value).length;
	    	                 }else{
	    	                     bitL=CFW.oStr.fnLengthB(obj.value);
	    	                 }
	    	             }else{
	    	 			    bitL=CFW.oStr.fnLengthB(obj.value);
	    	 			}
	    	 			var tmpAL=tmpA.length;
	    	 			var pos1=tmpA.indexOf("(");
	    	 			var pos2=tmpA.indexOf("-");
	    	 			var pos3=tmpA.indexOf(")");
	    	 			var bitL1=tmpA.substring(pos1+1,pos2);
	    	 			var bitL2=tmpA.substring(pos2+1,pos3);
	    	 			if(bitL!=0){
	    	 				var flag = true;
	    	 				if (pos2 < 0) {
	    	 					var bitL3 = tmpA.substring(pos1+1,pos3);
	    	 					if (CFW.oValid.fnIsInteger(bitL3) && bitL > bitL3) {
	    	 						bitL1 = 0;
	    	 						bitL2 = bitL3;
	    	 						flag = false;
	    	 					}
	    	 				} else if(CFW.oValid.fnIsInteger(bitL1)&&CFW.oValid.fnIsInteger(bitL2)){
	    	 					if(bitL<bitL1||bitL>bitL2){
	    	 						flag = false;
	    	 					}
	    	 				}
	    	 				if (!flag) {
	    	 					return '长度不合法\n（字母或数字长度应在'+bitL1+'和'+bitL2+'之间，\n汉字长度应在'+Math.floor(parseInt(bitL1)/2)+'和'+Math.floor(parseInt(bitL2)/2)+'之间）';
	    	 				}
	    	 			}
	    	 		}else if(tmpArray[j].indexOf('f')!=-1&&tmpArray[j]!='alf'){ //校验浮点型数据类型
	    	 				var tmp  = tmpArray[j];
	    	 			    var len  = tmp.length;
	    	 			    var ips  = tmp.indexOf('f'); 
	    	 			    var str  = "";
	    	 			    var val  = obj.value;
	    	 			    var ixu  =0; //小数位数
	    	 			    var izu  =0; //整数位数
	    	 			    if(val==''){
	    	 			    	return null;
	    	 			    }else{
	    	 			    	val = val.replace(/,/gi,'');	
	    	 			    }
	    	 			    
	    	 			    $(obj).css("text-align","right");
	    	 			    
	    	 			    if(!this.fnIsFloat(val)){return '浮点数字不合法,必须为数值！';}
	    	 			    
	    	 			    if(ips!=-1&&(ips+1)!=len){ 
	    	 				     str = tmp.split('f');
	    	 				     ixu = parseInt(str[1],10);
	    	 				   if(!this.fnCheckFloat(val, ixu)){
	    	 					   return '浮点数字不合法,必须为'+ixu+'位小数！';
	    	 				   }
	    	 			   }else{
	    	 				   var ips2 = val.indexOf('.');  
	    	 				   if(ips2!=-1){ return '浮点数字不合法,不能带有小数!';}
	    	 			   }
	    	 			    
	    	 			    str = tmp.split('f'); 
	    	 			    if(str[0]==''){
	    	 			    	izu = 1;
	    	 			    }else{
	    	 			    	izu = parseInt(str[0],10);
	    	 			    } 

	    	 			    str = val.split('.'); 
	    	 	            tmp = str[0]; 
	    	 			    len = tmp.length;

	    	 			    if(parseInt(len,10) > izu){
	    	 			    	return '浮点数字不合法,不能大于'+izu+'位整数！';
	    	 			    }
	    	 			    
	    	 			    //以下的处理主要是给数值补小数位
	    	 			    len = 0;
	    	 			    if(str[1]!=null){
	    	 			       tmp = str[1];
	    	 			       len = tmp.length; 
	    	 			    }
	    	 			    
	    	 				if(ixu!=len){
	    	 					tmp ='';
	    	 		    		 for(i=len;i<ixu;i++){
	    	 		    		   tmp+='0';
	    	 		    		 }
	    	 		    		 val = obj.value;
	    	 		    		 str = val.split('.');
	    	 		    		 if(str[1]!=null){
	    	 		    		   obj.value = str[0]+'.'+str[1]+tmp;
	    	 		    		 }else{
	    	 		    		   obj.value = str[0]+'.'+tmp;
	    	 		    		 }
	    	 		    	 }
	    	 				 
	    	 			  
	    	 		 }
	    	 			  
	    	 	}//for
	    	 	return null;
	    	 },

	    	 /**
			 * 只允许录入数值  
			 * @param e 事件event
			 * @returns boolean 校验结果,true/false
			 * <pre>
		     * 使用举例：(该组件内容调用)
		     *     CFW.oValid._fnFWNumOnly(ele);
		     * </pre>
			 */
	    	 _fnFWNumOnly: function(e){
	    	 	
	    	 	   //王码五笔字形无法录入数字的问题
	    	 	   if(e.keyCode==229){
	    	 		   return true;
	    	 	   }
	    	 	   
	    	 	   //左移动
	    	 	   if(e.keyCode==37){
	    	 	       return true;
	    	 		}
	    	 		   
	    	 		//右移动
	    	 		if(e.keyCode==39){
	    	 			return true;
	    	 		}
	    	 		   
	    	 	 //小键盘的数字区
	    	 	   if(e.keyCode >= 96 && e.keyCode <= 105){
	    	 		   return true;
	    	 	   }  
	    	 	   //键盘的数字区
	    	 		if ((e.keyCode >= 48 && e.keyCode <= 57 && e.ctrlKey == false && e.shiftKey == false)){
	    	 			return true;
	    	 		}   
	    	 	return false; 
	    	 },
	    	 /**
			 * 是否为0或正整数
			 * @param sInputVal 被校验的字符串
			 * @returns boolean 校验结果,true/false
			 * <pre>
		     * 使用举例：(该组件内容调用)
		     *     CFW.oValid._fnIs0AndPosInteger(sInputVal);
		     * </pre>
			 */
	    	 _fnIs0AndPosInteger : function(sInputVal){
					 var format=sInputVal.length;
					 if(format==18){
					    var lastChar = sInputVal.charAt(sInputVal.length-1);
					    if(lastChar=="X")
					       sInputVal=sInputVal.substring(0, sInputVal.length-1);
					 }
					 for (var i = 0; i < sInputVal.length; i++) {
					      var oneChar = sInputVal.charAt(i);
					 if (oneChar < "0" || oneChar > "9") {
					      return false;
					      }
					
					 }
					 return true;
	    	 },
	    	 /**
	    	  * 拼音字典缓存
	    	  */
	    	 _PINYIN_DICT_CACHE : PINYIN_DICT_CACHE,

	    	 /**
	    	  * 判断拼音是否匹配中文，支持常用中文字，支持多音字。
	    	  * 原理在于将字符串中的中文的的字符转换成英文字符，再用indexOf判断是否匹配。
	    	  * 例如:
	    	  * CFW.oValid._fnIsPinyinMatch('我爱你','wo'),返回是true
	    	  * CFW.oValid._fnIsPinyinMatch('1-单位','1-da'),返回是true
	    	  * CFW.oValid._fnisPinyinMatch('1-单位','wei'),返回是true
	    	  * CFW.oValid._fnIsPinyinMatch('1-单位','dw'),返回是false，不支持中文首字母搜索，需要完整拼音
	    	  * CFW.oValid._fnIsPinyinMatch('着急','zhe'),返回是true，因为“着”是多音字，
	    	  * @param itemText 需要被匹配的含有中文的字符串
	    	  * @param query    拼音
	    	  * @returns 如果拼音匹配则返回true,否则为false
	    	  */
	    	 _fnIsPinyinMatch : function(itemText,query){
	    		if(itemText==''||itemText==null){return false;}
	    		 
	    	 	//获取存放在左侧树页面的拼音字典
	    	 	if(null == PINYIN_DICT_CACHE){
	    	 	    var twindow = window;
	    	 		while(twindow.dialogArguments!=null){
	    	 			twindow = twindow.dialogArguments;
	    	 		}
	    	 	    try{
	    	 	    	PINYIN_DICT_CACHE = twindow.top.opener.top.frames['TreeMenu'].PINYIN_DICT_CACHE;
	    	 	    }catch(e){
	    	 	    	if(null == twindow.top.frames['TreeMenu']){
	    	 	    		return false;
	    	 	    	}
	    	 	    	PINYIN_DICT_CACHE = twindow.top.frames['TreeMenu'].PINYIN_DICT_CACHE;
	    	 	    	if(null == PINYIN_DICT_CACHE){
	    	 	    		return false;
	    	 	    	}
	    	 	    }
	    	 	}
	    	 	query = query.toLowerCase();
	    	 	var itemTextPinyin = _getPinyin(itemText);
	    	 	var bPinyinMatch = false;
	    	 	for(var i=0,len=itemTextPinyin.length;i<len;i++){
	    	 		if((itemTextPinyin[i].toLowerCase()).indexOf(query)!=-1){
	    	 			bPinyinMatch = true;
	    	 			break;
	    	 		}
	    	 	}
	    	 	return bPinyinMatch;
	    	 	
	    	 	//获取字符串的拼音
	    	     function _getPinyin(hans){
	    	     	//多音字的话，会有多种结果，所以用数组保存
	    	     	var rst = [];
	    	     	
	    	     	var len=hans.length;
	    	     	//r是一个二维数组，每个元素数组，存放一个字符的拼音，多音字的拼音有多个
	    	     	var r = [];
	    	     	var curChar;
	    	     	for(var i=0;i<len;i++){
	    	     		curChar = hans.charAt(i);
	    	     		var pattern = /^([\u4E00-\u9FA5])$/gi;
	    	     		var isCh = pattern.test(curChar);
	    	     		//如果是汉字
	    	     		if(true==isCh){
	    	     			//r.push(this._PINYIN_DICT_CACHE[curChar]);
	    	     			r.push(PINYIN_DICT_CACHE[curChar]==null?[""]:PINYIN_DICT_CACHE[curChar]);
	    	     		}else{
	    	     			r.push([curChar]);
	    	     		}
	    	     	}//for
	    	     	//计算笛卡尔积
	    	     	rst = _descartes(r);
	    	     	return rst;
	    	     }

	    	     //计算笛卡尔积，arr是二维数组，数组的每个元素都是是一个包含一个或多个字符串的数组
	    	     function _descartes(arr){
	    	     	var len=arr.length;
	    	     	if(1 == len){
	    	     		return arr[0];
	    	     	}
	    	     	var d = _descartesTwo(arr[0],arr[1]);
	    	     	for(var i=2;i<len;i++){
	    	     		d = _descartesTwo(d,arr[i]);
	    	     	}
	    	     	return d;
	    	     }
	    	     //计算两个一维数组的笛卡尔积
	    	     function _descartesTwo(arr1,arr2){
	    	     	var rst = [];
	    	     	for(var i=0,len1=arr1.length;i<len1;i++){
	    	     		for(var j=0,len2=arr2.length;j<len2;j++){
	    	     			rst.push(arr1[i]+arr2[j]);
	    	     		}
	    	     	}
	    	     	return rst;
	    	     }
	    	 },
	    	 /**
	    	  *	Purpose: 判断输入是否为日期 格式：yyyyMM，且为合法的日期
	    	  *	Inputs: String 
	    	  *	Returns: True, False 
	    	  */
	    	 fnIsDateClose : function(strDate){
	    		   var strSeparator = "-";
	    		   var strDateArray;
	    		   var intYear;
	    		   var intMonth;
	    		   var intDay;
	    		   var boolLeapYear;
	    		   var charMonth;

	    		   var ln_len=strDate.length;
	    		   if(ln_len!=6)  return false;//长度判断


	    		   intYear = parseInt(strDate.substr(0,4));
	    		   intMonth = parseInt(strDate.substr(4,6));
	    		   charMonth = strDate.substr(4,6);

	    		   if(isNaN(intYear)||isNaN(intMonth)) return false;
	    		   if(intYear<1900||intYear>2999) return false;
	    		   if(charMonth>12||charMonth<1) return false;


	    		   return true;
	    	 }
};