/* FUNCTION---------------------------------------------trim
功能：
	去除字符串两端的空格
参数：
	String	str 字符串
返回：
	String	去除两端空格的字符串
*/
function trim(str)
{
	var left = 0;
	var right = -1;
	for(var i=0;i<str.length;i++)
		if(str.charAt(i)!=" ")
		{
			left = i;
			break;
		}
	for(var i=str.length-1;i>=0;i--)
		if(str.charAt(i)!=" ")
		{
			right = i+1;
			break;
		}
	return str.substring(left,right);
}

/* FUNCTION---------------------------------------------extract_left
功能：
	从字符串左边提取指定数量的字符
参数：
	int	total_chars 整数
返回：
	String	从字符串左边提取指定数量的字符
*/
function extract_left(total_chars){
	return this.substring(0,total_chars)
}

/* FUNCTION---------------------------------------------extract_left
功能：
	从字符串右边提取指定数量的字符
参数：
	int	total_chars 整数
返回：
	String	从字符串右边提取指定数量的字符
*/
function extract_right(total_chars){
	return this.substring(this.length - total_chars)
}

/* FUNCTION---------------------------------------------concentrate
功能：
	使对象获取焦点
参数：
	object	obj 对象
返回：
	无
*/
function concentrate(obj)
{
	try
	{
		obj.select();
	}
	catch(e)
	{
		obj.focus();
	}
}

/* FUNCTION---------------------------------------------isNotBlank
功能：
	判断输入值是否不为空
参数：
	Object	obj 标签对象
	boolean	是否先去除字符串两端的空格
返回：
	boolean	输入值是否不为空
*/
function isNotBlank(obj,isSpaceFilter)
{
	if(isSpaceFilter)
		obj.value = trim(obj.value);
	if(obj.value!="")
		return true;
	else
	{
		concentrate(obj);
		alert("\""+obj.msgname+"\" 不能为空");
		return false;
	}
}

/* FUNCTION---------------------------------------------isNotBlankEx
功能：
	判断输入值是否不为空（去除字符串两端的空格）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否不为空
*/
function isNotBlankEx(obj)
{
	return isNotBlank(obj,true);
}

/* FUNCTION---------------------------------------------isNumber
功能：
	判断输入值是否为数值
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为数值
*/
function isNumber(obj)
{
	obj.value = trim(obj.value);
	if(obj.value=="")
		return true;
	if(!isNaN(obj.value))
		return true;
	else
	{
		concentrate(obj);
		alert("\""+obj.msgname+"\" 必须为数字");
		return false;
	}
}

/* FUNCTION---------------------------------------------isInteger
功能：
	判断输入值是否为整数
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为整数
*/
function isInteger(obj)
{
	obj.value = trim(obj.value);
	if(obj.value=="")
		return true;
	if(isNaN(obj.value))
	{
		concentrate(obj);
		alert("\""+obj.msgname+"\" 必须为整数");
		return false;
	}	
	if(parseInt(obj.value,10)==parseFloat(obj.value))
		return true;
	else
	{
		concentrate(obj);
		alert("\""+obj.msgname+"\" 必须为整数");
		return false;
	}
}

/* FUNCTION---------------------------------------------isBetween
功能：
	判断输入值是否在一区间内
参数：
	Object	obj 标签对象
	float	nMin 左边界取值
	boolean	isContainMin 是否左边界为闭区间
	float	nMax 右边界取值
	boolean isContainMax 是否右边界为闭区间
返回：
	boolean	输入值是否在一区间内
*/
function isBetween(obj,nMin,isContainMin,nMax,isContainMax)
{
	obj.value = trim(obj.value);
	if(obj.value=="")
		return true;
	if(isNaN(obj.value))
	{
		concentrate(obj);
		alert("\""+obj.msgname+"\" 必须为数字");
		return false;
	}
	var result = parseFloat(obj.value);
	var condition1 = (result>nMin && !isContainMin) || (result>=nMin && isContainMin);
	var condition2 = (result<nMax && !isContainMax) || (result<=nMax && isContainMax);
	if(condition1 && condition2)
		return true;
	else
	{
		concentrate(obj);
		var msg = "\""+obj.msgname+"\" 必须在区间";
		if(isContainMin)
			msg += "[";
		else
			msg += "(";
		msg += nMin+","+nMax;
		if(isContainMax)
			msg += "]";
		else
			msg += ")";
		msg += " 内";
		alert(msg);
		return false;
	}
}

