javaScript通用数据类型校验

/**  
* 取得字符串的字节长度  
*/   
function strlen(str)    
{    
  var i;    
  var len;    
     
  len = 0;    
  for (i=0;i<str.length;i++)    
  {    
    if (str.charCodeAt(i)>255) len+=2; else len++;    
  }    
  return len;    
}    
   

/*  
* 判断是否为数字，是则返回true,否则返回false  
*/   
function f_check_number(obj)    
{        
var rgexp = /^\d+$/
  if (rgexp.test(obj.value))    
  {    
    return true;    
  }    
  else    
  {    
    f_alert(obj,'请输入数字');    
    return false;    
  }    
}    
   

/*  
* 判断是否为自然数，是则返回true,否则返回false  
*/   
function f_check_naturalnumber(obj)    
{        
var rgexp =/^[0-9]+$/
  var s = obj.value;    
  if (rgexp.test( s ) && (s > 0))    
  {    
    return true;    
  }    
  else    
  {    
    f_alert(obj,'请输入自然数');    
    return false;    
  }    
}    
   

/*  
* 判断是否为整数，是则返回true,否则返回false  
*/   
function f_check_integer(obj)    
{        
var rgexp =/^(\+|-)?\d+$/
  if (rgexp.test( obj.value ))    
  {    
    return true;    
  }    
  else    
  {    
    f_alert(obj,'请输入整数');    
    return false;    
  }    
}    
   

/*  
* 判断是否为实数，是则返回true,否则返回false  
*/   
function f_check_float(obj)    
{       
var rgexp = /^(\\+|-)?\\d+($|\\.\\d+$)/
  if (rgexp.test( obj.value ))    
  {    
    return true;    
  }    
  else    
  {    
    f_alert(obj,'请输入实数');    
    return false;    
  }    
}    
   

/*  
* 校验数字的长度和精度  
*/   
function f_check_double(obj){    
  var numReg;    
  var value = obj.value;    
  var strValueTemp, strInt, strDec;      
  var dtype = obj.eos_datatype;    
  var pos_dtype = dtype.substring(dtype.indexOf('(')+1,dtype.indexOf(')')).split(',');    
  var len = pos_dtype[0], prec = pos_dtype[1];    
  try    
  {        
    numReg =/[\\-]/;    
    strValueTemp = value.replace(numReg, '');    
    numReg =/[\\+]/;    
    strValueTemp = strValueTemp.replace(numReg, '');    
    //整数    
    if(prec==0){    
        numReg =/[\\.]/;    
        if(numReg.test(value) == true){  
            f_alert(obj, '输入必须为整数类型');    
          return false;      
        }            
    }        
    if(strValueTemp.indexOf('.') < 0 ){    
        if(strValueTemp.length >( len - prec)){    
          f_alert(obj, '整数位不能超过'+ (len - prec) +'位');    
          return false;    
        }        
    }else{    
        strInt = strValueTemp.substr( 0, strValueTemp.indexOf('.') );        
        if(strInt.length >( len - prec)){    
          f_alert(obj, '整数位不能超过'+ (len - prec) +'位');    
          return false;    
        }    
        strDec = strValueTemp.substr( (strValueTemp.indexOf('.')+1), strValueTemp.length );    
        if(strDec.length > prec){    
          f_alert(obj, '小数位不能超过'+ prec +'位');    
          return false;    
        }        
    }        
    return true;    
  }catch(e){    
    alert('in f_check_double = ' + e);    
    return false;    
  }      
}    
   

/*  
* 校验数字的最小最大值  
* 返回bool  
*/   
function f_check_interval(obj)    
{    
  var value = parseFloat(obj.value);    
   
  var dtype = obj.eos_datatype;    
  var pos_dtype = dtype.substring(dtype.indexOf('(')+1,dtype.indexOf(')')).split(',');    
     
  var minLimit = pos_dtype[0];    
  var maxLimit = pos_dtype[1];    
  var minVal = parseFloat(pos_dtype[0]);    
  var maxVal = parseFloat(pos_dtype[1]);    
     
  if(isNaN(value))    
  {    
    f_alert(obj, '值必须为数字');    
    return false;    
  }    
  if((isNaN(minVal) && (minLimit != '-')) || (isNaN(maxVal) && (maxLimit != '+')))    
  {    
    f_alert(obj, '边界值必须为数字或-、+');    
    return false;    
  }    
   
  if(minLimit == '-' && !isNaN(maxVal))    
  {    
    if(value > maxVal)    
    {    
        f_alert(obj, '值不能超过' + maxVal);    
        return false;    
    }    
  }    
     
  if(!isNaN(minVal) && maxLimit == '+')    
  {       
if(value < minVal)    
    {    
        f_alert(obj, '值不能小于' + minVal);    
        return false;    
    }    
  }    
     
  if(!isNaN(minVal) && !isNaN(maxVal))    
  {    
    if(minVal > maxVal)    
    {    
        f_alert(obj, '起始值' + minVal + '不能大于终止值' + maxVal);    
    }else    
    {    
        if(!(value <= maxVal && value >= minVal))    
        {    
          f_alert(obj, '值应该在' + minVal + '和' + maxVal + '之间');    
          return false;    
        }    
    }    
  }    
  return true;    
}    
   

