function removeelements(obj)
{
	var rl;
    for(rl=0;rl<obj.options.length;rl++)
       obj.remove(rl);
     if(obj.options.length>0)
        removeelements(obj);
}
 function isEvent1(id)
 {
    var isevent1=false;
    var i=$.inArray(id,IDArray);
    if(i>-1 && Event1[i]=="1")
		isevent1=true;
    return isevent1;
 }
 function isEvent2(id)
 {
    var isevent2=false;
        var i=$.inArray(id,IDArray);
    if(i>-1 && Event2[i]=="1")
		isevent2=true;
    return isevent2;
 }

function saveValueString(id,valueString)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		ValueArray[i]=$.trim(valueString);
}
function saveTextString(id,textString)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		TextArray[i]=$.trim(textString);
}
function saveElementvalue(id,value)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		saveValueArray[i]=value;
}
function saveElementID(id)
{
    if(!checkID(id))
        IDArray[IDArray.length]=id;
}
function saveElementType(id,type)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		TypeArray[i]=type;
 }
function saveEvent1(id,event1)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		Event1[i]=event1;
 }
function saveEvent2(id,event2)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		Event2[i]=event2;
 }
function saveMemo(id,memo)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		Memo[i]=memo;
 }
function saveTitle(id,title)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		Title[i]=title;
 } 
function saveElementCode(id,_code)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		code[i]=_code;
}
function saveElementprecode(id,_precode)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		precode[i]=_precode;
}
function saveElementfoocode(id,_foocode)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		foocode[i]=_foocode;
}
function saveElementLength(id,len)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		LenghtArray[i]=len;
 }
function saveElementKey(id,key)
{            
	var i=$.inArray(id,IDArray);
    if(i>-1)
		KeyArray[i]=key;
 }
 function saveElementName(id,name)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		NameArray[i]=name;
 }
function saveElementLike(id,Like)
{  
	var i=$.inArray(id,IDArray);
    if(i>-1)
		LikeArray[i]=Like;
 }
function saveElementSearch(id,search)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		SearchArray[i]=search;
 }
 
function saveElementBetween(id,between)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		Between[i]=between;
}
function saveElementbg(id,bgs)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		bg[i]=bgs;
}
function saveElemented(id,eds)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		ed[i]=eds;
}             
 
