//判断输入的字符串是否是数字
function CheckNum(str)
{	var NumStr=new String();
	NumStr="0123456789"
	for(var i=0;i<str.length;i++)
		if(NumStr.indexOf(str.substr(i,1))<0)
			return false;
	return true;		
}

//判断是否是数字
function IsNum(str)
{
	nums=parseInt(str);
	if(isNaN(nums))
		return false;
	else
		return true;
}

//返回整型值
function getUnInt(str)
{
	nums=parseInt(str);
	if(isNaN(nums))
	{
		return 0;
	}
	else
	{
		return nums;
	}
	
}
//判断是否是浮点型的数字
function isFloat(str)
{
	nums=parseFloat(str)
	if(isNaN(nums))
	{
		return false;
	}
	else
	{
		return true;
	}
}

function checkFloat(obj)
{
	n=parseFloat(obj.value);
	if(isNaN(n))
	{
		obj.value="0";
	}
	else
	{
		obj.value=n;
	}
	return false;
}

function checkInt(obj)
{
	n=parseInt(obj.value);
	if(isNaN(n))
	{
		obj.value="0";
	}
	else
	{
		obj.value=n;
	}
	return false;
}

/*LTrim(string):去除左边的空格*/ 
function LTrim(str){   
    var whitespace = new String(" \t\n\r");   
    var s = new String(str);      
  
    if (whitespace.indexOf(s.charAt(0)) != -1){   
        var j=0, i = s.length;   
        while (j < i && whitespace.indexOf(s.charAt(j)) != -1){   
            j++;   
        }   
        s = s.substring(j, i);   
    }   
    return s;   
}   

/*RTrim(string):去除右边的空格*/
function RTrim(str){   
    var whitespace = new String(" \t\n\r");   
    var s = new String(str);   
    
    if (whitespace.indexOf(s.charAt(s.length-1)) != -1){   
        var i = s.length - 1;   
        while (i >= 0 && whitespace.indexOf(s.charAt(i)) != -1){   
            i--;   
        }   
        s = s.substring(0, i+1);   
    }   
    return s;   
}   

/*Trim(string):去除字符串两边的空格*/ 
function Trim(str){   
    return RTrim(LTrim(str));   
}   
//JavaScript Document
 /** 
* 取得字符串的字节长度 
*/
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 Check_Integer(obj)   
{          
    if (/^(\+|-)?\d+$/.test( obj.value ))    
    {   
       return true;   
    }    
    else    
    {   
        Alert_focus(obj,"请输入整数");   
        return false;   
    }   
}   
//检查
//判断是否全选
function CheckItem(CB){
  var tagname=(arguments.length>1)?arguments[1]:'TR';

  if(document.myform.chkAll.checked)
  {
    document.myform.chkAll.checked = document.myform.chkAll.checked&0;
  }
  if (CB.checked)
  {
	  hL(CB,tagname)
  }
  else
  {
	  dL(CB,tagname)
  }
  var TB=TO=0;
  for (var i=0;i<myform.elements.length;i++)
  {
    var e=myform.elements[i];
    if ((e.name != 'chkAll') && (e.type=='checkbox'))
	{
      TB++;
      if (e.checked) TO++;
    }
  }
  myform.chkAll.checked=(TO==TB)?true:false;
}

//选择所有的复选框
function CheckAll(form){
  var tagname=(arguments.length>1)?arguments[1]:'TR';
  for (var i=0;i<form.elements.length;i++){
    var e = form.elements[i];
    if (e.name != 'chkAll' && e.disabled == false && e.type == 'checkbox') {
      e.checked = form.chkAll.checked;
  
    }
  }
}

//改变表格的样式
function hL(E,tagname){
  while (E.tagName!=tagname) {E=E.parentElement;}
  E.className='tdbg2';
}

//改变表格的样式
function dL(E,tagname){
  while (E.tagName!=tagname) {E=E.parentElement;}
  E.className='tdbg';
}


//判断是否包含SQL注入
function insql(str,types)
{

	var sqlstra=new Array();
	var sqlstr=new String();
	var numstr=new String();
	if(types==1)//types==1表示是对密码进入SQL注入判断types==2表示是对用户进入SQL注入判断
		sqlstr="insert |delete |=|update |drop |alert |select "
	else
	{
		sqlstr="insert |delete |=|update |drop |alert |select |*|~|!|@|#|$|%|^|&|*|(|)|_|-|+|=|\"|\\|'|<|>|,|?|;|{|}|[|]"			
	if(numstr.indexOf(str.substr(0,1))>=0||str.indexOf("|")>=0)
		return true;	
	}	
	sqlstra=sqlstr.split("|")
	for(i=0;i<sqlstra.length-1;i++)
	{
		if(str.indexOf(sqlstra[i])>=0)
		{
			return true;
		}	
	}
	return false;
}