/* FUNCTION---------------------------------------------isBetweenEx
功能：
	判断输入值是否在一区间内（左边界为闭区间，右边界为闭区间）
参数：
	Object	obj 标签对象
	float	nMin 左边界取值
	float	nMax 右边界取值
返回：
	boolean	输入值是否在一区间内
*/
function isBetweenEx(obj,nMin,nMax)
{
	return isBetween(obj,nMin,true,nMax,true);
}

/* FUNCTION---------------------------------------------isBelow
功能：
	判断输入值是否小于某一数值
参数：
	Object	obj 标签对象
	float	nMax 右边界取值
	boolean isContainMax 是否右边界为闭区间
返回：
	boolean	输入值是否小于某一数值
*/
function isBelow(obj,nMax,isContainMax)
{
	obj.value = trim(obj.value);
	if(obj.value=="")
		return true;
	var result = parseFloat(obj.value);
	if(result<nMax && !isContainMax || result<=nMax && isContainMax)
		return true;
	else
	{
		concentrate(obj);
		var msg = "\""+obj.msgname+"\" 必须小于";
		if(isContainMax)
			msg += "等于";
		msg += " "+nMax;
		alert(msg);
		return false;
	}
}

/* FUNCTION---------------------------------------------isBelowEx
功能：
	判断输入值是否小于某一数值（右边界为闭区间）
参数：
	Object	obj 标签对象
	float	nMax 右边界取值
	boolean isContainMax 是否右边界为闭区间
返回：
	boolean	输入值是否小于某一数值
*/
function isBelowEx(obj,nMax)
{
	return isBelow(obj,nMax,true);
}

/* FUNCTION---------------------------------------------isAbove
功能：
	判断输入值是否大于某一数值
参数：
	Object	obj 标签对象
	float	nMin 左边界取值
	boolean isContainMin 是否左边界为闭区间
返回：
	boolean	输入值是否大于某一数值
*/
function isAbove(obj,nMin,isContainMin)
{
	obj.value = trim(obj.value);
	if(obj.value=="")
		return true;
	var result = parseFloat(obj.value);
	if(result>nMin && !isContainMin || result>=nMin && isContainMin)
		return true;
	else
	{
		concentrate(obj);
		var msg = "\""+obj.msgname+"\" 必须大于";
		if(isContainMin)
			msg += "等于";
		msg += " "+nMin;
		alert(msg);
		return false;
	}
}

/* FUNCTION---------------------------------------------isAboveEx
功能：
	判断输入值是否大于某一数值（左边界为闭区间）
参数：
	Object	obj 标签对象
	float	nMin 左边界取值
	boolean isContainMin 是否左边界为闭区间
返回：
	boolean	输入值是否大于某一数值
*/
function isAboveEx(obj,nMin)
{
	return isAbove(obj,nMin,true);
}

/* FUNCTION---------------------------------------------isPositiveNumber
功能：
	判断输入值是否为正数
参数：
	Object	obj 标签对象
	boolean isContainZero 是否允许零为合法
返回：
	boolean	输入值是否为正数
*/
function isPositiveNumber(obj,isContainZero)
{
	return isAbove(obj,0,isContainZero);
}

/* FUNCTION---------------------------------------------isPositiveNumberEx
功能：
	判断输入值是否为正数（允许零为合法）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为正数
*/
function isPositiveNumberEx(obj)
{
	return isPositiveNumber(obj,true);
}

/* FUNCTION---------------------------------------------isValidString
功能：
	判断输入值是否为指定的合法字符串
参数：
	Object	obj 标签对象
	String	species 合法字符集
	boolean isSpaceFilter 是否先去除字符串两端的空格
返回：
	boolean	输入值是否为指定的合法字符串
*/
var VS_LETTER = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
var VS_NUMBER = "0123456789";
var VS_DOC = ".";
var VS_FU = "-";
var VS_LINK = "-_";
var VS_MENEY = VS_NUMBER + VS_DOC;
var VS_MENEYFU = VS_NUMBER + VS_DOC + VS_FU;
var VS_BASIC = VS_LETTER + VS_NUMBER;
var VS_CHAR = VS_LETTER + VS_NUMBER + VS_LINK;
var VS_COMMON = "@$()/.- _\n\r" + VS_BASIC;
function isValidString(obj,species,isSpaceFilter)
{
	if(isSpaceFilter)
		obj.value = trim(obj.value);
	if(obj.value=="")
		return true;
	for(var i=0;i<obj.value.length;i++)
		if(species.indexOf(obj.value.charAt(i))<0)
		{
			concentrate(obj);
			alert("\""+obj.msgname+"\" 不能包含字符 \""+obj.value.charAt(i)+"\"");
			return false;
		}
	return true;
}