function saveElementBefore(id,before)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		BeforeArray[i]=before;
}
function saveElementComval(id,comval)
{            
	var i=$.inArray(id,IDArray);
    if(i>-1)
		Comval[i]=comval;
}
function saveElementComOp(id,comop)
{            
	var i=$.inArray(id,IDArray);
    if(i>-1)
		ComOp[i]=comop;
}
function saveElementCommsg(id,commsg)
{            
	var i=$.inArray(id,IDArray);
    if(i>-1)
		  Commsg[i]=commsg;
}
function saveElementCom(id,com)
{            
	var i=$.inArray(id,IDArray);
    if(i>-1)
		Com[i]=com;
}
function saveElementRexval(id,rexval)
{            
	var i=$.inArray(id,IDArray);
    if(i>-1)
		 Rexval[i]=rexval;
}
function saveElementRexmsg(id,rexmsg)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		 Rexmsg[i]=rexmsg;
}
function saveElementRex(id,rex)
{            
	var i=$.inArray(id,IDArray);
    if(i>-1)
		RexCom[i]=rex;
}
function saveElementMustmsg(id,mustmsg)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		Mustmsg[i]=mustmsg;
}
function saveElementMust(id,must)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		Must[i]=must;
}
function saveElementOpExp(id,opexp)
{ 
	var i=$.inArray(id,IDArray);
    if(i>-1)
		OpExp[i]=opexp;
}
function saveElementGloab(id,gloab)
{   
	var i=$.inArray(id,IDArray);
    if(i>-1)
		Gloab[i]=gloab;
}
function saveElementGloabSch(id,gloabsch)
{     
	var i=$.inArray(id,IDArray);
    if(i>-1)
		GloabSch[i]=gloabsch;
}
function saveElementvalidGloab(id,validgloab)
{
	var i=$.inArray(id,IDArray);
    if(i>-1)
		validGloab[i]=validgloab;
}
function saveHZ(id,hz)
{           
	var i=$.inArray(id,IDArray);
    if(i>-1)
		pHZ[i]=hz;
}             
function saveHZN(id,hzn)
{     
	var i=$.inArray(id,IDArray);
    if(i>-1)
		pHZN[i]=hzn;
}             
function saveM(id,s)
{        
	var i=$.inArray(id,IDArray);
    if(i>-1)
		savem[i]=s;
}             
function rpl(opexp,i)
{
    var pt = RegExp("@"+IDArray[i].toLowerCase()+"@");
    if(opexp.indexOf("@"+IDArray[i].toLowerCase()+"@")>=0 && (TypeArray[i]=="numeric" || TypeArray[i]=="int"))
    {
        opexp=opexp.replace(pt,parseFloat(I$(IDArray[i]).value));
    }
    else 
    {
    try{
    if(TypeArray[i]=="nvarchar2")
        if($(IDArray[i]).options[$(IDArray[i]).selectedIndex].value!="")
            opexp=opexp.replace(pt,$(IDArray[i]).options[$(IDArray[i]).selectedIndex].text);
        else
            opexp=opexp.replace(pt,'0');//既然加运算，应该为0，原来为''
        }catch(ex){}
    }
    if(opexp.indexOf("@"+IDArray[i].toLowerCase()+"@")>=0 && (TypeArray[i]=="numeric" || TypeArray[i]=="int" || TypeArray[i]=="nvarchar"))
        opexp=rpl(opexp,i);//原来写成opexp=repl(i) ？？？
    return opexp;
}
function expTocal(opexp)
{
    var i;
    for(i=0;i<IDArray.length;i++)
        opexp=rpl(opexp,i);
    return opexp;
}
//可以扩展到其他类型的计算
function calculateResult(obj)
{
    var opexp="";
    if(checkID(obj.id))
    {
        //修改
        var i;
        for(i=0;i<IDArray.length;i++)
        {
            if(OpExp[i].indexOf("@"+obj.id+"@")>=0)
            {
                if(TypeArray[i]=="numeric" || TypeArray[i]=="int" || TypeArray[i]=="nvarchar")//)只此三种类型支持运算事件，当为nvarchar时，企业应该为数字
                {
					try{
                    opexp=OpExp[i].toLowerCase();
                    var _r=expTocal(opexp);
                    if(TypeArray[i]=="numeric" || TypeArray[i]=="int")
                        I$(IDArray[i]).value=eval(_r);
                    else
                        $(IDArray[i]).value=_r;
                        }catch(exp){}
                }
            }
        }
    }
    return opexp;
}
function getNvarchar34Value(id,objsavem)
{
	var objval="";
	var obj=document.getElementsByName(id);
	for(var i=0;i<obj.length;i++)
	{
		if(obj[i].checked)
		{
			if(objsavem=="0")
				objval+=obj[i].value+",";
			else
				objval+=obj[i].title+",";
		}
	}
	if(objval)
		objval=objval.substring(0,objval.length-1);
	else
		objval="";
	if(objval=="")
		objval="*";
	return objval;
}
//检查对象是否存在
function checkID(id)
{
    var _ret=false;
    var _index=$.inArray(id,IDArray);
    if(_index>-1)
		_ret=true;   
    return _ret;
}
//比较条件
function compares(p1,p2,p3)
{
    if(p2=="==" && p1.replace(/(^\s*)|(\s*$)/g, "")==p3)
        return true;
    else if(p2==">" && p1.replace(/(^\s*)|(\s*$)/g, "")>p3)
        return true;
    else if(p2==">=" && p1.replace(/(^\s*)|(\s*$)/g, "")>=p3)
        return true;
    else if(p2=="<" && p1.replace(/(^\s*)|(\s*$)/g, "")<p3)
        return true;
    else if(p2=="<=" && p1.replace(/(^\s*)|(\s*$)/g, "")<=p3)
        return true;
    else if(p2=="<>" && p1.replace(/(^\s*)|(\s*$)/g, "")!=p3)
        return true;
    else
        return false;
}


//过滤/的方法
function replaces(str)
{
    var _r="";
    if(str!="")
    {
        _r=str.replace("/", "");
        if(_r.indexOf("/")>=0)
            _r=replaces(_r); 
    }
    return _r;
}
//执行js代码 jsCode不包含<script>
function executeJS(jsCode)
{
    var jsIframe = document.createElement("iframe");
    jsIframe.style.display = "none";//把jsIframe隐藏起来
    document.body.appendChild(jsIframe);
    with(window.frames[window.frames.length - 1]){
        document.open();
        document.write("<script>"+jsCode+"</script>"); //执行JS代码
        document.close();
    }
    //document.body.removeChild(jsIframe);//执行后删除iframe对象
}

/*
/// <summary>
/// 返回开始结束标志区间字符串
/// </summary>
/// <param name="MarkStart">开始标识</param>
/// <param name="MarkEnd">结束标识</param>
/// <param name="parentString">原字符串</param>
/// <returns></returns>
*/
function getString(MarkStart, MarkEnd, parentString)
{
	var _tempstring = "";
	var _startFlag = 0;
	var _endFlag = 0;
	var _markstartLength = MarkStart.length;
	_startFlag = parentString.indexOf(MarkStart);
	_endFlag = parentString.lastIndexOf(MarkEnd);
	if (_startFlag >= 0 && _endFlag > 0)
		_tempstring = parentString.substr(_startFlag + _markstartLength, _endFlag - _startFlag - _markstartLength);
	return _tempstring;
}