//获取选中的多选框的值
function getChecked(cname)   
{   
	var cobj,idstrs;
	cobj = document.getElementsByName(cname);   
	idstrs="";
	for(var i=0;i<cobj.length;i++) 
	{  
		if(cobj[i].checked) idstrs=idstrs+cobj[i].value+",";
	}	 	
	return idstrs;
}   

  
//获取选中的单选框的值   
function getRadio(obj)
{
	var robj=document.getElementsByName(obj);
	var len=robj.length;   
	for (var i=0;i<len ;i++ )
	{ 
		if( robj[i].checked==true )
 		{
		  return robj[i].value;
 		}
	}
	return ""
}
   
///删除确认
function ConfirmDel()
{
	if(window.confirm("确认要删除所有选中的选项吗?"))
		return true;
	else
		return false;
}
	


/* 
用途：检查输入对象的值是否符合E-Mail格式 
输入：str 输入的字符串 
返回：如果通过验证返回true,否则返回false 
*/ 
function 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;    
    Alert_focus(obj,"请输入合法的电子邮件地址");   
    return false;    
} 
/* 
要求：一、移动电话号码为11或12位，如果为12位,那么第一位为0 
二、11位移动电话号码的第一位和第二位为"13" 
三、12位移动电话号码的第二位和第三位为"13" 
用途：检查输入手机号码是否正确 
输入： 
s：字符串 
返回： 
如果通过验证返回true,否则返回false 
*/ 
function 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;   
    }   
    Alert_focus(obj,"请输入正确的手机号码");   
    return false;      
}   
/* 
要求：一、电话号码由数字、"("、")"和"-"构成 
二、电话号码为3到8位 
三、如果电话号码中包含有区号，那么区号为三位或四位 
四、区号用"("、")"或"-"和其他部分隔开 
用途：检查输入的电话号码格式是否正确 
输入： 
strPhone：字符串 
返回： 
如果通过验证返回true,否则返回false 
*/ 
function 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;   
    }   
    Alert_focus(obj,"请输入正确的电话号码");   
    return false;   
}   
   
function Check_Tel(obj)
{
    var regu =/(^[1][3][0-9]{9}$)|(^0[1][3][0-9]{9}$)/;   
    var re = new RegExp(regu);
    var regu1 =/(^([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 re1 = new RegExp(regu1);	
	if(re.test(obj.value))
	{
		return true;
	}
	if(re1.test(obj.value))
	{
		return true;
	}
	 Alert_focus(obj,"请输入正确的电话号码"); 
	 return false;
}

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

/* 弹出警告对话框，用户点确定后将光标置于出错文本框上， 并且将原来输入内容选中。*/ 
function Alert_focus(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 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;   
}   
/* 
* 判断是否为实数，是则返回true,否则返回false 
*/ 
function Check_Float(obj)   
{          
    if (/^(\+|-)?\d+($|\.\d+$)/.test( obj.value ))    
    {   
       return true;   
    }    
    else    
    {   
        Alert_focus(obj,"请输入实数");   
       return false;   
    }   
}   
  
  /* 
* 校验数字的长度和精度 
*/function Fcheck_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){   
                Alert_focus(obj, "输入必须为整数类型");   
                return false;      
            }              
        }          
        if(strValueTemp.indexOf(".") < 0 ){   
            if(strValueTemp.length >( len - prec)){   
                Alert_focus(obj, "整数位不能超过"+ (len - prec) +"位");   
                return false;   
            }          
        }else{   
            strInt = strValueTemp.substr( 0, strValueTemp.indexOf(".") );          
            if(strInt.length >( len - prec)){   
                Alert_focus(obj, "整数位不能超过"+ (len - prec) +"位");   
                return false;   
            }   
            strDec = strValueTemp.substr( (strValueTemp.indexOf(".")+1), strValueTemp.length );    
            if(strDec.length > prec){   
                Alert_focus(obj, "小数位不能超过"+  prec +"位");   
                return false;   
            }          
        }          
        return true;   
    }catch(e){   
        alert("in f_check_double = " + e);   
        return false;   
    }      
}   
   
