在线考试系统

最近做了一个非常简单的在线考试系统：JSP+Servlet+mysql+ajax+存储过程，把一些遇到的问题发到这里记录一下

Aptana Plugin For Eclipse 1.2.7 破解

针对最新的aptana_update_024747，可以从 http://www.aptana.com/download/下载并安装。

安装完成后，在eclipse/plugins目录中找到 com.aptana.ide.core_1.2.7.024747.jar

用jad或者相关反编译软件反编译 com.aptana.ide.core.licensing.ClientKey 这个类，我用的是 http://proglife.yo2.cn/articles/eclipse%E4%B8%8B%E7%9A%84%E5%8F%8D%E7%BC%96%E8%AF%91%E6%96%B9%E6%A1%88.html 里边的方案进行反编译的。

新建一个Java类ClientKey，将反编译出来的代码粘贴到这个类中，并修改如下：

package com.aptana.ide.core.licensing;

import java.util.Calendar;
import java.util.TimeZone;

public final class ClientKey
{
  public static final String BEGIN_LICENSE_MARKER = "--begin-aptana-license--";
  public static final String END_LICENSE_MARKER = "--end-aptana-license--";
  public static final int PRO = 0;
  public static final int TRIAL = 1;
  private static final TimeZone GMT = TimeZone.getTimeZone("GMT");
  public static final String EMAILS_NON_MATCHING = "EMAILS_NON_MATCHING";
  public static final ClientKey EMPTY_KEY = new ClientKey(1, "any@gmail.com", 0L);
  private String email;
  private long expiration;
  private int type;

  public ClientKey(int type, String email, long expiration)
  {
    this.type = type;
    this.email = email;
    this.expiration = expiration;
  }

  public boolean isCloseToExpiring()
  {
    return false;
  }

  public boolean isValid()
  {
    return true;
  }

  public boolean isCloseToMatching()
  {
    return true;
  }

  public boolean isExpired()
  {
   return false;
  }

  public String getEmail()
  {
      return "any@gmail.com";
  }

  public Calendar getExpiration()
  {
    Calendar expirationCal = Calendar.getInstance();
    expirationCal.add(Calendar.YEAR, 50);
    return expirationCal;
  }

  public boolean isTrial()
  {
    return false;
  }

  public boolean isPro()
  {
    return (!(isTrial()));
  }

  public boolean shouldProPluginsRun()
  {
    if (isPro())
    {
      return true;
    }
    return (!(isExpired()));
  }

  public static String trimEncryptedLicense(String encrypted)
  {
    String newEncrypted = encrypted;
    newEncrypted = newEncrypted.trim();
    newEncrypted = newEncrypted.replaceAll("--begin-aptana-license--", "");
    newEncrypted = newEncrypted.replaceAll("--end-aptana-license--", "");
    newEncrypted = newEncrypted.replaceAll("\\s+", "");
    return newEncrypted;
  }
}

注意红色的是修改的部分。

编译该文件，并用生成的class文件替换com.aptana.ide.core_1.2.7.024747.jar中的ClientKey.class文件。（可用winrar打开后直接拖进去覆盖）。

重新启动eclipse即可生效。效果图如下：

相册程序中的表单检查

<script language="JavaScript" type="text/javascript">
<!--
function checkForm(){
    var filename=document.getElementById("photos").value;
    if(filename==""){
        alert("请先选择要上传的照片后再确定上传！");
        return false;
    }else{
        if(!IsImageName(filename)){
            alert("只允许上传jpg、jpeg、png形式的图片!");
            return false;
        }
    }
    return true;
}
function IsImageName(filename){
    var regex=/^.*(\\|\/)[^\.]+.(jpg|png|jpeg)$/
    var splitted=filename.match(regex);
    if(splitted==null)
        return false;
    return true;
}
//-->
</script>

 

<form action="../servlet/PhotoUpload" method="post" enctype="multipart/form-data" name="form1" id="form1" onsubmit="return checkForm();">
  <table width="67%" border="0" cellspacing="0" cellpadding="0">
    <tr>
      <td>选择文件</td>
      <td><input type="file" name="photos" id="photos" /></td>
    </tr>
    <tr>
      <td valign="top">照片说明</td>
      <td><textarea name="description" id="description" cols="36" rows="3"></textarea></td>
    </tr>
    <tr>
      <td colspan="2"><center>
        <input name="btnSubmit" type="submit" id="btnSubmit" value="上传" />
      </center>
      </td>
      </tr>
  </table>
  </form>

使用javascript显示页面装载过程进度条

<script language="javascript" type="text/javascript">
var percent=0;          //百分比进度，显示在滚动条后面
var element="||";      //滚动条单元竖线
var elements="||";    //滚动条当前竖线
count();                //开始调用循环

function count(){
    percent=percent+10;    //每次百分比加10
    elements =elements + element;  //滚动条当前竖线增加一个滚动条单元竖线
    document.loading.bar.value=elements; //设置窗体loading表单中bar元素的当前值
    document.loading.percentage.value=percent+"%"; //设置窗体loading表单中percentage元素的当前值
    if (percent<99){                    //percent小于99则继续循环
        setTimeout("count()",500);        //每500ms进行一次count()
    }
    else{
         window.location = "http://campus.cslg.cn/";    //percent达到100时跳转
    }
}
</script>

