/** 
* 去除多余空格函数 
* trim:去除两边空格 lTrim:去除左空格 rTrim: 去除右空格 
* 用法： 
* var str = " hello "; 
* str = str.trim(); 
*/ 
String.prototype.trim = function() 
{ 
	return this.replace(/(^[\\s]*)|([\\s]*$)/g, ""); 
} 
String.prototype.lTrim = function() 
{ 
	return this.replace(/(^[\\s]*)/g, ""); 
} 
String.prototype.rTrim = function() 
{ 
	return this.replace(/([\\s]*$)/g, ""); 
} 
/********************************** Empty **************************************/ 
/** 
*校验字符串是否为空 
*返回值： 
*如果不为空，定义校验通过，返回true 
*如果为空，校验不通过，返回false 参考提示信息：输入域不能为空！ 
*/ 
function checkIsNotEmpty(str) 
{ 
	if(str.trim() == "") 
		return false; 
	else 
		return true; 
} 
/*--------------------------------- Empty --------------------------------------*/ 
/********************************** Integer *************************************/ 
/** 
*校验字符串是否为整型 
*返回值： 
*如果为空，定义校验通过， 返回true 
*如果字串全部为数字，校验通过，返回true 
*如果校验不通过， 返回false 参考提示信息：输入域必须为数字！ 
*/ 
function checkIsInteger(str) 
{ 
	//如果为空，则通过校验 
	if(str == "") 
		return true; 
	if(/^(\\-?)(\\d+)$/.test(str)) 
		return true; 
	else 
		return false; 
}
/** 
*校验整型最小值 
*str：要校验的串。 val：比较的值 
*返回值： 
*如果为空，定义校验通过， 返回true 
*如果满足条件，大于等于给定值，校验通过，返回true 
*如果小于给定值， 返回false 参考提示信息：输入域不能小于给定值！ 
*/ 
function checkIntegerMinValue(str,val) 
{ 
	//如果为空，则通过校验 
	if(str == "") 
	return true; 
	if(typeof(val) != "string") 
		val = val + ""; 
	if(checkIsInteger(str) == true) 
	{ 
		if(parseInt(str,10)>=parseInt(val,10)) 
			return true; 
		else 
			return false; 
	} 
	else 
		return false; 
}
/** 
*校验整型最大值 
*str：要校验的串。 val：比较的值 
* 
*返回值： 
*如果为空，定义校验通过， 返回true 
*如果满足条件，小于等于给定值，校验通过，返回true 
*如果大于给定值， 返回false 参考提示信息：输入值不能大于给定值！ 
*/ 
function checkIntegerMaxValue(str,val) 
{ 
	//如果为空，则通过校验 
	if(str == "") 
		return true; 
	if(typeof(val) != "string") 
		val = val + ""; 
	if(checkIsInteger(str) == true) 
	{ 
		if(parseInt(str,10)<=parseInt(val,10)) 
			return true; 
		else 
			return false; 
	} 
	else 
	{
		return false;
	}
} 
/** 
*校验整型是否为非负数 
*str：要校验的串。 
* 
*返回值： 
*如果为空，定义校验通过，返回true 
*如果非负数， 返回true 
*如果是负数， 返回false 参考提示信息：输入值不能是负数！ 
*/ 
function isNotNegativeInteger(str) 
{ 
//如果为空，则通过校验 
	if(str == "") 
		return true; 
	if(checkIsInteger(str) == true) 
	{ 
		if(parseInt(str,10) < 0) 
			return false; 
		else 
			return true; 
	} 
	else 
		return false; 
}
/*--------------------------------- Integer --------------------------------------*/ 
/********************************** Double ****************************************/ 
/** 
*校验字符串是否为浮点型 
*返回值： 
*如果为空，定义校验通过， 返回true 
*如果字串为浮点型，校验通过， 返回true 
*如果校验不通过， 返回false 参考提示信息：输入域不是合法的浮点数！ 
*/ 
function checkIsDouble(str) 
{ 
	//如果为空，则通过校验 
	if(str == "") 
		return true; 
	//如果是整数，则校验整数的有效性 
	if(str.indexOf(".") == -1) 
	{ 
		if(checkIsInteger(str) == true) 
			return true; 
		else 
			return false; 
	} 
	else 
	{ 
		if(/^(\\-?)(\\d+)(.{1})(\\d+)$/g.test(str)) 
			return true; 
		else 
			return false; 
	} 
}
/** 
*校验浮点型最小值 
*str：要校验的串。 val：比较的值 
* 
*返回值： 
*如果为空，定义校验通过， 返回true 
*如果满足条件，大于等于给定值，校验通过，返回true 
*如果小于给定值， 返回false 参考提示信息：输入域不能小于给定值！ 
*/ 
function checkDoubleMinValue(str,val) 
{ 
	//如果为空，则通过校验 
	if(str == "") 
		return true; 
	if(typeof(val) != "string") 
		val = val + ""; 
	if(checkIsDouble(str) == true) 
	{ 
		if(parseFloat(str)>=parseFloat(val)) 
			return true; 
		else 
			return false; 
	} 
	else 
		return false; 
} 
/** 
*校验浮点型最大值 
*str：要校验的串。 val：比较的值 
* 
*返回值： 
*如果为空，定义校验通过， 返回true 
*如果满足条件，小于等于给定值，校验通过，返回true 
*如果大于给定值， 返回false 参考提示信息：输入值不能大于给定值！ 
*/ 
function checkDoubleMaxValue(str,val) 
{ 
	//如果为空，则通过校验 
	if(str == "") 
		return true; 
	if(typeof(val) != "string") 
		val = val + ""; 
	if(checkIsDouble(str) == true) 
	{ 
		if(parseFloat(str)<=parseFloat(val)) 
			return true; 
		else 
			return false; 
	} 
	else 
		return false; 
}//~~~ 
/** 
*校验浮点型是否为非负数 
*str：要校验的串。 
* 
*返回值： 
*如果为空，定义校验通过，返回true 
*如果非负数， 返回true 
*如果是负数， 返回false 参考提示信息：输入值不能是负数！ 
*/ 
function isNotNegativeDouble(str) 
{ 
	//如果为空，则通过校验 
	if(str == "") 
		return true; 
	if(checkIsDouble(str) == true) 
	{ 
		if(parseFloat(str) < 0) 
			return false; 
		else 
			return true; 
	} 
	else 
		return false; 
}//~~~ 
/*--------------------------------- Double ---------------------------------------*/ 
/********************************** date ******************************************/ 
/** 
*校验字符串是否为日期型 
*返回值： 
*如果为空，定义校验通过， 返回true 
*如果字串为日期型，校验通过， 返回true 
*如果日期不合法， 返回false 参考提示信息：输入域的时间不合法！（yyyy-MM-dd） 
*/ 
function checkIsValidDate(str) 
{ 
	//如果为空，则通过校验 
	if(str == "") 
		return true; 

	var pattern = /^((\\d{4})|(\\d{2}))-(\\d{1,2})-(\\d{1,2})$/g; 

	if(!pattern.test(str)) 
		return false; 

	var arrDate = str.split("-"); 

	if(parseInt(arrDate[0],10) < 100) 
		arrDate[0] = 2000 + parseInt(arrDate[0],10) + ""; 

	var date = new Date(arrDate[0],(parseInt(arrDate[1],10) -1)+"",arrDate[2]); 

	if(date.getYear() == arrDate[0] && date.getMonth() == (parseInt(arrDate[1],10) -1)+"" && date.getDate() == arrDate[2]) 
		return true; 
	else 
		return false; 
}//~~~ 
/** 
*校验两个日期的先后 
*返回值： 
*如果其中有一个日期为空，校验通过, 返回true 
*如果起始日期早于等于终止日期，校验通过， 返回true 
*如果起始日期晚于终止日期， 返回false 参考提示信息： 起始日期不能晚于结束日期。 
*/ 
function checkDateEarlier(strStart,strEnd) 
{ 
	if(checkIsValidDate(strStart) == false || checkIsValidDate(strEnd) == false) 
		return false; 
	//如果有一个输入为空，则通过检验 
	if (( strStart == "" ) || ( strEnd == "" )) 
		return true; 

	var arr1 = strStart.split("-"); 
	var arr2 = strEnd.split("-"); 

	var date1 = new Date(arr1[0],parseInt(arr1[1].replace(/^0/,""),10) - 1,arr1[2]); 
	var date2 = new Date(arr2[0],parseInt(arr2[1].replace(/^0/,""),10) - 1,arr2[2]); 

	if(arr1[1].length == 1) 
		arr1[1] = "0" + arr1[1]; 

	if(arr1[2].length == 1) 
		arr1[2] = "0" + arr1[2]; 

	if(arr2[1].length == 1) 
		arr2[1] = "0" + arr2[1]; 

	if(arr2[2].length == 1) 
		arr2[2]="0" + arr2[2]; 

	var d1 = arr1[0] + arr1[1] + arr1[2]; 
	var d2 = arr2[0] + arr2[1] + arr2[2]; 

	if(parseInt(d1,10) > parseInt(d2,10)) 
		return false; 
	else 
		return true; 
}//~~~ 
/*--------------------------------- date -----------------------------------------*/ 
/********************************** email *****************************************/ 
/** 
*校验字符串是否为email型 
*返回值： 
*如果为空，定义校验通过， 返回true 
*如果字串为email型，校验通过， 返回true 
*如果email不合法， 返回false 参考提示信息：Email的格式不正確！ 
*/ 
function checkEmail(email)
{
	var reg = new RegExp("^([\.a-zA-Z0-9_-]){3,}@([a-zA-Z0-9_-]){3,}(\.([a-zA-Z0-9]){2,4}){1,2}$");
	
	if(!reg.test(email)){
		//alert("不合法的电子邮件地址!");
		return false;
	}
	return true;
}//~~~ 
/*--------------------------------- email ----------------------------------------*/ 
/********************************** chinese ***************************************/ 
/** 
*校验字符串是否为中文 
*返回值： 
*如果为空，定义校验通过， 返回true 
*如果字串为中文，校验通过， 返回true 
*如果字串为非中文， 返回false 参考提示信息：必须为中文！ 
*/ 
function checkIsChinese(str) 
{ 
	//如果值为空，通过校验 
	if (str == "") 
		return true; 
	var pattern = /^([\\u4E00-\\u9FA5]|[\\uFE30-\\uFFA0])*$/gi; 

	if (pattern.test(str)) 
		return true; 
	else 
		return false; 
}//~~~ 
/** 
* 计算字符串的长度，一个汉字两个字符 
*/ 
String.prototype.realLength = function() 
{ 
	return this.replace(/[^\\x00-\\xff]/g,"**").length; 
} 
/*--------------------------------- chinese --------------------------------------*/ 
/********************************** mask ***************************************/ 
/** 
*校验字符串是否符合自定义正则表达式 
*str 要校验的字串 pat 自定义的正则表达式 
*返回值： 
*如果为空，定义校验通过， 返回true 
*如果字串符合，校验通过， 返回true 
*如果字串不符合， 返回false 参考提示信息：必须满足***模式 
*/ 
function checkMask(str,pat) 
{ 
	//如果值为空，通过校验 
	if (str == "") 
		return true; 

	var pattern = new RegExp(pat,"gi");

	if (pattern.test(str)) 
		return true; 
	else 
		return false; 

}//~~~ 
/*--------------------------------- mask --------------------------------------*/ 
/********************************** file ***************************************/ 
/** 
* added by LxcJie 2004.6.25 
* 得到文件的后缀名 
* oFile为file控件对象 
*/ 
function getFilePostfix(oFile) 
{ 
	if(oFile == null)
	{
		return null; 
	}

	var pattern = /(.*)\\.(.*)$/gi ; 

	if(typeof(oFile) == "object") 
	{ 
		if(oFile.value == null || oFile.value == "") 
		{
			return null; 
		}
		var arr = pattern.exec(oFile.value); 

		return RegExp.$2; 
	} 
	else if(typeof(oFile) == "string") 
	{ 
		var arr = pattern.exec(oFile); 
		return RegExp.$2; 
	} 
	else 
		return null; 
}