/*   
-------------- 函数检索 --------------   
trim函数:                         trim() lTrim() rTrim()   
校验字符串是否为空:                 checkIsNotEmpty(str)   
校验字符串是否为整型:               checkIsInteger(str)   
校验整型最小值:                    checkIntegerMinValue(str,val)   
校验整型最大值:                    checkIntegerMaxValue(str,val)   
校验整型是否为非负数:               isNotNegativeInteger(str)   
校验字符串是否为浮点型:             checkIsDouble(str)   
校验浮点型最小值:                  checkDoubleMinValue(str,val)   
校验浮点型最大值:                  checkDoubleMaxValue(str,val)   
校验浮点型是否为非负数:             isNotNegativeDouble(str)   
校验字符串是否为日期型:             checkIsValidDate(str)   
校验两个日期的先后:                checkDateEarlier(strStart,strEnd)   
校验字符串是否为email型:           checkEmail(str)   
  
校验字符串是否为中文:               checkIsChinese(str)   
计算字符串的长度，一个汉字两个字符:   realLength()   
校验字符串是否符合自定义正则表达式:   checkMask(str,pat)   
得到文件的后缀名:                   getFilePostfix(oFile)    
-------------- 函数检索 --------------   
*/   
   
/**   
* 去除多余空格函数   
* 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, "");    
}     
   
/**   
*校验字符串是否为空   
*返回值：   
*如果不为空，定义校验通过，返回true   
*如果为空，校验不通过，返回false    
*参考提示信息：输入域不能为空！   
*/   
function checkIsNotEmpty(str) {    
    if(str.trim() == "")    
        return false;
    else
        return true;
}    
   
/**   
*校验字符串是否为整型   
*返回值：   
*如果为空，定义校验通过，返回true   
*如果字串全部为数字，校验通过，返回true   
*如果校验不通过，返回false    
*参考提示信息：输入域必须为数字！   
*/   
function checkIsInteger(str){    
    //如果为空，则通过校验    
  if(str == "")    
        return true;    
//    if(/^(\\-?)(\\d+)$/.test(str))     
var pt= new RegExp("^-?\\d+$");//^-?\\d+$
if(pt.exec(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;    
    }    
}    
   
/**   
*校验字符串是否为浮点型   
*返回值：   
*如果为空，定义校验通过，返回true   
*如果字串为浮点型，校验通过，返回true   
*如果校验不通过，返回false   
*参考提示信息：输入域不是合法的浮点数！   
*/   
function checkIsDouble(str) {    
    //如果为空，则通过校验    
  if(str == "")    
        return true;    
    //如果是整数，则校验整数的有效性    
  if(str.indexOf(".") == -1) {    
        if(checkIsInteger(str) == true)    
            return true;    
        else   
            return false;    
    } else {
		var pt= new RegExp("^(-?\\d+)(\\.\\d+)?$");
		if(pt.exec(str))     
        //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;    
    }    
}    
   
/**   
*校验字符串是否为日期型   
*返回值：   
*如果为空，定义校验通过，返回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;
	var pattern= new RegExp("^((\\d{4})|(\\d{2}))-(\\d{1,2})-(\\d{1,2})$");
//	  if(!pattern.test(str))
	if(!pattern.exec(str))
        return false;
    var arrDate = str.split("-");
    if(parseInt(arrDate[0],10) < 100)
        arrDate[0] = 1900 + 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;    
}    
   
/**   
*校验字符串是否为email型   
*返回值：   
*如果为空，定义校验通过，返回true   
*如果字串为email型，校验通过，返回true   
*如果email不合法，返回false       
*参考提示信息：Email的格式不正確！   
*/   
function checkEmail(str) {    
    //如果为空，则通过校验    
  if(str == "")    
        return true;    
    if (str.charAt(0) == "." || str.charAt(0) == "@" || str.indexOf("@", 0) == -1  
		|| str.indexOf(".", 0) == -1 || str.lastIndexOf("@") == str.length-1 || str.lastIndexOf(".") == str.length-1)    
        return false;    
    else   
        return true;    
}
   
/**   
*校验字符串是否为中文   
*返回值：   
*如果为空，定义校验通过，返回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;    
}    
   
/**   
*校验字符串是否符合自定义正则表达式   
*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;    
}    
   
/**   
* 得到文件的后缀名   
* 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 itemOnMouseOver()
    {
        event.srcElement.style.color='#ffffff';
        event.srcElement.style.background='#0000ff';
    }
    
    function itemOnMouseOut()
    {
        event.srcElement.style.color='#000000';
        event.srcElement.style.background='#f5f5f5';
    }
/**
* 时间对象的格式化;
*/
Date.prototype.format = function(format){
/*
* eg:format="YYYY-MM-dd hh:mm:ss";
*/
var o = {
"M+" : this.getMonth()+1, //month
"d+" : this.getDate(), //day
"h+" : this.getHours(), //hour
"m+" : this.getMinutes(), //minute
"s+" : this.getSeconds(), //second
"q+" : Math.floor((this.getMonth()+3)/3), //quarter
"S" : this.getMilliseconds() //millisecond
}


if(/(y+)/.test(format)) {
format = format.replace(RegExp.$1, (this.getFullYear()+"").substr(4 - RegExp.$1.length));
}


for(var k in o) {
if(new RegExp("("+ k +")").test(format)) {
format = format.replace(RegExp.$1, RegExp.$1.length==1 ? o[k] : ("00"+ o[k]).substr((""+ o[k]).length));
}
}
return format;
}