JavaScript函数库

/*

-------------- 函数检索 --------------
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) 
-------------- 函数检索 --------------
*/

/**
* 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, "");
}
/********************************** 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(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;
}//~~~
/*--------------------------------- 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;
}//~~~
/*--------------------------------- file --------------------------------------*/

通用数据校验JavaScript脚本（适用于IE）

/*
作者：沈健（常熟理工学院计算机系），jimshen@21cn.com
编写本JavaScript脚本的原因在于为表单验证提供一个便于使用的可重用的代码
本代码的版权归作者所有，你可以在任何场合使用本代码，但必须保留该代码的版权声明
在使用过程中遇到的问题或者任何建议可通过电子邮件反馈给作者
*/

//类型模式，用以正则表达式检查表单内容是否满足要求
var ALPHABETIC=0;        //只能使用英文字母
var ALPHANUM=1;            //只能使用英文字母、数字和下划线
var PASSWORD=2;            //能够使用除'、"以及空白字符以外的其他字符
var EMAIL=3;            //符合Email地址格式（用户名@域名/IP地址）
var NOLIMIT=4;            //无限制，可使用任何字符
var NORETURN=5;            //除换行(\n)之外的任何字符
                        //缺省情况为ALPHABETIC

//错误代号
var EMPTY=0;            //表单元素（文本类）输入为空
var TOO_SHORT=1;        //文本长度太短
var TOO_LONG=2;            //文本长度太长
var ILLEGLE=3;            //文本含有非法字符
var WRONG_EMAIL=4;        //电子邮件地址格式错误
var NO_SELECT=5;        //表单元素（单选、复选按钮等）未选择
var TOO_FEW_SELECT=6;    //复选按钮组或者复选列表框选择的数据项数量太少
var TOO_MANY_SELECT=7;    //复选按钮组或者复选列表框选择的数据项数量太多

//产生警告信息
//formName: 表单元素名称
//errorCode: 错误代号
//number: 可选的数量词，表示文本长度或者选项个数需要符合的条件
function warning(formName,errorCode,number){
    var _msg;
    var errorMsg=new Array(8);
    errorMsg[0]="为空，请填写完整！";
    errorMsg[1]="长度不符合要求！长度不能小于";
    errorMsg[2]="长度不符合要求！长度不能大于";
    errorMsg[3]="包含非法的字符！请参照表单填写说明进行修改！";
    errorMsg[4]="电子邮件地址不正确，请填写正确！";
    errorMsg[5]="没有选择，请选择！";
    errorMsg[6]="选择的项数不能少于";
    errorMsg[7]="选择的项数不能多于";
    if(number==null)
        number="";
    _msg=formName+errorMsg[errorCode]+number;
    window.alert(_msg);
    return false;
}

//验证表单元素内容是否符合要求，如果满足返回true，否则返回false
//formObj: 表单元素
//formName: 表单名称，用于显示在错误信息中，应提供用户能够理解的文字
//contentType: 类型模式，用以正则表达式检查，使用预定义的符号，对于文本类以外的元素无意义，默认为只允许英文字母
//minLen: 可选，文本最小长度，对于单选按钮无意义，对于复选按钮组表示最少选择的数量
//maxLen: 可选，文本最大长度，对于单选按钮无意义，对于复选按钮组表示最多选择的数量
//如果不提供minLen和maxLen则不检查长度或个数

//各种检查格式：
// 文本 validate(form1.formname,"文字描述",ALPHANUM,最小长度,最大长度)
// 密码 validate(form1.formname,"文字描述",PASSWORD,最小长度,最大长度)
// 文本－电子邮件 validate(form1.email,"电子邮件",EMAIL)
// 文本域 validate(form1.formname,"文字描述",NOLIMIT,最小长度,最大长度)
// 单选按钮 validate(form1.formname,"文字描述")
// 单个复选按钮 validate(form1.formname,"文字描述")
// 复选按钮组 validate(form1.formname,"文字描述","",最少个数,最大个数)
// 下拉列表 validate(form1.formname,"文字描述")
// 单选列表框 validate(form1.formname,"文字描述")
// 多选列表框 validate(form1.formname,"文字描述","",最少个数,最大个数)