/* 
* 校验数字的最小最大值 
* 返回bool 
*/ 
function 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))   
    {   
        Alert_focus(obj, "值必须为数字");   
        return false;   
    }   
    if((isNaN(minVal) && (minLimit != "-")) || (isNaN(maxVal) && (maxLimit != "+")))   
    {   
        Alert_focus(obj, "边界值必须为数字或-、+");   
        return false;   
    }   
  
    if(minLimit == "-" && !isNaN(maxVal))   
    {   
        if(value > maxVal)   
        {   
            Alert_focus(obj, "值不能超过" + maxVal);   
            return false;   
        }   
    }   
       
    if(!isNaN(minVal) && maxLimit == "+")   
    {          
        if(value < minVal)   
        {   
            Alert_focus(obj, "值不能小于" + minVal);   
            return false;   
        }   
    }   
       
    if(!isNaN(minVal) && !isNaN(maxVal))   
    {   
        if(minVal > maxVal)   
        {   
            Alert_focus(obj, "起始值" + minVal + "不能大于终止值" + maxVal);   
        }else  
        {   
            if(!(value <= maxVal && value >= minVal))   
            {   
                Alert_focus(obj, "值应该在" + minVal + "和" + maxVal + "之间");   
                return false;   
            }   
        }   
    }   
    return true;   
} 

/* 
用途：检查输入字符串是否只由汉字组成 
如果通过验证返回true,否则返回false 
*/ 
function Check_zh(obj){   
    if (/^[\u4e00-\u9fa5]+$/.test(obj.value)) {   
      return true;   
    }   
    Alert_focus(obj,"请输入汉字");   
    return false;   
}   
/* 
* 判断是否为小写英文字母，是则返回true,否则返回false 
*/ function Check_LowerCase(obj)   
{          
    if (/^[a-z]+$/.test( obj.value ))    
    {   
       return true;   
    }    
    Alert_focus(obj,"请输入小写英文字母");   
    return false;   
}   
/* 
* 判断是否为大写英文字母，是则返回true,否则返回false 
*/ 
function Check_UpperCase(obj)   
{          
    if (/^[A-Z]+$/.test( obj.value ))    
    {   
       return true;   
    }    
    Alert_focus(obj,"请输入大写英文字母");   
    return false;   
}   
/* 
* 判断是否为英文字母，是则返回true,否则返回false 
*/ 
function Check_Letter(obj)   
{          
    if (/^[A-Za-z]+$/.test( obj.value ))    
    {   
       return true;   
    }    
    Alert_focus(obj,"请输入英文字母");   
    return false;   
}   
   /* 
用途：检查输入字符串是否只由汉字、字母、数字组成 
输入： 
value：字符串 
返回： 
如果通过验证返回true,否则返回false 
*/ 
function Check_ZhOrNumOrLett(obj){    //判断是否是汉字、字母、数字组成   
    var regu = "^[0-9a-zA-Z\u4e00-\u9fa5]+$";      
    var re = new RegExp(regu);   
    if (re.test( obj.value )) {   
      return true;   
    }   
    Alert_focus(obj,"请输入汉字、字母或数字");   
    return false;   
}   
/* 
用途：校验ip地址的格式 
输入：strIP：ip地址 
返回：如果通过验证返回true,否则返回false； 
*/ 
function 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;   
    }   
    Alert_focus(obj,"请输入合法的计算机IP地址");   
    return false;    
}   