/*  
用途：检查输入字符串是否只由汉字组成  
如果通过验证返回true,否则返回false  
*/   
function f_check_zh(obj){    
var rgexp = /^[\\u4e00-\\u9fa5]+$/
  if (rgexp.test(obj.value)) {    
    return true;    
  }    
  f_alert(obj,'请输入汉字');    
  return false;    
}    
   

/*  
* 判断是否为小写英文字母，是则返回true,否则返回false  
*/   
function f_check_lowercase(obj)    
{        
var rgexp =/^[a-z]+$/
  if (rgexp.test( obj.value ))    
  {    
    return true;    
  }    
  f_alert(obj,'请输入小写英文字母');    
  return false;    
}    
   

/*  
* 判断是否为大写英文字母，是则返回true,否则返回false  
*/   
function f_check_uppercase(obj)    
{        
var rgexp = /^[A-Z]+$/
  if (rgexp.test( obj.value ))    
  {    
    return true;    
  }    
  f_alert(obj,'请输入大写英文字母');    
  return false;    
}    
   

/*  
* 判断是否为英文字母，是则返回true,否则返回false  
*/   
function f_check_letter(obj)    
{        
var rgexp= /^[A-Za-z]+$/
  if (rgexp.test( obj.value ))    
  {    
    return true;    
  }    
  f_alert(obj,'请输入英文字母');    
  return false;    
}    
   


   

/*  
用途：校验ip地址的格式  
输入：strIP：ip地址  
返回：如果通过验证返回true,否则返回false；  
*/  
function f_check_IP(obj)    
{    
  var re=/^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$/; //匹配IP地址的正则表达式    
  if(re.test( obj.value ))    
  {    
    if( RegExp.$1 <256 && RegExp.$2<256 && RegExp.$3<256 && RegExp.$4<256) return true;    
  }    
  f_alert(obj,'请输入合法的计算机IP地址');    
  return false;    
}    
   

/*  
用途：检查输入对象的值是否符合端口号格式  
输入：str 输入的字符串  
返回：如果通过验证返回true,否则返回false  
*/   
function f_check_port(obj)    
{    
  if(!f_check_number(obj))    
    return false;    
  if(obj.value < 65536)    
    return true;    
  f_alert(obj,'请输入合法的计算机IP地址端口号');    
  return false;    
}    
   

/*  
用途：检查输入对象的值是否符合网址格式  
输入：str 输入的字符串  
返回：如果通过验证返回true,否则返回false  
*/   
function f_check_URL(obj){      
  var myReg = /^((http:[/][/])?\w+([.]\w+|[/]\w*)*)?$/;    
  if(myReg.test( obj.value )) return true;    
  f_alert(obj,'请输入合法的网页地址');    
  return false;    
}    
   

/*  
用途：检查输入对象的值是否符合E-Mail格式  
输入：str 输入的字符串  
返回：如果通过验证返回true,否则返回false  
*/   
function f_check_email(obj){      
  var myReg = /^([-_A-Za-z0-9\\.]+)@([_A-Za-z0-9]+\\.)+[A-Za-z0-9]{2,3}$/;    
  if(myReg.test( obj.value )) return true;    
  f_alert(obj,'请输入合法的电子邮件地址');    
  return false;    
}    
   

