`

项目开发中的common.js

 
阅读更多

pageLoadFinish = false;


function pageFinished()
{
 pageLoadFinish = true;
}
/*
 -------------- 函数检索 --------------
 trim函数:                         trim() lTrim() rTrim()
 检验输入的长度：                       strlength(str)
 校验字符串是否为空:                 checkIsNotEmpty(str)
 校验字符串是否为整型:               checkIsInteger(str)
 校验整型最小值:                    checkIntegerMinValue(str,val)
 校验整型最大值:                    checkIntegerMaxValue(str,val)
 校验整型是否为非负数:               isNotNegativeInteger(str)
 校验是否是数字(包括正数和负数):    isNegativeDouble(str)
 校验两个整型的先后:    checkIntegerEarlier(strStart,strEnd)
 校验字符串是否为浮点型:             checkIsDouble(str)
 校验浮点型最小值:                  checkDoubleMinValue(str,val)
 校验浮点型最大值:                  checkDoubleMaxValue(str,val)
 校验浮点型是否为非负数:             isNotNegativeDouble(str)
 校验浮点型是否为非负数:(小数点后6位)  blurIsNotNegativeDouble_6(str);
 判断浮点型数据的小数位数              blurIsNotNegativeDoublePrecision( checkElement, actionElement, infoStr, precision);
 校验两个日期的先后:                checkDateEarlier(strStart,strEnd)
 校验字符串是否为email型:           checkEmail(str)
 校验字符串是否为中文:               checkIsChinese(str)
 校验字符串是否符合自定义正则表达式:   checkMask(str,pat)
 得到文件的后缀名:                   getFilePostfix(oFile) 
 校验字符串是否为日期型:             checkDate(str)
 校验字符串最大长度:             checkMaxLen(str)
 校验字符串最小长度:             checkMinLen(str)
 校验字符串是否为空:             checkEmpty(str)
 根据生日计算年龄     calcAge( birthDay );
 驾驶证号码检验                  checkDrivinglicenceNo(licenceNo)
 校验字符串最大长度:             getDefauleValue( fieldName, str)
 校验字符串中包含中文字符:             checkStrIncludeChinese(sString)
 checkMoreZeroOnKeyPress( text ) 输入框只能输入数字
function isLeapYear( birthDay );  // 是否为闰年
function addYears( strDate, addNum )  // 计算后几年
function addMonths( strDate, addNum )  // 计算后几月
function addDays( strDate, addNum )  // 计算后几天
idCard15To18       // 身份证 15 转 18位
checkIdcard(str)     //身份证验证书
function checkFieldMaxLength( chkForm ) // 校验输入字段的最大值。
 根据8位日期转换成10位日期   checkDateOnKeyDown( text ); // onKeyDown="checkDateOnKeyDown(this)"
-- 只允许输入浮点数的校验:               checkFloatOnKeyDown(text, n)  // onKeyDown="checkFloatOnKeyDown(this, 2)"

 -------------- 函数检索 --------------
*/
//费率只能输入二位小数
function baserateKeyUp(baserate){
 var decimaldigits;
 var baseratevalue=baserate.value;
   var at_sign  =baseratevalue.indexOf(".");
   var at_sing1=baseratevalue.indexOf(".",at_sign+1);
   if(at_sing1!=-1){
    baserate.value=baseratevalue.substring(0,at_sing1);
    return false;
   }
   if(at_sign!=-1){
    decimaldigits=baseratevalue.substring(at_sign+1,baseratevalue.length); 
    if(decimaldigits.length>2){
     baserate.value=baseratevalue.substring(0,at_sign+1)+baseratevalue.substring(at_sign+1,at_sign+3);
     return false; 
    }
   }
   return true;
 }
//判断是否为数字
function checkInt(tmp){
 //如果为空，则通过校验
    if(tmp == "")
        return true;
for(var i=0;i<tmp.length;i++)
{
 var temp=tmp.substring(i,i+1);
if((temp>='0'&& temp<='9')||(temp=='.'))
 {} //check input in 0-9 and '.'
else{
 return false;
 }
}
return true;
}
// var matchNumberKeyCode = new Array(48,49,50,51,52,53,54,55,56,57);   // '0123456789';
function checkMoreZeroOnKeyPress(text)
{
 var matchNumberKeyChars = '.0123456789';
 if( isSpecialKey() ) return;
 inputChar = String.fromCharCode(event.keyCode);
 if( !isLegalChar( inputChar, matchNumberKeyChars ) )
 {
  event.returnValue=false
 }
 else
 {
  str = text.value;
  len = str.length;
  if( len == 0 )
  {
   if( inputChar == '0' )
    event.returnValue=false
  }
 }
}
function isLegalChar(inputChar,matchStr)
{
 if (matchStr.indexOf (inputChar, 0)==-1) 
  return false;
 else
  return true;
}
function isSpecialKey()
{
 if( event.keyCode <= 32 )
  return true;
 else
  return false;
}
/**
 * added by LxcJie 2004.6.25
 * 去除多余空格函数
 * 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, "");
}

//元素动作
function elementAction( processElement ) {
 if( processElement.type == 'text' || processElement.type == 'textarea' ) {
  processElement.focus();
  processElement.select();
 } else {
  processElement.focus();
 }
}
/********************************** 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;
}

/**
*校验两个整型的先后
*返回值：
*如果其中有一个日期为空，校验通过,          返回true
*如果第一个小于等于第二个，校验通过，   返回true
*如果第一个大于第二个，                 返回false    参考提示信息： 第一个不能大于第二个。
*/
function checkIntegerEarlier(strStart,strEnd)
{
 //如果有一个输入为空，则通过检验
    if (( strStart == "" ) || ( strEnd == "" ))
        return true;
    if(isNotNegativeInteger(strStart) == false || isNotNegativeInteger(strEnd) == false)
        return false;
  
    if(parseInt(strStart,10) > parseInt(strEnd,10))
       return false;
    else
       return true;
}

/**
*校验字符串是否为浮点型
*返回值：
*如果为空，定义校验通过，      返回true
*如果字串全部为浮点型，校验通过，返回true
*如果校验不通过，              返回false     参考提示信息：输入域必须为浮点型！
*/

function checkIsDouble(str,precision)
{
 //如果为空，则通过校验
    if(str == "")
        return true;
    if(precision==null)
     precision=2;
    var checkDouble = /^(-1\+)?\d+(\.\d{1,20})?$/;
    if(precision==2)
      checkDouble = /^(-1\+)?\d+(\.\d{1,2})?$/; //创建正则表达式校验浮点数对象
    else if(precision==3)
      checkDouble = /^(-1\+)?\d+(\.\d{1,3})?$/;
    else if (precision==4)
      checkDouble = /^(-1\+)?\d+(\.\d{1,4})?$/;
    else if (precision==6)
      checkDouble = /^(-1\+)?\d+(\.\d{1,6})?$/;
    if(checkDouble.test(str))
        return true;
    else
        return false;
}

/**
*校验字符串是否为浮点型(小数点后3位)
*返回值：
*如果为空，定义校验通过，      返回true
*如果字串全部为浮点型，校验通过，返回true
*如果校验不通过，              返回false     参考提示信息：输入域必须为浮点型！
*/
function checkIsDouble_6(str)
{
 //如果为空，则通过校验
    if(str == "")
        return true;
    var checkDouble = /^(-1\+)?\d+(\.\d{1,6})?$/; //创建正则表达式校验浮点数对象
    if(checkDouble.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;
}
function isNotNegativeDouble(str,precision)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(checkIsDouble(str,precision) == true)
    {
        if(parseFloat(str) < 0)
            return false;
        else
            return true;
    }
    else
        return false;
}

/**
*校验浮点型是否为非负数
*str：要校验的串。
*
*返回值：
*如果为空，定义校验通过，返回true
*如果非负数，            返回true
*如果是负数，            返回false               参考提示信息：输入值不能是负数！
*/
function isNotNegativeDouble_6(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(checkIsDouble_6(str) == true)
    {
        if(parseFloat(str) < 0)
            return false;
        else
            return true;
    }
    else
        return false;
}


/**
*校验两个日期的先后
*返回值：
*如果其中有一个日期为空，校验通过,          返回true
*如果起始日期早于等于终止日期，校验通过，   返回true
*如果起始日期晚于终止日期，                 返回false    参考提示信息： 起始日期不能晚于结束日期。
*/
function checkDateEarlier(strStart,strEnd)
{
 //如果有一个输入为空，则通过检验
    if (( strStart == "" ) || ( strEnd == "" ))
        return true;
    if(checkDate(strStart) == false || checkDate(strEnd) == false)
        return false;
       
    var strStartYear = strStart.substring(0,4);
 var strStartMonth = strStart.substring(5,7);
 var strStartDay = strStart.substring(8,10);
 
 var strEndYear = strEnd.substring(0,4);
 var strEndMonth = strEnd.substring(5,7);
 var strEndDay = strEnd.substring(8,10);
 
    var d1 = strStartYear + strStartMonth + strStartDay;
    var d2 = strEndYear + strEndMonth + strEndDay;
   
    if(parseInt(d1,10) > parseInt(d2,10))
       return false;
    else
       return true;
}

function checkDateBefore(strStart,strEnd)
{
 //如果有一个输入为空，则通过检验
    if (( strStart == "" ) || ( strEnd == "" ))
        return true;
    if(checkDate(strStart) == false || checkDate(strEnd) == false)
        return false;
       
    var strStartYear = strStart.substring(0,4);
  var strStartMonth = strStart.substring(5,7);
  var strStartDay = strStart.substring(8,10);
 
  var strEndYear = strEnd.substring(0,4);
  var strEndMonth = strEnd.substring(5,7);
  var strEndDay = strEnd.substring(8,10);
 
    var d1 = strStartYear + strStartMonth + strStartDay;
    var d2 = strEndYear + strEndMonth + strEndDay;
   
    if(parseInt(d1,10) > parseInt(d2,10))
       return false;
    else
       return true;
}

// 计算后几年
function addYears( strDate, addNum )
{
 var newdate=getDateObj(strDate);
 year = newdate.getMonth();
 var dateObj = new Date( newdate.getYear()+addNum, newdate.getMonth(), newdate.getDate() );
 return formartDate( dateObj );
}

// 计算后几月
function addMonths( strDate, addNum )
{
 var newdate=getDateObj(strDate);
 year = newdate.getMonth();
 var dateObj = new Date( newdate.getYear(), newdate.getMonth()+addNum, newdate.getDate() );
 return formartDate( dateObj );
}

// 计算后几天
function addDays( strDate, addNum )
{
 var newdate=getDateObj(strDate);
 var newtimems=newdate.getTime()+(addNum*24*60*60*1000);
 newdate.setTime(newtimems);
 return formartDate( newdate );
}

function isLeapYear( year )
{
 if ( ( year % 400 ) == 0 )
   return true;
 else if ( ( year % 4 ) == 0 )
 {
  if ( ( year % 100 ) == 0 )
   return false;
  else return true;
 }
 else return false;
}

function getLastDayOfMonth( strDate )
{
 dayArray = new Array( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
 var newdate=getDateObj(strDate);
 year = newdate.getYear();
 month = newdate.getMonth();
 retn = 0;
 if ( month == 1 )
 {
  if ( isLeapYear(year) )
  {
   retn = 29;
  }
  else
  {
   retn = dayArray[month];
  }
 }
 else
 {
  retn = dayArray[month];
 }
 return retn;
}

// 根据生日计算年龄
function calcAge( birthDay )
{
 var birthYear = parseInt( birthDay.substring(0,4), 10);
    var birthMonth = 0;
    var birthDay = 0;
    if( birthDay.length >= 7 )
    {
  birthMonth = parseInt( (birthDay.substring(5,7)-1), 10);
  if( birthDay.length >= 10 )
     {
   birthDay = parseInt( birthDay.substring(8,10), 10);
  }
 }
 
 var days = new Date();
 var caldate = days.getDate() - birthDay ;
 var calmonth = days.getMonth() - birthMonth;
 var calyear = days.getYear() - birthYear;
 if( caldate < 0 )
  calmonth = calmonth -1;
 if( calmonth < 0 )
  calyear = calyear - 1
 if( calmonth < -11 )
  calyear = calyear - 2
 return calyear;
}

/**
*校验字符串是否为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;
}

/**
*校验字符串是否符合自定义正则表达式
*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;
}
/**
 * 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;
}

//捕捉Enter键下事件并转换为Tab键事件
function keyHandler(evnt)
{
 if (event.keyCode==13 && event.srcElement.tagName != "TEXTAREA" )
     event.keyCode=9;
    return true;
}
//document.onkeydown=keyHandler;

function strlength(str)
{
 if(str==null){
  return 0;
 }
 var len = 0;
 for ( var i = 0;i<str.length;i++)
 {
  if (str.charCodeAt(i)>255)
   len+=2;
  else
   len++;
 }
 return len;
}

function getDateObj( strDate )
{
 try
    {
        var strYear = strDate.substring(0,4);
  var strMonth = strDate.substring(5,7)-1;
  var strday = strDate.substring(8,10);
  var dateObj = new Date( strYear, strMonth, strday );
  return dateObj
    }
    catch( e )
    {
  return;
    }
}

function formartDate( dateObj )
{
 if( dateObj == null )
  return "";
 var year  = dateObj.getFullYear();
 var month = dateObj.getMonth()+1;
 var date  = dateObj.getDate();
 
 var strStart = year;
 if( month < 10 )
  strStart = strStart+"-0"+month
 else
  strStart = strStart+"-"+month
 if( date < 10 )
  strStart = strStart+"-0"+date
 else
  strStart = strStart+"-"+date
 return strStart
}

function checkDate( strDate )
{
 if( strlength(strDate) == 0 )
 {
  return true;
 }
 try
    {
        var strYear = strDate.substring(0,4);
  var strMonth = strDate.substring(5,7)-1;
  var strday = strDate.substring(8,10);
  var dateObj = new Date( strYear, strMonth, strday );
  if (dateObj.getMonth() != parseInt(strMonth,10))
  {
   return false;
  }
    }
    catch( e )
    {
  return false;
    }
    return true;
}

function checkDateYearMonth( strDate )
{
 if( strlength(strDate) == 0 )
 {
  return true;
 }
 try
    {
     if(strlength(strDate) >7 || strlength(strDate) != 7){
      return false;
     }
     if(strDate.substring(4,5)!='-'){
       return false;
     }
        var strYear = strDate.substring(0,4);
  var strMonth = strDate.substring(5,7)-1;
  var strday = "01";
  var dateObj = new Date( strYear, strMonth, strday );
  if (dateObj.getMonth() != parseInt(strMonth,10))
  {
   return false;
  }
    }
    catch( e )
    {
  return false;
    }
    return true;
}

function checkMaxLen( val, len )
{
 if( strlength(val) > len )
 {
  return false;
 }
 return true;
}

function checkMinLen( val, len )
{
 if( strlength(val) < len )
 {
  return false;
 }
 return true;
}

function checkEmpty( val )
{
 if( strlength(val) == 0 )
 {
  return false;
 }
 return true;
}
//失去焦点时验证非负整数
function blurIsNotNegativeInteger( checkElement, actionElement, infoStr ) {
 if( !isNotNegativeInteger( checkElement.value.trim() ) ) 
 {
  alert(infoStr+"应为非负整数!");
  elementAction( actionElement );
  return false;
 }
 return true;
}

//失去焦点时验证非负浮点数(小数点后2位)验证浮点型大于0、F-.2
function blurIsNotNegativeDouble( checkElement, actionElement, infoStr ) {
 if( !isNotNegativeDouble( checkElement.value.trim() ) )
 {
  alert( infoStr+"应为小数点后2位的浮点数!" );
  elementAction( actionElement );
  checkElement.value="";
  return false;
 }
 return true;
}

//失去焦点时验证非负浮点数(小数点后precision位)验证浮点型大于0、F-.2
function blurIsNotNegativeDouble_precision( checkElement, actionElement, infoStr, precision) {
 if( !isNotNegativeDouble( checkElement.value.trim(),3 ) )
 {
  alert( infoStr+"应为小数点后" + precision + "位的浮点数!" );
  elementAction( actionElement );
  checkElement.value="";
  return false;
 }
 return true;
}

//失去焦点时验证非负浮点数(小数点后3位)验证浮点型大于0、F-.3
function blurIsNotNegativeDouble_6( checkElement, actionElement, infoStr ) {
 if( !isNotNegativeDouble_6( checkElement.value.trim() ) )
 {
  alert( infoStr+"应为小数点后6位的浮点数!" );
  elementAction( actionElement );
  checkElement.value="";
  return false;
 }
 return true;
}

//失去焦点时验证日期yyyy-mm-dd
function blurCheckDate( checkElement, actionElement, infoStr ) {
 if( !checkDate( checkElement.value.trim() ) )
 {
  alert("日期值错误！"+infoStr+"应该符合 YYYY-MM-DD 格式。");
  elementAction( actionElement );
  checkElement.value="";
  return false;
 }
 return true;
}
//提交时检查日期是否符合其YYYY-MM的格式
function submitCheckDateYearMonth( checkElement, actionElement, infoStr ) {
 if( !checkDateYearMonth( checkElement.value.trim() ) ) {
  alert("日期值错误！"+infoStr+"应该符合 YYYY-MM 格式。");
  elementAction( actionElement );
  checkElement.value="";
  return false;
 }
}
//失去焦点时验证日期yyyy-mm-dd 初次登记日期的录入控制可以比系统当前日期早40年（包含），也可以比系统当前日期晚2个月
function blurCheckDateYearMonth( checkElement, actionElement, infoStr ) {
 if( !checkDateYearMonth( checkElement.value.trim() ) ) {
  alert("日期值错误！"+infoStr+"应该符合 YYYY-MM 格式。");
  elementAction( actionElement );
  checkElement.value="";
  return false;
 }
 var firstRegisterDateString = document.getElementById('firstRegisterDateString');
 var today = new Date();
 var year = today.getYear();
 var month = today.getMonth()+1;
 var value = checkElement.value.trim();
 var checkYear = value.substring(0,4);
 var checkMonth = value.substring(5);
 if (checkYear > year) {
  alert("初次登记年月不得晚于出单日。");
  form1.firstRegisterDateString.value = '';
  return false;
 }
 if (checkYear == year && checkMonth > (month+2)) {
  alert("初次登记年月不得晚于出单日2个月。");
  form1.firstRegisterDateString.value = '';
  return false;
 }
 if (checkYear < (year - 40)) {
  alert("初次登记年月距离出单日最长提前40年。");
  form1.firstRegisterDateString.value = '';
  return false;
 }
 return true;
}
function removeAllSelectOption( selectObj ){
 var len = selectObj.options.length;
 for(i = 0; i < len; i++){
  selectObj.options.remove(0);
 }
}

function appendSelectOption( selectObj, opt_value, opt_name ){
 var len = selectObj.options.length+1;
 var newOption = document.createElement("OPTION");
 selectObj.options.add(newOption, len);
 newOption.value = opt_value;
 newOption.innerText = opt_name;
}

function appendSelectOptionSelected( selectObj, opt_value, opt_name, opt_selected ){
    var len = selectObj.options.length+1;
    var newOption = document.createElement("OPTION");
    selectObj.options.add(newOption, len);
    newOption.value = opt_value;
    newOption.innerText = opt_name;
    newOption.selected = opt_selected;
}

var base64KeyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

function encode64(input) {
 var output = "";
 var chr1, chr2, chr3 = "";
 var enc1, enc2, enc3, enc4 = "";
 var i = 0;

 do {
   chr1 = input.charCodeAt(i++);
   chr2 = input.charCodeAt(i++);
   chr3 = input.charCodeAt(i++);

   enc1 = chr1 >> 2;
   enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
   enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
   enc4 = chr3 & 63;

   if (isNaN(chr2)) {
   enc3 = enc4 = 64;
   } else if (isNaN(chr3)) {
   enc4 = 64;
   }

   output = output +
   base64KeyStr.charAt(enc1) +
   base64KeyStr.charAt(enc2) +
   base64KeyStr.charAt(enc3) +
   base64KeyStr.charAt(enc4);
   chr1 = chr2 = chr3 = "";
   enc1 = enc2 = enc3 = enc4 = "";
 } while (i < input.length);

 return output;
}

function decode64(input) {
 var output = "";
 var chr1, chr2, chr3 = "";
 var enc1, enc2, enc3, enc4 = "";
 var i = 0;

 // remove all characters that are not A-Z, a-z, 0-9, +, /, or =
 var base64test = /[^A-Za-z0-9\+\/\=]/g;
 if (base64test.exec(input)) {
   alert("There were invalid base64 characters in the input text.\n" +
   "Valid base64 characters are A-Z, a-z, 0-9, '+', '/', and '='\n" +
   "Expect errors in decoding.");
 }
 input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");

 do {
   enc1 = base64KeyStr.indexOf(input.charAt(i++));
   enc2 = base64KeyStr.indexOf(input.charAt(i++));
   enc3 = base64KeyStr.indexOf(input.charAt(i++));
   enc4 = base64KeyStr.indexOf(input.charAt(i++));

   chr1 = (enc1 << 2) | (enc2 >> 4);
   chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
   chr3 = ((enc3 & 3) << 6) | enc4;

   output = output + String.fromCharCode(chr1);

   if (enc3 != 64) {
   output = output + String.fromCharCode(chr2);
   }
   if (enc4 != 64) {
   output = output + String.fromCharCode(chr3);
   }

   chr1 = chr2 = chr3 = "";
   enc1 = enc2 = enc3 = enc4 = "";

 } while (i < input.length);

 return output;
}
 
function adv_format(value,num) //四舍五入
{
 var bool=false;
 var a_str = formatnumber(value,num);
 var a_int = parseFloat(a_str);
 
 if (value.toString().length>a_str.length)
 {
  if(a_int < 0){
   bool=true;
   a_int = Math.abs(a_int);
  }
  var b_str = value.toString().substring(a_str.length,a_str.length+1)
  var b_int = parseFloat(b_str);
  if (b_int<5)
  {
   return a_str
  }
  else
  {
   var bonus_str,bonus_int;
   if (num==0)
   {
    bonus_int = 1;
   }
   else
   {
    bonus_str = "0."
    for (var i=1; i<num; i++)
    bonus_str+="0";
    bonus_str+="10001";
    bonus_int = parseFloat(bonus_str);
   }
   a_str = formatnumber(a_int + bonus_int, num);
   if(bool){
    a_str = "-"+a_str;
   }
  }
 }
 
 return a_str
}

function formatnumber(value,num) //直接去尾
{
 var a,b,c,i
 a = value.toString();
 b = a.indexOf('.');
 c = a.length;
 if (num==0)
 {
  if (b!=-1)
   a = a.substring(0,b);
 }
 else
 {
  if (b==-1)
  {
   a = a + ".";
   for (i=1;i<=num;i++)
    a = a + "0";
  }
  else
  {
   a = a.substring(0,b+num+1);
   for (i=c;i<=b+num;i++)
    a = a + "0";
  }
 }
 return a
}

var matchDateStr = '0123456789';
function checkDateOnKeyDown( text )
{
 if( event.keyCode == 8 || event.keyCode == 9
  || event.keyCode == 37 || event.keyCode == 38 || event.keyCode == 39 || event.keyCode == 40
  || event.keyCode == 46 || event.keyCode == 27 )
  return;
 inputChar = String.fromCharCode(event.keyCode);
 if( !isLegalChar( inputChar, matchDateStr ) )
 {
  event.returnValue=false
 }
 else
 {
  str = text.value;
  len = str.length;
  switch(len)
  {
   case 4:
   case 7:
    if( inputChar != '-' ) // '-'
     str = str+'-';
    break;
  }
  text.value = str;
 }
}

var matchFloatKeyCode = new Array(48,49,50,51,52,53,54,55,56,57,189,190); //'0123456789-.';
// onKeyDown="checkFloatOnKeyDown(this)"
function checkFloatOnKeyDown( text )
{
 if( event.keyCode == 8 || event.keyCode == 9
  || event.keyCode == 37 || event.keyCode == 38 || event.keyCode == 39 || event.keyCode == 40
  || event.keyCode == 46 || event.keyCode == 27 )
  return;
 if( !isLegalKeyCode( event.keyCode, matchFloatKeyCode ) )
 {
  event.returnValue=false
 }
 else
 {
  str = text.value;
  len = str.length;
  if( event.keyCode == 189 && len > 0 )
   event.returnValue=false
  else if( (str == '0' || str == "-0") && event.keyCode != 190 )
  {
   event.returnValue=false
  }
  else
  {
   index = str.indexOf(".");
   if( index != -1 && event.keyCode == 190 )
   {
    event.returnValue=false
   }
  }
 }
}

var matchFloatKeyCode = new Array(48,49,50,51,52,53,54,55,56,57,190);  // '0123456789.';

function checkMoreZeroFloatOnKeyDown( text )
{
 if(event.keyCode==229||(event.keyCode>95 && event.keyCode<106)){
  return;
 }
 if( event.keyCode == 8 || event.keyCode == 9
  || event.keyCode == 37 || event.keyCode == 38 || event.keyCode == 39 || event.keyCode == 40
  || event.keyCode == 46 || event.keyCode == 27 )
  return;
 if( !isLegalKeyCode( event.keyCode, matchFloatKeyCode ) )
 {
  event.returnValue=false
 }
 else
 {
  str = text.value;
  len = str.length;
  if( event.keyCode == 189 && len > 0 )
   event.returnValue=false
  else if( str == '0' && event.keyCode != 190 )
  {
   event.returnValue=false
  }
  else
  {
   index = str.indexOf(".");
   if( index != -1 && event.keyCode == 190 )
   {
    event.returnValue=false
   }
  }
 }
}

var matchNumberKeyCode = new Array(48,49,50,51,52,53,54,55,56,57,189);   // '0123456789-';
function checkNumberOnKeyDown( text, n )
{
 if( event.keyCode == 8 || event.keyCode == 9
  || event.keyCode == 37 || event.keyCode == 38 || event.keyCode == 39 || event.keyCode == 40
  || event.keyCode == 46 || event.keyCode == 27 )
  return;
 if( !isLegalKeyCode( event.keyCode, matchNumberKeyCode ) )
 {
  event.returnValue=false
 }
 else
 {
  str = text.value;
  len = str.length;
  if( len == 1 )
  { 
   if( str == "0" )
    text.value = "";
   else if( str == '-' && event.keyCode == 48 )
    event.returnValue=false
  }
  else if( event.keyCode == 189 )
  {
   event.returnValue=false
  }
 }
}

var matchNumberKeyCode = new Array(48,49,50,51,52,53,54,55,56,57);   // '0123456789';
function checkMoreZeroOnKeyDown( text, n )
{
 if( event.keyCode == 8 || event.keyCode == 9
  || event.keyCode == 37 || event.keyCode == 38 || event.keyCode == 39 || event.keyCode == 40
  || event.keyCode == 46 || event.keyCode == 27 )
  return;
 if( !isLegalKeyCode( event.keyCode, matchNumberKeyCode ) )
 {
  event.returnValue=false
 }
 else
 {
  str = text.value;
  len = str.length;
  if( len == 0 )
  {
   if( event.keyCode == 48 )
    event.returnValue=false
  }
 }
}
function checkMoreAndZeroOnKeyDown( text, n )
{
 if( event.keyCode == 8 || event.keyCode == 9
  || event.keyCode == 37 || event.keyCode == 38 || event.keyCode == 39 || event.keyCode == 40
  || event.keyCode == 46 || event.keyCode == 27 )
  return;
 if( !isLegalKeyCode( event.keyCode, matchNumberKeyCode ) )
  event.returnValue=false
 else
 {
  str = text.value;
  len = str.length;
  if( len == 0 )
   if( event.keyCode == 48 )
    event.returnValue=false
  else if( len == 1 )
   if( str == "0" ) text.value = "";
 }
}

function checkDatebelow18( strDate ) {
 if( strlength(strDate) == 0 ) {
  return true;
 }
 try {
        var strYear = strDate.substring(0,4)-(-18);
  var strMonth = strDate.substring(5,7)-1;
  var strday = strDate.substring(8,10);
  var dateObj = new Date( strYear, strMonth, strday );
  var nowDate = new Date();
  var strStart = dateObj.getFullYear()+'-'+(dateObj.getMonth()-(-1)<10?'0'+(dateObj.getMonth()-(-1)):(dateObj.getMonth()-(-1)))+'-'+(dateObj.getDate()<10?'0'+dateObj.getDate():dateObj.getDate());
  var strEnd = nowDate.getFullYear()+'-'+(nowDate.getMonth()-(-1)<10?'0'+(nowDate.getMonth()-(-1)):(nowDate.getMonth()-(-1)))+'-'+(nowDate.getDate()<10?'0'+nowDate.getDate():nowDate.getDate());
  if( !checkDateEarlier( strStart, strEnd ) ) {
   return false;
  }
    } catch( e ) {
  return false;
    }
    return true;
}

function isLegalString(inputStr,matchStr)
{
 for (i=0; i < inputStr.length; i++) 
 {
  indexChar= inputStr.substring (i, i+1);
  if (matchStr.indexOf (indexChar, 0)==-1) 
   return (false);
 }
 return true;
}

function isLegalChar(inputChar,matchStr)
{
 if (matchStr.indexOf (inputChar, 0)==-1) 
  return false;
 else
  return true;
}
function isLegalKeyCode(keyCode,matchKeyCode)
{
 for( i=0; i<matchKeyCode.length; i++ )
  if (matchKeyCode[i] == keyCode ) 
   return true;
 return false;
}

function idCard15To18(strTemp)
{
 var arrInt = new Array(7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2);
 var arrCh = new Array('1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2');
 var nTemp = 0, i;
 if(strTemp.length==15)
 {
  strTemp = strTemp.substr(0,6) + '19' + strTemp.substr(6,strTemp.length-6);
  for(i = 0; i < strTemp.length; i ++)
  {
   nTemp += strTemp.substr(i, 1) * arrInt[i];
  }
  strTemp += arrCh[nTemp % 11];
 }
 return strTemp;
}

function checkFieldMaxLength( chkForm )  //验证整个Form的元素集合中各个元素的maxLength属性的中文长度问题
{
 len = chkForm.elements.length
 for( i=0; i<len; i++ )
 {
  var field = chkForm.elements[i];
  if ( field.maxLength != 'undefined' && field.maxLength > 0 && field.maxLength < 2147483647 && field.disabled == false && field.style.display == '')
  {
   //alert( field.name +":"+ field.maxLength );
   if( strlength(field.value) > field.maxLength )
   {
    try{
    field.focus();
    field.select();
    alert( "焦点输入框字段不能超过'"+field.maxLength+"'个字符" );
    return false;
    }catch(ex){}
   }
  }
 }
 return true;
}
//驾驶证号码验证
function checkDrivinglicenceNo(licenceNo){
 
 var Errors=new Array(
 "验证通过!",
 "驾驶证号码位数不对!",
 "驾驶证号码出生日期超出范围或含有非法字符!",
 "驾驶证号码校验错误!",
 "驾驶证地区非法!"
 );
 var area={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 licenceNo,Y,JYM;
 var S,M;
 var idcard_array = new Array();
 idcard_array = licenceNo.split("");
 //地区检验
 if(area[parseInt(licenceNo.substr(0,2))]==null)
 return Errors[4];
 //身份号码位数及格式检验
 switch(licenceNo.length){
 case 15:
  if ( (parseInt(licenceNo.substr(6,2))+1900) % 4 == 0 || ((parseInt(licenceNo.substr(6,2))+1900) % 100 == 0 && (parseInt(licenceNo.substr(6,2))+1900) % 4 == 0 )){
    ereg=/^[1-9][0-9]{5}[0-9]{2}((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|[1-2][0-9]))[0-9]{3}$/;//测试出生日期的合法性
  } else {
    ereg=/^[1-9][0-9]{5}[0-9]{2}((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|1[0-9]|2[0-8]))[0-9]{3}$/;//测试出生日期的合法性
  }
  if(ereg.test(licenceNo))
    return Errors[0];
  else
   return Errors[2];
  break;
 case 18:
  //18位身份号码检测
  //出生日期的合法性检查 
  //闰年月日:((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|[1-2][0-9]))
  //平年月日:((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|1[0-9]|2[0-8]))
  if ( parseInt(licenceNo.substr(6,4)) % 4 == 0 || (parseInt(licenceNo.substr(6,4)) % 100 == 0 && parseInt(licenceNo.substr(6,4))%4 == 0 )){
   ereg=/^[1-9][0-9]{5}19[0-9]{2}((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|[1-2][0-9]))[0-9]{3}[0-9Xx]$/;//闰年出生日期的合法性正则表达式
  } else {
   ereg=/^[1-9][0-9]{5}19[0-9]{2}((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|1[0-9]|2[0-8]))[0-9]{3}[0-9Xx]$/;//平年出生日期的合法性正则表达式
  }
  if(ereg.test(licenceNo)){//测试出生日期的合法性
  //计算校验位
  S = (parseInt(idcard_array[0]) + parseInt(idcard_array[10])) * 7
  + (parseInt(idcard_array[1]) + parseInt(idcard_array[11])) * 9
  + (parseInt(idcard_array[2]) + parseInt(idcard_array[12])) * 10
  + (parseInt(idcard_array[3]) + parseInt(idcard_array[13])) * 5
  + (parseInt(idcard_array[4]) + parseInt(idcard_array[14])) * 8
  + (parseInt(idcard_array[5]) + parseInt(idcard_array[15])) * 4
  + (parseInt(idcard_array[6]) + parseInt(idcard_array[16])) * 2
  + parseInt(idcard_array[7]) * 1 
  + parseInt(idcard_array[8]) * 6
  + parseInt(idcard_array[9]) * 3 ;
  Y = S % 11;
  M = "F";
  JYM = "10X98765432";
  M = JYM.substr(Y,1);//判断校验位
  if(M == idcard_array[17])
   return Errors[0]; //检测ID的校验位
  else return Errors[3];
  }
  else
   return Errors[2];
  break;
  default:
  return Errors[1];
  break;
  }
}

function getDefauleValue( fieldName, str)
{
 fieldRef = document.getElementById(fieldName);
 if( fieldRef != null )
 {
  if( fieldRef.value.trim().length > 0  )
  {
   return fieldRef.value.trim();
  }
 }
 return str;
}

function setFieldValue( fieldName, str )
{
 fieldRef = document.getElementById(fieldName);
 if( fieldRef != null )
 {
  fieldRef.value = str;
 }
}
//负浮点数
//校验是否全由数字组成
function isNegativeDouble(str)
{
var patrn=/^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/;
 if(!patrn.test(str)) return false
return true
}


//身份证验证
function checkIdcard(idcard){
 
 var Errors=new Array(
 "验证通过!",
 "身份证号码位数不对!",
 "身份证号码出生日期超出范围或含有非法字符!",
 "身份证号码校验错误!",
 "身份证地区非法!"
 );
 var area={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 idcard,Y,JYM;
 var S,M;
 var idcard_array = new Array();
 idcard_array = idcard.split("");
 //地区检验
 //if(area[parseInt(idcard.substr(0,2))]==null)
 //return Errors[4];
 //身份号码位数及格式检验
 switch(idcard.length){
 case 15:
  if ( (parseInt(idcard.substr(6,2))+1900) % 4 == 0 || ((parseInt(idcard.substr(6,2))+1900) % 100 == 0 && (parseInt(idcard.substr(6,2))+1900) % 4 == 0 )){
    ereg=/^[1-9][0-9]{5}[0-9]{2}((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|[1-2][0-9]))[0-9]{3}$/;//测试出生日期的合法性
  } else {
    ereg=/^[1-9][0-9]{5}[0-9]{2}((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|1[0-9]|2[0-8]))[0-9]{3}$/;//测试出生日期的合法性
  }
  if(!ereg.test(idcard))
    return Errors[2];
  else
   return Errors[0];
  break;
 case 18:
  //18位身份号码检测
  //出生日期的合法性检查 
  //闰年月日:((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|[1-2][0-9]))
  //平年月日:((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|1[0-9]|2[0-8]))
  if ( parseInt(idcard.substr(6,4)) % 4 == 0 || (parseInt(idcard.substr(6,4)) % 100 == 0 && parseInt(idcard.substr(6,4))%4 == 0 )){
   ereg=/^[1-9][0-9]{5}19[0-9]{2}((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|[1-2][0-9]))[0-9]{3}[0-9Xx]$/;//闰年出生日期的合法性正则表达式
  } else {
   ereg=/^[1-9][0-9]{5}19[0-9]{2}((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|1[0-9]|2[0-8]))[0-9]{3}[0-9Xx]$/;//平年出生日期的合法性正则表达式
  }
  if(!ereg.test(idcard)){//测试出生日期的合法性
  //计算校验位
  //S = (parseInt(idcard_array[0]) + parseInt(idcard_array[10])) * 7
  //+ (parseInt(idcard_array[1]) + parseInt(idcard_array[11])) * 9
  //+ (parseInt(idcard_array[2]) + parseInt(idcard_array[12])) * 10
  //+ (parseInt(idcard_array[3]) + parseInt(idcard_array[13])) * 5
  //+ (parseInt(idcard_array[4]) + parseInt(idcard_array[14])) * 8
  //+ (parseInt(idcard_array[5]) + parseInt(idcard_array[15])) * 4
  //+ (parseInt(idcard_array[6]) + parseInt(idcard_array[16])) * 2
  //+ parseInt(idcard_array[7]) * 1 
  //+ parseInt(idcard_array[8]) * 6
  //+ parseInt(idcard_array[9]) * 3 ;
  //Y = S % 11;
  //M = "F";
  //JYM = "10X98765432";
  //M = JYM.substr(Y,1);//判断校验位
  //if(M == idcard_array[17])
  // return Errors[0]; //检测ID的校验位
  //else
  // return Errors[3];
  return Errors[2];
  }
  else
   return Errors[0];
  break;
  
  default:
    return Errors[1];
    break;
  }
}
function showDialog600500( url )
{
 showModalDialog(url,window,"status:false;dialogWidth:600px;dialogHeight:500px;status:no");
}

function showDialog700600( url )
{
 showModalDialog(url,window,"status:false;dialogWidth:800px;dialogHeight:600px;status:no");
}

function showDialog900600( url )
{
 showModalDialog(url,window,"status:false;dialogWidth:900px;dialogHeight:600px;status:no");
}
function showDialog600300( url )
{
 showModalDialog(url,window,"status:false;dialogWidth:610px;dialogHeight:350px;status:no");
}

function CheckYearDate(str){
    var rc=true;
   
    if(str.length != 4){
     rc=false;
     return rc;
    }
   
    if (str+"" == "undefined" || str == null){
        rc=false;
    } else if(str.length==0){
 rc=false;
    } else {
 for(i=0;i<str.length;i++){
 
 if(str.charAt(0)<'1' || str.charAt(i)>'9'){
         rc=false;
         break;
     }
   if(i>0){ 
     if(str.charAt(i)<'0' || str.charAt(i)>'9'){
         rc=false;
         break;
     }
     }
    
 }
    }
    return rc;
}

function setTitle(strtitle)
{
 if( parent )
 {
  parent.document.title = strtitle; 
 }
}


function formatDate( oText )
{
 var oo=oText.value;
 var var1="";
 if( oo.length == 0 )
 {
  return;
 }
 if( oo.length == 6 )
 {
  var year=oo.substring(0,4);
  var month=oo.substring(4,6);
  var1=year+"-"+month;
  oText.value=var1;
 }
 else if(oo.length==7)
 {
  if(oo.substring(4,5)!="-")
  {
   alert("输入格式为 YYYYMM 或 YYYY-MM");
   oText.focus();
   return;
  }
 }
 else if(oo.length==8)
 {
  var year=oo.substring(0,4);
  var month=oo.substring(4,6);
  var dd=oo.substring(6,8);
  var1=year+"-"+month+"-"+dd;
  oText.value=var1;
 }
 else if(oo.length==10)
 {
  if(oo.substring(4,5)!="-" || oo.substring(7,8)!="-")
  {
   alert("输入格式为 YYYYMMDD 或 YYYY-MM-DD");
   oText.focus();
   return;
  }
 }
 else
 {
  alert("输入格式不正确");
  oText.focus();
  return;
 }
}

/**
*校验字符串是否包含中文
*返回值：
*如果包含     返回true
*如果字串不包含中文返回false 
*/
function checkStrIncludeChinese(sString)
{
            var sStr,i,strTemp ;
            sStr = sString.split("");
            var flag = false;
            for (i = 0 ; i < sStr.length ; i ++)
            {
                        strTemp = escape(sStr[i]);
                        if (strTemp.indexOf("%u",0) == -1)
                        {
                                    flag = false ;
                        }
                        else
                        {
                                    flag = true ;
                                    break;
                        }
            }
            return flag ;
}
//判断value是否为日期格式，支持yyyy-MM-dd 和yyyy/MM/dd格式
function isDate(value){
 var reg = /^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2})$/;
 var r = value.match(reg);
 if(r == null)return false;
 var d = new Date(r[1], r[3]-1,r[4]);
 var newStrY = d.getFullYear().toString();
 var newStrM = (d.getMonth()+1).toString();
 var newStrD = d.getDate().toString();
 if(newStrM.length == 1)
 newStrM = "0" + newStrM;
 if(newStrD.length == 1)
 newStrD = "0" + newStrD;
 var newStr = newStrY+r[2]+newStrM+r[2]+newStrD;
 return newStr == value;
}

//right left has
function appendSelectedOption2009(fromObj,toObj,hasObj){
 
 for(var i=0; i<fromObj.options.length;i++){
  var tempOpt= fromObj.options[i];
  if(tempOpt.selected){
    var value = tempOpt.value;
    var text = tempOpt.text;
    for(var j=0;j<toObj.options.length;j++){
        if(value == toObj.options[j].value){
         alert(toObj.options[j].text+"备选项已经添加");
         return;
        }
    }
    for(var j=0;j<hasObj.options.length;j++){
        if(value == hasObj.options[j].value){
         alert(hasObj.options[j].text+"备选项已经存在");
         return;
        }
    }
    var len = toObj.options.length+1;
    var tempOption = document.createElement("OPTION");
    toObj.options.add(tempOption,len);
    tempOption.value=value;
    tempOption.text=text;
  }
  
 }
}
function removeSelectedOption2009(selectObj){
 for(var i = 0;i<selectObj.options.length;i++){
  if(selectObj.options[i].selected){
   selectObj.options[i] = null;
  }
 }
}

//判断浮点型数据的小数位数precision
function blurIsNotNegativeDoublePrecision( checkElement, actionElement, infoStr, precision) {
 if( !isNotNegativeDouble( checkElement.value.trim(),precision ) )
 {
  alert( infoStr+"应为小数点后" + precision + "位的浮点数!" );
  elementAction( actionElement );
  checkElement.value="";
  return false;
 }
 return true;
}


function checkFloatOnKeyPress( text )
{
 var matchFloatKeyChars = '0123456789-.';
 if( isSpecialKey() ) return;
 inputChar = String.fromCharCode(event.keyCode);
 if( !isLegalChar( inputChar, matchFloatKeyChars ) )
 {
  event.returnValue=false
 }
 else
 {
  str = text.value;
  len = str.length;
  
  if( inputChar == '-' && len > 0 )
   event.returnValue=false
  else if( (str == '0' || str == '-0') && (inputChar != '.') )
  {
   event.returnValue=false
  }
  else
  {
   dotIndex = str.indexOf(".");
   if( dotIndex != -1 && inputChar == '.' )
   {
    event.returnValue=false
   }
  }
 }
}

 

function checkNum(text)
{
 str = text.value;
 if(str != null && str != ""){
  var reg=/^[0-9]{1,}(|.[0-9]{1,2})$/;
  if(!reg.test(str)){
   alert("输入格式不正确，只能输入数字、小数点，且小数点后只能有2位！");
   text.focus();
  }
 }
}

function checkIsDoubleByChengs(str)
{
 //如果为空，则通过校验
    if(str == ""){
        return true;
    }

    checkDouble = /^(-|\+)?\d+(\.\d{1,10})?$/;
    if(checkDouble.test(str)){
        return true;
    }else{
        return false;
    }
}
function SetWinHeight(obj){
   var win=obj;
   if (document.getElementById){
         if (win && !window.opera){
                   if (win.contentDocument && win.contentDocument.body.offsetHeight){
                       win.height = win.contentDocument.body.offsetHeight;    
                   }else if(win.Document && win.Document.body.scrollHeight){
                       win.height = win.Document.body.scrollHeight;
                   }
         }
     }
}

 

分享到：
| 杂
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    common.css和common.js及GIF

    在IT行业中，构建交互式网页应用时，"common.css"和"common.js"是常见的资源文件，它们分别用于定义页面的样式和实现交互...同时，理解并掌握"common.css"和"common.js"中的代码结构和逻辑，将有助于提升Web开发技能。

    vue.min.js&vue.min.js&vue.common.js&vue.esm.js&vue.runtime.js等 真实资源共计14个js

    Vue.js 是一个流行的轻量级前端JavaScript框架，用于构建用户界面。它采用了声明式的数据绑定和组件化的设计，使得...在实际项目中，选择正确的Vue.js版本和搭配合适的工具链（如Webpack或Vite）是提升开发效率的关键。

    vue.js和vue.min.js

    Vue.js和Vue.min.js是两种版本的同一款前端JavaScript框架——Vue.js的实现。Vue.js由尤雨溪（Evan You）开发，旨在为构建用户界面提供简洁、易用且可扩展的工具。这两个文件在功能上是相同的，但它们在实际应用中...

    common.js

    总的来说，`common.js`是JavaScript项目中的一种常用模式，它帮助我们实现代码的复用和模块化，提高开发效率。理解和合理使用`common.js`，对于优化项目结构、提升代码质量具有重要意义。在实际开发中，我们应当根据...

    eclipse win64,中文api，jQuery1.8.3，echarts.common.min.js

    4. **echarts.common.min.js**: ECharts 是百度开发的一个基于JavaScript的数据可视化库，支持丰富的图表类型，如折线图、柱状图、饼图等。ECharts.common.min.js 是ECharts的压缩版库文件，它经过压缩和混淆，体积...

    jquery.common通用方法

    jQuery.common就是一种常见的做法，它将常用的jQuery方法进行封装，形成一个通用的方法集合，以方便开发者在项目中复用，提高开发效率。本文将深入探讨jQuery.common的实现原理、常用功能以及如何在实际项目中应用。...

    微信小程序-小商城后台（基于 Node.js、MongoDB、Redis 开发的系统...）

    微信小程序-小商城后台（基于 Node.js、MongoDB、Redis 开发的系统...） 项目说明： 基于 Node.js、MongoDB、Redis 开发的系统 基于 Express 提供 RESTful API 基于 apidoc 提供接口文档 基于 Angular.js、Ionic、...

    vue移动端商城平台后台管理系统，采用node.js+egg+mongoDB，自带后台界面和角色权限管理.zip

    在本项目中，Vue.js 负责构建用户交互丰富的前端界面，提供组件化开发模式，使得代码结构清晰，易于维护。 2. **Node.js**：Node.js 是一个基于Chrome V8引擎的JavaScript运行环境，用于构建高性能的服务器端和网络...

    Vue中通过<script></script>引入的Vue.js文件

    &lt;script src="./js/vue%20(1).js" type="text/javascript" charset="UTF-8"&gt; src里面的内容根据自己的下载的Vue.js的文件位置决定的，我这里只是拿我自己做的举个例子。这个地方的vue.js是因为我下载了两次这个版本...

    Node.js-使用node做server的基础脚手架基于egg.js

    Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境，它让开发者能够在服务器端使用 JavaScript 进行编程，极大地推动了全栈开发的流行。...在实际开发中，你可能需要学习这些杂项来提升你的 Node.js 项目质量。

    项目开发规范..doc项目开发规范..doc

    项目开发规范是软件开发中的重要组成部分，它确保团队成员遵循一致的编码风格和组织结构，从而提高代码的可读性、可维护性和团队协作效率。以下是对提供的项目开发规范的详细说明： 1. **项目包结构**： - `src`: ...

    common文件上

    在移动开发和智能端开发领域，"common文件"通常指的是包含通用代码的模块或库，这些代码可以在多个项目或页面中复用，以提高开发效率和代码一致性。在这个场景下，"公共js"指的是JavaScript文件，它们包含了可以跨...

    sea.js与jquery.mobile-1.3.2，jquery结合实现模块化开发

    "sea.js与jquery.mobile-1.3.2，jquery结合实现模块化开发" 这个标题表明了我们将会探讨如何利用Sea.js（一个JavaScript模块加载器）和jQuery Mobile（一个用于移动设备的前端框架）相结合，进行模块化的Web应用开发...

    echarts.zip

    ECharts是一款基于JavaScript的数据可视化库，它由百度公司开发并开源。这个名为"echarts.zip"的压缩包包含了ECharts的几个核心版本，为开发者提供了丰富的图表类型和强大的交互功能，适用于网页数据展示和分析。...

    sea.js demo 简单实例教程

    Sea.js 是一个遵循 CMD（Common Module Definition）规范的 JavaScript 模块加载器，它旨在为浏览器环境提供模块化的解决方案。CMD 规范与 Node.js 中的 CommonJS 规范类似，但做了针对浏览器的优化。Sea.js 提供了...

    前台web开发代码示例

    在这个"前台web开发代码示例"中，我们可以预期`common.js` 文件包含了一些核心的JavaScript功能，这些功能可以提高开发效率，简化代码结构，并促进代码的重用。 1. **事件处理**：`common.js` 可能包含了各种事件...

    ember.js-master_React_TheCommon_js_webiste_

    Ember.js是一个强大的JavaScript框架，它的目标是提升开发效率，减少构建Web应用所需的时间。它提供了全面的结构和约定，让开发者能够更专注于编写应用程序的业务逻辑，而非基础架构。这个压缩包文件“ember.js-...

    Echarts4.1.0.js

    - **安装**：可以直接通过CDN链接引入，或者将压缩包中的js文件下载到本地项目中引用。 - **初始化**：在HTML中创建一个用于绘图的div元素，然后通过JavaScript调用`echarts.init`方法初始化ECharts实例。 - **...

    echarts.js.zip

    ECharts是一款由百度开发的，基于JavaScript的数据可视化库，它提供了丰富的图表类型，精美的图表设计，以及强大的交互功能。ECharts.js.zip压缩包包含了ECharts的主要版本，这些文件是ECharts库的核心组成部分，...

    element-ui@2.13.2.rar

    "lib" 文件夹通常包含了编译后的 JavaScript 和 CSS 文件，这些文件是 Element UI 的核心，用于在项目中直接引入使用。开发者可以在 HTML 中通过 `&lt;script&gt;` 和 `&lt;link&gt;` 标签引入这些资源，使页面具备 Element UI ...

Magicbox
Global site tag (gtag.js) - Google Analytics