/**
*
* 判断长度是否大于规定的长度
*/
function checkMaxLen(val,len)
{
	if(!val) val = "";
	if(len){
		var t = val.replace(/[^\x00-\xff]/ig,"AA");//全角字符处理（汉字，汉字标点等）
		if(t.length > len){
			//alert("输入长度不能超过"+len+"\r\n\r\n目前您输入的长度为(一个汉字占两个长度位置):"+t.length);
			return false;
		}
	}
	return true;
}



/**
*
* 判断长度是否小于规定的长度
*/
function checkMinLen(val,len)
{
	if(!val) val = "";
	if(len){
		var t = val.replace(/[^\x00-\xff]/ig,"AA");//全角字符处理（汉字，汉字标点等）
		if(t.length < len){
			return false;
		}
	}
	return true;
}




/***
*
* 判断是否英文或数字
*/
function checkLetterOrNumber(str)
{
	if(!/^([_a-zA-Z0-9])*([a-zA-Z0-9])*$/.test(str)){
		//alert("输入必须为数字或字母");
		return false;
	}
	return true;
}


/**
*
*判断日期是否合法
*/
function isDatePart(dateStr){
  var parts;

  if(dateStr.indexOf("-") > -1){
    parts = dateStr.split('-');
  }else if(dateStr.indexOf("/") > -1){
    parts = dateStr.split('/');
  }else{
    return false;
  }

  if(parts.length < 3){
  //日期部分不允许缺少年、月、日中的任何一项
    return false;
  }

  for(i = 0 ;i < 3; i ++){
  //如果构成日期的某个部分不是数字，则返回false
    if(isNaN(parts[i])){
      return false;
    }
  }

  y = parts[0];//年
  m = parts[1];//月
  d = parts[2];//日

  if(y > 3000){
    return false;
  }

  if(m < 1 || m > 12){
    return false;
  }

  switch(d){
    case 29:
      if(m == 2){
      //如果是2月份
        if( (y / 100) * 100 == y && (y / 400) * 400 != y){
          //如果年份能被100整除但不能被400整除 (即闰年)
        }else{
          return false;
        }
      }
      break;
    case 30:
      if(m == 2){
      //2月没有30日
        return false;
      }
      break;
    case 31:
      if(m == 2 || m == 4 || m == 6 || m == 9 || m == 11){
      //2、4、6、9、11月没有31日
        return false;
      }
      break;
    default:

  }

  return true;
}