/*  
要求：一、移动电话号码为11或12位，如果为12位,那么第一位为0  
二、11位移动电话号码的第一位和第二位为'13'  
三、12位移动电话号码的第二位和第三位为'13'  
用途：检查输入手机号码是否正确  
输入：  
s：字符串  
返回：  
如果通过验证返回true,否则返回false  
*/   
function f_check_mobile(obj){      
  var regu =/(^[1][3][0-9]{9}$)|(^0[1][3][0-9]{9}$)/;    
  var re = new RegExp(regu);    
  if (re.test( obj.value )) {    
    return true;    
  }    
  f_alert(obj,'请输入正确的手机号码');    
  return false;      
}    
   

/*  
要求：一、电话号码由数字、'('、')'和'-'构成  
二、电话号码为3到8位  
三、如果电话号码中包含有区号，那么区号为三位或四位  
四、区号用'('、')'或'-'和其他部分隔开  
用途：检查输入的电话号码格式是否正确  
输入：  
strPhone：字符串  
返回：  
如果通过验证返回true,否则返回false  
*/   
function f_check_phone(obj)    
{    
  var regu =/(^([0][1-9]{2,3}[-])?\\d{3,8}(-\\d{1,6})?$)|(^\\([0][1-9]{2,3}\\)\\d{3,8}(\\(\\d{1,6}\\))?$)|(^\\d{3,8}$)/;    
  var re = new RegExp(regu);    
  if (re.test( obj.value )) {    
    return true;    
  }    
  f_alert(obj,'请输入正确的电话号码');    
  return false;    
}    
   

/* 判断是否为邮政编码 */   
function f_check_zipcode(obj)    
{    
  if(!f_check_number(obj))    
    return false;    
  if(obj.value.length!=6)    
  {    
    f_alert(obj,'邮政编码长度必须是6位'); 
return false;    
  }    
  return true;    
}    
   

/*  
用户ID，可以为数字、字母、下划线的组合，  
第一个字符不能为数字,且总长度不能超过20。  
*/   
function f_check_userID(obj)    
{    
  var userID = obj.value;    
  if(userID.length > 20)    
  {    
    f_alert(obj,'ID长度不能大于20');    
    return false;    
  }    
   
  if(!isNaN(userID.charAt(0)))    
  {    
    f_alert(obj,'ID第一个字符不能为数字');    
    return false;    
  }    
  var rgexp = /^\\w{1,20}$/
  if(!rgexp.test(userID))    
  {    
    f_alert(obj,'ID只能由数字、字母、下划线组合而成');    
    return false;    
  }    
  return true;    
}    
   

/*  
功能：验证身份证号码是否有效  
提示信息：未输入或输入身份证号不正确！  
使用：f_check_IDno(obj)  
返回：bool  
*/   
function f_check_IDno(obj)    
{    
  var aCity={11:'北京',12:'天津',13:'河北',14:'山西',15:'内蒙古',21:'辽宁',22:'吉林',23:'黑龙江',31:'上海',32:'江苏',33:'浙江',34:'安徽',35:'福建',36:'江西',37:'山东',41:'河南',42:'湖北',43:'湖南',44:'广东',45:'广西',46:'海南',50:'重庆',51:'四川',52:'贵州',53:'云南',54:'西藏',61:'陕西',62:'甘肃',63:'青海',64:'宁夏',65:'新疆',71:'台湾',81:'香港',82:'澳门',91:'国外'};    
   
  var iSum = 0;    
  var info = '';    
  var strIDno = obj.value;    
  var idCardLength = strIDno.length;      
  var rgexp = /^\\d{17}(\\d|x)$/i.test(strIDno)&&!/^\\d{15}$/i
  if(!rgexp.test(strIDno))    
  {    
    f_alert(obj,'非法身份证号');    
    return false;    
  }    
   
  //在后面的运算中x相当于数字10,所以转换成a    
  strIDno = strIDno.replace(/x$/i,'a');    
   
  if(aCity[parseInt(strIDno.substr(0,2))]==null)    
  {    
    f_alert(obj,'非法地区');    
    return false;    
  }    
     
  if (idCardLength==18)    
  {    
    sBirthday=strIDno.substr(6,4)+'-'+Number(strIDno.substr(10,2))+'-'+Number(strIDno.substr(12,2));    
    var d = new Date(sBirthday.replace(/-/g,'/'))    
    if(sBirthday!=(d.getFullYear()+'-'+ (d.getMonth()+1) + '-' + d.getDate()))    
    {        
        f_alert(obj,'非法生日');    
        return false;    
    }    
   
    for(var i = 17;i>=0;i --)    
        iSum += (Math.pow(2,i) % 11) * parseInt(strIDno.charAt(17 - i),11);    
   
    if(iSum%11!=1)    
    {    
        f_alert(obj,'非法身份证号');    
        return false;    
    }    
  }    
  else if (idCardLength==15)    
  {    
    sBirthday = '19' + strIDno.substr(6,2) + '-' + Number(strIDno.substr(8,2)) + '-' + Number(strIDno.substr(10,2));   
var d = new Date(sBirthday.replace(/-/g,'/'))    
    var dd = d.getFullYear().toString() + '-' + (d.getMonth()+1) + '-' + d.getDate();      
    if(sBirthday != dd)    
    {    
        f_alert(obj,'非法生日');    
        return false;    
    }    
  }    
  return true;    
}    
   