function validate(formObj,formName,contentType,minLen,maxLen){
    var str;
    var regex;
    var formType=formObj.type;
    if(formType==null)
        formType=formObj[0].type;
    var count;
    if(contentType==null)
        contentType=ALPHABETIC;
    switch(contentType){
        case ALPHABETIC:
            regex=/^[A-Za-z]*$/;
            break;
        case ALPHANUM:
            regex=/^[\w]*$/;
            break;
        case PASSWORD:
            regex=/^[^\'\"\s]*$/;
            break;
        case NOLIMIT:
            regex=/^[\u0000-\uffff]*$/;
            break;
        case NORETURN:
            regex=/^.*$/;
            break;
        case EMAIL:
            str=formObj.value;
            if(str==null || str==""){
                return warning(formName,EMPTY);
            }
            if(!checkEmail(str)){
                return warning(formName,WRONG_EMAIL);
            }else
                return true;
            break;
        default:
            regex=/^[\w]*$/;
            break;
    }
    switch(formType){
        case "text":
        case "password":
        case "textarea":
        case "file":
            str=formObj.value;
            if(str==null || str==""){
                return warning(formName,EMPTY);
            }
            if(minLen!=null && minLen!=""){
                if(str.length<minLen){
                    return warning(formName,TOO_SHORT,minLen);
                }
            }
            if(maxLen!=null && maxLen!=""){
                if(str.length>maxLen){
                    return warning(formName,TOO_LONG,maxLen);
                }
            }
            if(!check(str,regex)){
                return warning(formName,ILLEGLE);
            }
            break;
        case "radio":
        case "checkbox":
            count=readButton(formObj);
            if(count==0){
                return warning(formName,NO_SELECT);
            }
            if(minLen!=null && minLen!=""){
                if(count<minLen){
                    return warning(formName,TOO_FEW_SELECT,minLen);
                }
            }
            if(maxLen!=null && maxLen!=""){
                if(count>maxLen){
                    return warning(formName,TOO_MANY_SELECT,maxLen);
                }
            }
            break;
        case "select-one":
            if(readSingle(formObj)<0){
                return warning(formName,NO_SELECT);
            }
            break;
        case "select-multiple":
            count=readMultiple(formObj);
            if(count==0){
                return warning(formName,NO_SELECT);
            }
            if(minLen!=null && minLen!=""){
                if(count<minLen){
                    return warning(formName,TOO_FEW_SELECT,minLen);
                }
            }
            if(maxLen!=null && maxLen!=""){
                if(count>maxLen){
                    return warning(formName,TOO_MANY_SELECT,maxLen);
                }
            }
            break;
    }
    return true;
}

//读取单选按钮、复选按钮、复选按钮组的数据，返回选中的选项的个数
//如果返回为0，表示未选择
function readButton(formObj){
    var count=0;
    var len=formObj.length;
    if(len!=null){
        for(i=0;i<formObj.length;i++){
            if(formObj[i].checked)
                count++;
        }
    }else if(formObj.checked)
        count=1;
    return count;
}

//返回下拉列表、单选列表中被选中数据的编号
//如果返回为-1，表示未选择
function readSingle(formObj){
    return formObj.selectedIndex;
}

//返回多选列表中被选中数据项的个数
//如果返回为0，表示未选择
function readMultiple(formObj){
    var len=formObj.length;
    var count=0;
    for(i=0;i<len;i++){
        if(formObj.options[i].selected){
            count++;
        }
    }
    return count;
}

//检查字符串是否匹配规定的正则表达式
function check(str,regex){
    var splitted=str.match(regex);
    if(splitted==null)
        return false;
    else
        return true;
}

//检查Email地址格式是否正确
function checkEmail(email){
    var splitted = email.match("^(.+)@(.+)$");
    if(splitted == null) return false;
    if(splitted[1] != null )
    {
      var regexp_user=/^\"?[\w-_\.]*\"?$/;
      if(splitted[1].match(regexp_user) == null) return false;
    }
    if(splitted[2] != null)
    {
      var regexp_domain=/^[\w-\.]*\.[A-Za-z]{2,4}$/;
      if(splitted[2].match(regexp_domain) == null)
      {
        var regexp_ip =/^\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\]$/;
        if(splitted[2].match(regexp_ip) == null) return false;
      }// if
      return true;
   }
}

身份证检验Javascript脚本

/*ckBodyId(sId) start
*入口参数：sId:身份证号码字符串。
*返 回 值：false:失败，身份证号码错误。
*          true:成功，身份证号码正确。
*作    用：判断身份证号码是否符合规则。
*/
function ckBodyId(sId)
   {var iSum=0;
    var info="";
    var aCity={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:"国外"};
    if(sId.length==15)
      {if(!/^\d{15}$/i.test(sID))
         {alert("非法证号！");
          return false;
         }
       sBirthday=sId.substr(6,2)+"-"+Number(sId.substr(8,2))+"-"+Number(sId.substr(10,2));
      }
    else
      {if(!/^\d{17}(\d|x)$/i.test(sId))
         {alert("非法证号！");
          return false;
         }
       sId=sId.replace(/x$/i,"a");
       sBirthday=sId.substr(6,4)+"-"+Number(sId.substr(10,2))+"-"+Number(sId.substr(12,2));
       for(var i = 17;i>=0;i --)
         iSum += (Math.pow(2,i) % 11) * parseInt(sId.charAt(17 - i),11);
       if(iSum%11!=1)
         {alert("非法证号！");
          return false;
         }
      }
    if(aCity[parseInt(sId.substr(0,2))]==null)
      {alert("非法地区！");
       return false;
      }
    var d=new Date(sBirthday.replace(/-/g,"/"))
    if(sBirthday!=(d.getFullYear()+"-"+ (d.getMonth()+1) + "-" + d.getDate()))
      {alert("非法生日！");
       return false;
      }
    return true
   }
//ckBodyId(sId) end