/**
*
*取得radio的值
*/
function getRadioValue(radio)
{
	var dvalue = "";
	var dradio = radio;

	if (!eval(dradio+".length")) 
	{ 
		if (eval(dradio+".checked")) 
		{ 
			dvalue=eval(dradio+".value");
		} 

	}
	else
	{
		for(var i=0;i<eval(dradio+".length");i++)
		{
			if(eval(dradio+"[i].checked"))
			{
				dvalue=eval(dradio+"[i].value");
				break;
			}
		}
	}
	
	return dvalue;
}

/**
*
*判断是否有选择checkbox
*/
function checkselect() 
{ 
    var ifcheck=false; 
	var ifexit=false;
	var ifnull="";
	var inputList = document.dataform.getElementsByTagName("input");
	for(var i=0;i<inputList.length;i++){ 

		var aInput = inputList[i]; 
		
		if(aInput.getAttribute("type")=="checkbox") { 
		 
			 if(aInput.getAttribute("name")=="ID"){ 

				 ifexit=true;

			 }
		}
	}

if(ifexit){
    
	if (document.dataform.ID.length==undefined){
		//alert("aa");//不管单条多条都未选
		if (document.dataform.ID.checked==true) 
		{ 
			 ifcheck=true;
			//alert("bb");//单条有选
		}  

	}else{

		for(var i=0;i<document.dataform.ID.length;i++) 
		{ 
			if (document.dataform.ID[i].checked==true) 
			{ 
				ifcheck=true;
				//alert("cc");//多条有选
			}
		}
	}
}else{
	ifcheck=false;
}

	return ifcheck;

}


/**
*
*组合指定复选框元素值用,号隔开
*/
function getIds(element)
{
	var strids=""; 
	var ele = element;

	for(var i=0;i< eval(ele+".length");i++) 
	{ 
		if (eval(ele+"[i].checked")) 
		{ 
			strids=strids+eval(ele+"[i].value")+",";
		} 
	}
	//alert(eval(ele+".length"));
	if (!eval(ele+".length")) 
	{ 
		if (eval(ele+".checked")) 
		{ 
			strids=eval(ele+".value")+"," 
		} 

	}


	strids=strids.substring(0,strids.length-1); 
	return strids;
	
}