/*  
* 判断字符串是否符合指定的正则表达式  
*/   
function f_check_formatStr(obj)    
{    
  var str = obj.value;    
  var dtype = obj.eos_datatype;    
  var regu = dtype.substring(dtype.indexOf('(')+1,dtype.indexOf(')'));   //指定的正则表达式    
  var re = new RegExp(regu);    
  if(re.test(str))    
    return true;    
  f_alert(obj , '不符合指定的正则表达式要求');    
  return false;      
}    
   


/*判断当前对象是否可见*/   
function isVisible(obj){    
  var visAtt,disAtt;    
  try{    
    disAtt=obj.style.display;    
    visAtt=obj.style.visibility;    
  }catch(e){}    
  if(disAtt=='none' || visAtt=='hidden')    
    return false;    
  return true;    
}    
   

/*判断当前对象及其父对象是否可见*/   
function checkPrVis(obj){    
  var pr=obj.parentNode;    
  do{    
    if(pr == undefined || pr == 'undefined') return true;    
    else{    
        if(!isVisible(pr)) return false;    
    }    
  }while(pr=pr.parentNode);    
  return true;    
}    
   

/* 弹出警告对话框，用户点确定后将光标置于出错文本框上， 并且将原来输入内容选中。*/   
function f_alert(obj,alertInfo)    
{    
  var caption = obj.getAttribute('eos_displayname');    
  if(caption == null)    
    caption = '';    
  alert(caption + '：' + alertInfo + '！');    
  obj.select();    
  if(isVisible(obj) && checkPrVis(obj))    
    obj.focus();   
}    
   

/**  
* 检测字符串是否为空  
*/   
function isnull(str)    
{    
  var i;    
  if(str.length == 0)    
    return true;    
  for (i=0;i<str.length;i++)    
  {    
    if (str.charAt(i)!=' ')    
        return false;    
  }    
  return true;    
}    
   

/**  
* 检测指定文本框输入是否合法。  
* 如果用户输入的内容有错，则弹出提示对话框，  
* 同时将焦点置于该文本框上，并且该文本框前面  
* 会出现一个警告图标(输入正确后会自动去掉)。  
*/   
function checkInput(object)    
{    
  var image;    
  var i;    
  var length;    
   
  if(object.eos_maxsize + '' != 'undefined') length = object.eos_maxsize;    
  else length = 0;    
   
  if (object.eos_isnull=='true' && isnull(object.value)) return true;    
   
  /* 长度校验 */    
  if(length != 0 && strlen(object.value) > parseInt(length)) {    
        f_alert(object, '超出最大长度' + length);    
        return false;    
  }    
  /* 数据类型校验 */    
  else {    
    if (object.eos_datatype + '' != 'undefined')    
    {        
   
        var dtype = object.eos_datatype;    
        var objName = object.name;    
        //如果类型名后面带有括号，则视括号前面的字符串为校验类型    
        if(dtype.indexOf('(') != -1)    
          dtype = dtype.substring(0,dtype.indexOf('('));    
        //根据页面元素的校验类型进行校验    
        try{    
          if(eval('f_check_' + dtype + '(object)') != true)    
            return false;    
        }catch(e){return true;}    
        /* 如果form中存在name前半部分相同，并且同时存在以'min'和'max'结尾的表单域，    
          那么视为按区间查询。即'min'结尾的表单域的值要小于等于'max'结尾的表单域的值。 */    
        if(objName.substring((objName.length-3),objName.length)=='min')    
        {    
          var objMaxName = objName.substring(0, (objName.length-3)) + 'max';    
          if(document.getElementById(objMaxName) != undefined && document.getElementById(objMaxName) != 'undefined' )    
          {    
            if(checkIntervalObjs(object, document.getElementById(objMaxName)) != true)    
                return false;                
          }   
 }            
    }    
  }    
  return true;    
}    
   