/* FUNCTION---------------------------------------------isValidCharEx
功能：
	判断输入值是否为指定的合法字符串（以VS_CHAR为合法字符集，先去除字符串两端的空格）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为指定的合法字符串
*/
function isValidCharEx(obj)
{
	return isValidString(obj,VS_CHAR,true);
}

/* FUNCTION---------------------------------------------isValidStringEx
功能：
	判断输入值是否为指定的合法字符串（以VS_COMMON为合法字符集，先去除字符串两端的空格）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为指定的合法字符串
*/
function isValidStringEx(obj)
{
	return isValidString(obj,VS_COMMON,true);
}

/* FUNCTION---------------------------------------------isValidChineseString
功能：
	判断输入值是否为指定的合法的中文字符串
参数：
	Object	obj 标签对象
	String	species 其它合法字符集
	boolean isSpaceFilter 是否先去除字符串两端的空格
返回：
	boolean	输入值是否为指定的合法中文字符串
*/
function isValidChineseString(obj,species,isSpaceFilter)
{
	if(isSpaceFilter)
		obj.value = trim(obj.value);
	if(obj.value=="")
		return true;
	for(var i=0;i<obj.value.length;i++)
		if(species.indexOf(obj.value.charAt(i))<0 && obj.value.charCodeAt(i)<19968)
		{
			concentrate(obj);
			alert("\""+obj.msgname+"\" 不能包含字符 \""+obj.value.charAt(i)+"\"");
			return false;
		}
	return true;
}

/* FUNCTION---------------------------------------------isValidChineseStringEx
功能：
	判断输入值是否为指定的合法的中文字符串（以VS_COMMON为其它合法字符集，先去除字符串两端的空格）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为指定的合法中文字符串
*/
function isValidChineseStringEx(obj)
{
	return isValidChineseString(obj,VS_COMMON,true);
}

/* FUNCTION---------------------------------------------isValidExtendedString
功能：
	判断输入值是否为指定的合法的扩展（含中文）字符串
参数：
	Object	obj 标签对象
	String	species 其它合法字符集
	boolean isSpaceFilter 是否先去除字符串两端的空格
返回：
	boolean	输入值是否为指定的合法扩展（含中文）字符串
*/
function isValidExtendedString(obj,species,isSpaceFilter)
{
	if(isSpaceFilter)
		obj.value = trim(obj.value);
	if(obj.value=="")
		return true;
	for(var i=0;i<obj.value.length;i++)
		if(species.indexOf(obj.value.charAt(i))<0 && obj.value.charCodeAt(i)<128)
		{
			concentrate(obj);
			alert("\""+obj.msgname+"\" 不能包含字符 \""+obj.value.charAt(i)+"\"");
			return false;
		}
	return true;
}

/* FUNCTION---------------------------------------------isValidExtendedStringEx
功能：
	判断输入值是否为指定的合法的扩展（含中文）字符串（以VS_COMMON为其它合法字符集，先去除字符串两端的空格）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为指定的合法扩展（含中文）字符串
*/
function isValidExtendedStringEx(obj)
{
	return isValidExtendedString(obj,VS_COMMON,true);
}

/* FUNCTION---------------------------------------------isStandardDate
功能：
	判断输入值是否为合法的日期类型（格式为yyyy?mm?dd其中年份必须为[1000,9999]）
参数：
	Object	obj 标签对象
	String	conjunction 为年月日的连接符（长度为1）
返回：
	boolean	输入值是否为合法的日期类型
*/
function isStandardDate(obj,conjunction)
{
	obj.value = trim(obj.value);
	if(obj.value=="")
		return true;
	if(obj.value.charAt(4)!=conjunction || obj.value.charAt(7)!=conjunction)
	{
		concentrate(obj);
		alert("\""+obj.msgname+"\" 不是合法的日期类型 yyyy"+conjunction+"mm"+conjunction+"dd");
		return false;
	}
	var year = obj.value.substring(0,4);
	var month = obj.value.substring(5,7);
	var day = obj.value.substring(8,10);
	var condition1 = isNaN(year) || isNaN(month) || isNaN(day);
	var condition2 = parseInt(year,10)!=parseFloat(year) || parseInt(month,10)!=parseFloat(month) || parseInt(day,10)!=parseFloat(day)
	if(condition1 || condition2)
		return false;
	var d = new Date(parseInt(year,10),parseInt(month,10)-1,parseInt(day,10));
	year = d.getFullYear();
	month = d.getMonth()+1;
	day = d.getDate();
	var temp = year+conjunction;
	if(month<10)
		temp+="0";
	temp+=month+conjunction;
	if(day<10)
		temp+="0";
	temp+=day;
	if(obj.value==temp)
		return true;
	else
	{
		concentrate(obj);
		alert("\""+obj.msgname+"\" 不是合法的日期类型 yyyy"+conjunction+"mm"+conjunction+"dd");
		return false;
	}
}