/* 
用途：检查输入对象的值是否符合端口号格式 
输入：str 输入的字符串 
返回：如果通过验证返回true,否则返回false 
*/ 
function Check_Port(obj)   
{   
    if(!f_check_number(obj))   
        return false;   
    if(obj.value < 65536)   
        return true;   
    Alert_focus(obj,"请输入合法的计算机IP地址端口号");   
    return false;    
}   
/* 
用途：检查输入对象的值是否符合网址格式 
输入：str 输入的字符串 
返回：如果通过验证返回true,否则返回false 
*/ 
function Check_URL(obj){     
    var myReg = /^((http:[/][/])?\w+([.]\w+|[/]\w*)*)?$/;    
    if(myReg.test( obj.value )) return true;    
    Alert_focus(obj,"请输入合法的网页地址");   
    return false;    
}   
   
   /* 
用户ID，可以为数字、字母、下划线的组合， 
第一个字符不能为数字,且总长度不能超过20。 
*/ 
function Check_UserID(obj)   
{   
    var userID = obj.value;   
    if(userID.length > 20)   
    {   
        Alert_focus(obj,"ID长度不能大于20");   
        return false;   
    }   
  
    if(!isNaN(userID.charAt(0)))   
    {   
        Alert_focus(obj,"ID第一个字符不能为数字");   
        return false;   
    }   
    if(!/^\w{1,20}$/.test(userID))    
    {   
        Alert_focus(obj,"ID只能由数字、字母、下划线组合而成");   
        return false;   
    }   
    return true;   
}
/* 
* 判断字符串是否符合指定的正则表达式 
*/ 
function 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;   
    Alert_focus(obj , "不符合指定的正则表达式要求");   
    return false;      
}   
/* 
功能：判断是否为日期(格式:yyyy年MM月dd日,yyyy-MM-dd,yyyy/MM/dd,yyyyMMdd) 
提示信息：未输入或输入的日期格式错误！ 
使用：f_check_date(obj) 
返回：bool 
*/
function Check_Time(obj)   
{   
    var time = Trim(obj.value);   

    var dtype = obj.eos_datatype;   
    var format = dtype.substring(dtype.indexOf("(")+1,dtype.indexOf(")"));  //日期格式   
    var datePat,matchArray,year,month,day,hour,minute,second;   
  
    if(/^(y{4})(-|\/)(M{1,2})\2(d{1,2}) (HH:mm:ss)$/.test(format))   
        datePat = /^(\d{4})(-|\/)(\d{1,2})\2(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})$/;   
    else if(/^(y{4})(年)(M{1,2})(月)(d{1,2})(日)(HH时mm分ss秒)$/.test(format))   
        datePat = /^(\d{4})年(\d{1,2})月(\d{1,2})日(\d{1,2})时(\d{1,2})分(\d{1,2})秒$/;   
    else if(format == "yyyyMMddHHmmss")   
        datePat = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/;   
    else  
    {   
        Alert_focus(obj,"日期格式不对");   
        return false;   
    }   
    matchArray = time.match(datePat);   
    if(matchArray == null)    
    {   
        Alert_focus(obj,"日期长度不对,或日期中有非数字符号");   
        return false;   
    }   
    if(/^(y{4})(-|\/)(M{1,2})\2(d{1,2}) (HH:mm:ss)$/.test(format))   
    {   
        year = matchArray[1];   
        month = matchArray[3];   
        day = matchArray[4];   
        hour = matchArray[5];   
        minute = matchArray[6];   
        second = matchArray[7];   
    } else  
    {   
        year = matchArray[1];   
        month = matchArray[2];   
        day = matchArray[3];   
        hour = matchArray[4];   
        minute = matchArray[5];   
        second = matchArray[6];   
    }   
    if (month < 1 || month > 12)   
    {                
        Alert_focus(obj,"月份应该为1到12的整数");   
        return false;   
    }   
    if (day < 1 || day > 31)   
    {              
        Alert_focus(obj,"每个月的天数应该为1到31的整数");   
        return false;   
    }        
    if ((month==4 || month==6 || month==9 || month==11) && day==31)   
    {            
        Alert_focus(obj,"该月不存在31号");   
        return false;   
    }        
    if (month==2)   
    {   
        var isleap=(year % 4==0 && (year % 100 !=0 || year % 400==0));   
        if (day>29)   
        {                  
            Alert_focus(obj,"2月最多有29天");   
            return false;   
        }   
        if ((day==29) && (!isleap))   
        {                  
            Alert_focus(obj,"闰年2月才有29天");   
            return false;   
        }   
    }   
    if(hour<0 || hour>23)   
    {   
        Alert_focus(obj,"小时应该是0到23的整数");   
        return false;   
    }   
    if(minute<0 || minute>59)   
    {   
        Alert_focus(obj,"分应该是0到59的整数");   
        return false;   
    }   
    if(second<0 || second>59)   
    {   
        Alert_focus(obj,"秒应该是0到59的整数");   
        return false;   
    }   
    return true; 
}
/** 
* 检测字符串是否为空 
*/ 
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;   
} 
/*根据日期格式，将字符串转换成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);   
}   

///检测输入的字符串长度
function checkLen(obj,maxLen)
{
	if(obj.value.length>maxLen)
	{
		alert("输入内容不能超过"+maxLen+"个字符（中文)！");
		obj.value=obj.value.substring(0,maxLen);
		obj.focus();
	}
}
///HTML反编码
function XMLEncode(str)
{
	str=Trim(str);
	str=str.replace("&","&amp;");
	str=str.replace("<","&lt;");
	str=str.replace(">","&gt;");
	str=str.replace("'","&apos;");
	str=str.replace("\"","&quot;");
	return str;
}