/* 检测表单中所有输入项的正确性，一般用于表单的onsubmit事件 */   
function checkForm(myform)    
{    
  var i;    
  for (i=0;i<myform.elements.length;i++)    
  {    
    /* 非自定义属性的元素不予理睬 */        
    if (myform.elements.eos_displayname + '' == 'undefined') continue;    
    /* 非空校验 */    
    if (myform.elements.eos_isnull=='false' && isnull(myform.elements.value)){    
        f_alert(myform.elements,'不能为空');    
        return false;    
    }        
    /* 数据类型校验 */    
    if (checkInput(myform.elements)==false)    
        return false;              
  }    
  return true;    
}      

/**  
* 校验两个表单域数据的大小，目前只允许比较日期和数字。  
* @param obj1 小值表单域  
* @param obj2 大值表单域  
*/   
function checkIntervalObjs(obj1 , obj2)    
{      
  var caption1 = obj1.getAttribute('eos_displayname');    
  var caption2 = obj2.getAttribute('eos_displayname');    
  var val1 = parseFloat(obj1.value);    
  var val2 = parseFloat(obj2.value);    
  // 非自定义属性的元素不予理睬    
  if (obj1.eos_displayname + '' == 'undefined' || obj2.eos_displayname + '' == 'undefined') {    
    return false;    
  }    
  // 日期类型的比较    
  if(f_check_date(obj1) == true && f_check_date(obj2) == true){    
    var dtype = obj1.eos_datatype;    
    var format = dtype.substring(dtype.indexOf('(')+1,dtype.indexOf(')')); //日期格式    
    val1 = getDateByFormat(obj1.value, format);    
    dtype = obj2.eos_datatype;    
    format = dtype.substring(dtype.indexOf('(')+1,dtype.indexOf(')')); //日期格式    
    val2 = getDateByFormat(obj2.value, format);    
    if(val1 > val2){    
    obj2.select();    
    if(isVisible(obj) && checkPrVis(obj))    
        obj2.focus();    
    alert(caption1 + '的起始日期不能大于其终止日期！');    
    return false;    
    }    
  }    
  // 数字类型的比较    
  if((isNaN(val1) && !isnull(val1)) || (isNaN(val2) && !isnull(val2))){    
    alert(caption1 + '的值不全为数字则不能比较！');    
    return false;    
  }    
  if(val1 > val2){    
    obj2.select();    
    if(isVisible(obj) && checkPrVis(obj))    
        obj2.focus();    
    alert(caption1 + '的起始值不能大于其终止值！');   
return false;    
  }    
  return true;    
}    
   

/*根据日期格式，将字符串转换成Date对象。  
格式：yyyy-年，MM-月，dd-日，HH-时，mm-分，ss-秒。  
（格式必须写全，例如:yy-M-d，是不允许的，否则返回null；格式与实际数据不符也返回null。）  
默认格式：yyyy-MM-dd HH:mm:ss,yyyy-MM-dd。*/   
function getDateByFormat(str){    
  var dateReg,format;    
  var y,M,d,H,m,s,yi,Mi,di,Hi,mi,si;    
  if((arguments[1] + '') == 'undefined') format = 'yyyy-MM-dd HH:mm:ss';    
  else format = arguments[1];    
  yi = format.indexOf('yyyy');    
  Mi = format.indexOf('MM');    
  di = format.indexOf('dd');    
  Hi = format.indexOf('HH');    
  mi = format.indexOf('mm');    
  si = format.indexOf('ss');    
  if(yi == -1 || Mi == -1 || di == -1) return null;    
  else{    
    y = parseInt(str.substring(yi, yi+4));    
    M = parseInt(str.substring(Mi, Mi+2));    
    d = parseInt(str.substring(di, di+2));    
  }    
  if(isNaN(y) || isNaN(M) || isNaN(d)) return null;    
  if(Hi == -1 || mi == -1 || si == -1) return new Date(y, M-1, d);    
  else{    
    H = str.substring(Hi, Hi+4);    
    m = str.substring(mi, mi+2);    
    s = str.substring(si, si+2);    
  }    
  if(isNaN(parseInt(y)) || isNaN(parseInt(M)) || isNaN(parseInt(d))) return new Date(y, M-1, d);    
  else return new Date(y, M-1, d,H, m, s);    
}