/* FUNCTION---------------------------------------------isStandardDateEx
功能：
	判断输入值是否为合法的日期类型（格式为yyyy?mm?dd其中年份必须为[1000,9999]，年月日连接符为“/”）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为合法的日期类型
*/
function isStandardDateEx(obj)
{
	return isStandardDate(obj,"/");
}

/* FUNCTION---------------------------------------------isLengthBetween
功能：
	判断输入值长度是否在一闭区间内
参数：
	Object	obj 标签对象
	int		nMin 长度左边界
	int		nMax 长度右边界
返回：
	boolean	输入值长度是否在一闭区间内
*/
function isLengthBetween(obj,nMin,nMax)
{
	obj.value = trim(obj.value);
	if(obj.value=="")
		return true;
	if(obj.value.length>=nMin && obj.value.length<=nMax)
		return true;
	else
	{
		concentrate(obj);
		if(nMin==nMax)
			alert("\""+obj.msgname+"\" 必须含有 "+nMin+" 个字符");
		else
			alert("\""+obj.msgname+"\" 必须含有 "+nMin+"-"+nMax+" 个字符");
		return false;
	}
}

/* FUNCTION---------------------------------------------isLengthBelow
功能：
	判断输入值长度是否小于某一值
参数：
	Object	obj 标签对象
	int		nMax 长度右边界
返回：
	boolean	输入值长度是否小于某一值
*/
function isLengthBelow(obj,nMax)
{
	return isLengthBetween(obj,0,nMax);
}

/* FUNCTION---------------------------------------------isLengthEqual
功能：
	判断输入值长度是否为某一值
参数：
	Object	obj 标签对象
	int		n 字符串必须长度
返回：
	boolean	输入值长度是否为某一值
*/
function isLengthEqual(obj,n)
{
	return isLengthBetween(obj,n,n);
}

/* FUNCTION---------------------------------------------isNotContain
功能：
	判断输入值是否不含有某些字符
参数：
	Object	obj 标签对象
	String	species 不合法字符集
	boolean isSpaceFilter 是否先去除字符串两端的空格
返回：
	boolean	输入值是否不含有某些字符
*/
var NC_BASIC = "<>";
var NC_COMMON = NC_BASIC+"\"\'";
function isNotContain(obj,species,isSpaceFilter)
{
	if(isSpaceFilter)
		obj.value = trim(obj.value);
	if(obj.value=="")
		return true;
	for(var i=0;i<species.length;i++)
		if(obj.value.indexOf(species.charAt(i))>=0)
		{
			concentrate(obj);
			alert("\""+obj.msgname+"\" 不能包含字符 \""+species.charAt(i)+"\"");
			return false;
		}
	return true;
}

/* FUNCTION---------------------------------------------isNotContainEx
功能：
	判断输入值是否不含有某些字符（以NC_COMMON为不合法字符集，先去除字符串两端的空格）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否不含有某些字符
*/
function isNotContainEx(obj)
{
	return isNotContain(obj,NC_COMMON,true);
}

/* FUNCTION---------------------------------------------isContain
功能：
	判断输入值是否含有某些字符（不去除字符串两端的空格）
参数：
	Object	obj 标签对象
	String	species 必须含有的字符集
返回：
	boolean	输入值是否含有某些字符
*/
function isContain(obj,species)
{
	if(obj.value=="")
		return true;
	for(var i=0;i<species.length;i++)
		if(obj.value.indexOf(species.charAt(i))<0)
		{
			concentrate(obj);
			alert("\""+obj.msgname+"\" 必须包含字符 \""+species.charAt(i)+"\"");
			return false;
		}
	return true;
}