正则表达式-汇总

 正则表达式使用详解
--------------------------------------------------------------------------------
 
作者:吕晓波  
  
    如果我们问那些UNIX系统的爱好者他们最喜欢什么，答案除了稳定的系统和可以远程启动之外，十有八九的人会提到正则表达式；如果我们再问他们最头痛的是什么，可能除了复杂的进程控制和安装过程之外，还会是正则表达式。那么正则表达式到底是什么？如何才能真正的掌握正则表达式并正确的加以灵活运用？本文将就此展开介绍，希望能够对那些渴望了解和掌握正则表达式的读者有所助益。 

入门简介 

　　简单的说，正则表达式是一种可以用于模式匹配和替换的强有力的工具。我们可以在几乎所有的基于UNIX系统的工具中找到正则表达式的身影，例如，vi编辑器，Perl或PHP脚本语言，以及awk或sed shell程序等。此外，象JavaScript这种客户端的脚本语言也提供了对正则表达式的支持。由此可见，正则表达式已经超出了某种语言或某个系统的局限，成为人们广为接受的概念和功能。 
　　正则表达式可以让用户通过使用一系列的特殊字符构建匹配模式，然后把匹配模式与数据文件、程序输入以及WEB页面的表单输入等目标对象进行比较，根据比较对象中是否包含匹配模式，执行相应的程序。 
　　举例来说，正则表达式的一个最为普遍的应用就是用于验证用户在线输入的邮件地址的格式是否正确。如果通过正则表达式验证用户邮件地址的格式正确，用户所填写的表单信息将会被正常处理；反之，如果用户输入的邮件地址与正则表达的模式不匹配，将会弹出提示信息，要求用户重新输入正确的邮件地址。由此可见正则表达式在WEB应用的逻辑判断中具有举足轻重的作用。

基本语法 

　　在对正则表达式的功能和作用有了初步的了解之后，我们就来具体看一下正则表达式的语法格式。 
　　正则表达式的形式一般如下： 
　　/love/ 
　　其中位于“/”定界符之间的部分就是将要在目标对象中进行匹配的模式。用户只要把希望查找匹配对象的模式内容放入“/”定界符之间即可。为了能够使用户更加灵活的定制模式内容，正则表达式提供了专门的“元字符”。所谓元字符就是指那些在正则表达式中具有特殊意义的专用字符，可以用来规定其前导字符（即位于元字符前面的字符）在目标对象中的出现模式。 
　　较为常用的元字符包括： “+”， “*”，以及 “?”。其中，“+”元字符规定其前导字符必须在目标对象中连续出现一次或多次，“*”元字符规定其前导字符必须在目标对象中出现零次或连续多次，而“?”元字符规定其前导对象必须在目标对象中连续出现零次或一次。 
　　下面，就让我们来看一下正则表达式元字符的具体应用。 
　　/fo+/ 
　　因为上述正则表达式中包含“+”元字符，表示可以与目标对象中的 “fool”, “fo”, 或者 “football”等在字母f后面连续出现一个或多个字母o的字符串相匹配。 
　　/eg*/ 
　　因为上述正则表达式中包含“*”元字符，表示可以与目标对象中的 “easy”, “ego”, 或者 “egg”等在字母e后面连续出现零个或多个字母g的字符串相匹配。 
　　/Wil?/ 
　　因为上述正则表达式中包含“？”元字符，表示可以与目标对象中的 “Win”, 或者 “Wilson”,等在字母i后面连续出现零个或一个字母l的字符串相匹配。 
　　除了元字符之外，用户还可以精确指定模式在匹配对象中出现的频率。例如， 
　　/jim{2,6}/ 
　　上述正则表达式规定字符m可以在匹配对象中连续出现2-6次，因此，上述正则表达式可以同jimmy或jimmmmmy等字符串相匹配。 
　　在对如何使用正则表达式有了初步了解之后，我们来看一下其它几个重要的元字符的使用方式。 
　　/s：用于匹配单个空格符，包括tab键和换行符； 
　　/S：用于匹配除单个空格符之外的所有字符； 
　　/d：用于匹配从0到9的数字； 
　　/w：用于匹配字母，数字或下划线字符； 
　　/W：用于匹配所有与/w不匹配的字符； 
　　. ：用于匹配除换行符之外的所有字符。 
　　（说明：我们可以把/s和/S以及/w和/W看作互为逆运算） 
　　下面，我们就通过实例看一下如何在正则表达式中使用上述元字符。 
　　//s+/ 
　　上述正则表达式可以用于匹配目标对象中的一个或多个空格字符。 
　　//d000/ 
　　如果我们手中有一份复杂的财务报表，那么我们可以通过上述正则表达式轻而易举的查找到所有总额达千元的款项。 
　　除了我们以上所介绍的元字符之外，正则表达式中还具有另外一种较为独特的专用字符，即定位符。定位符用于规定匹配模式在目标对象中的出现位置。 
　　较为常用的定位符包括： “^”, “$”, “/b” 以及 “/B”。其中，“^”定位符规定匹配模式必须出现在目标字符串的开头，“$”定位符规定匹配模式必须出现在目标对象的结尾，/b定位符规定匹配模式必须出现在目标字符串的开头或结尾的两个边界之一，而“/B”定位符则规定匹配对象必须位于目标字符串的开头和结尾两个边界之内，即匹配对象既不能作为目标字符串的开头，也不能作为目标字符串的结尾。同样，我们也可以把“^”和“$”以及“/b”和“/B”看作是互为逆运算的两组定位符。举例来说： 
　　/^hell/ 
　　因为上述正则表达式中包含“^”定位符，所以可以与目标对象中以 “hell”, “hello”或 “hellhound”开头的字符串相匹配。 
　　/ar$/ 
　　因为上述正则表达式中包含“$”定位符，所以可以与目标对象中以 “car”, “bar”或 “ar” 结尾的字符串相匹配。 
　　//bbom/ 
　　因为上述正则表达式模式以“/b”定位符开头，所以可以与目标对象中以 “bomb”, 或 “bom”开头的字符串相匹配。 
　　/man/b/ 
　　因为上述正则表达式模式以“/b”定位符结尾，所以可以与目标对象中以 “human”, “woman”或 “man”结尾的字符串相匹配。 
　　为了能够方便用户更加灵活的设定匹配模式，正则表达式允许使用者在匹配模式中指定某一个范围而不局限于具体的字符。例如： 
　　/[A-Z]/ 
　　上述正则表达式将会与从A到Z范围内任何一个大写字母相匹配。 
　　/[a-z]/ 
　　上述正则表达式将会与从a到z范围内任何一个小写字母相匹配。 
　　/[0-9]/ 
　　上述正则表达式将会与从0到9范围内任何一个数字相匹配。 
　　/([a-z][A-Z][0-9])+/ 
　　上述正则表达式将会与任何由字母和数字组成的字符串，如 “aB0” 等相匹配。这里需要提醒用户注意的一点就是可以在正则表达式中使用 “()” 把字符串组合在一起。“()”符号包含的内容必须同时出现在目标对象中。因此，上述正则表达式将无法与诸如 “abc”等的字符串匹配，因为“abc”中的最后一个字符为字母而非数字。 
　　如果我们希望在正则表达式中实现类似编程逻辑中的“或”运算，在多个不同的模式中任选一个进行匹配的话，可以使用管道符 “|”。例如： 
　　/to|too|2/ 
　　上述正则表达式将会与目标对象中的 “to”, “too”, 或 “2” 相匹配。 
　　正则表达式中还有一个较为常用的运算符，即否定符 “[^]”。与我们前文所介绍的定位符 “^” 不同，否定符 “[^]”规定目标对象中不能存在模式中所规定的字符串。例如： 
　　/[^A-C]/ 
　　上述字符串将会与目标对象中除A，B，和C之外的任何字符相匹配。一般来说，当“^”出现在 “[]”内时就被视做否定运算符；而当“^”位于“[]”之外，或没有“[]”时，则应当被视做定位符。 
　　最后，当用户需要在正则表达式的模式中加入元字符，并查找其匹配对象时，可以使用转义符“/”。例如： 
　　/Th/*/ 
　　上述正则表达式将会与目标对象中的“Th*”而非“The”等相匹配。

使用实例 

　　在对正则表达式有了较为全面的了解之后，我们就来看一下如何在Perl，PHP，以及JavaScript中使用正则表达式。 

　　通常，Perl中正则表达式的使用格式如下： 

　　operator / regular-expression / string-to-replace / modifiers 

　　运算符一项可以是m或s，分别代表匹配运算和替换运算。 

　　其中，正则表达式一项是将要进行匹配或替换操作的模式，可以由任意字符，元字符，或定位符等组成。替换字符串一项是使用s运算符时，对查找到的模式匹配对象进行替换的字符串。最后的参数项用来控制不同的匹配或替换方式。例如： 

　　s/geed/good/ 

　　将会在目标对象中查找第一个出现的geed字串，并将其替换为good。如果我们希望在目标对象的全局范围内执行多次查找—替换操作的话，可以使用参数 “g”，即s/love/lust/g。 

　　此外，如果我们不需要限制匹配的大小写形式的话，可以使用参数 “i ”。例如， 

　　m/JewEL/i 

　　上述正则表达式将会与目标对象中的jewel，Jewel，或JEWEL相匹配。 

　　在Perl中，使用专门的运算符“=~”指定正则表达式的匹配对象。例如： 

　　$flag =~ s/abc/ABC/ 

　　上述正则表达式将会把变量$flag中的字串abc替换为ABC。 

　　下面，我们就在Perl程序中加入正则表达式，验证用户邮件地址格式的有效性。代码如下： 

　　#!/usr/bin/perl 
　　# get input 
　　print “What/'s your email address?/n”; 
　　$email = <STDIN> 
　　chomp($email); 
　　# match and display result 
　　if($email =~ /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(/.[a-zA-Z0-9_-])+/) 
　　{ 
　　print(“Your email address is correct!/n”); 
　　} 
　　else 
　　　{ 
　　　　print(“Please try again!/n”); 
　　　} 

　　如果用户更偏爱PHP的话，可以使用ereg()函数进行模式匹配操作。ereg()函数的使用格式如下： 
　　 ereg(pattern, string) 

　　其中，pattern代表正则表达式的模式，而string则是执行查找替换操作的目标对象。同样是验证邮件地址，使用PHP编写的程序代码如下： 

　　<?php 
　　 if (ereg(“^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(/.[a-zA-Z0-9_-])+”,$email)) 
　　　 { echo “Your email address is correct!”;} 
　　 else 
　　　 { echo “Please try again!”;} 
　　 ?> 
　　最后，我们在来看一下JavaScript。JavaScript 1.2中带有一个功能强大的RegExp()对象，可以用来进行正则表达式的匹配操作。其中的test()方法可以检验目标对象中是否包含匹配模式，并相应的返回true或false。 

　　我们可以使用JavaScript编写以下脚本，验证用户输入的邮件地址的有效性。 

　　 
　　  
　　　 <script language=/"Javascript1.2/"> 
　　　　 <!-- start hiding 
　　　　 function verifyAddress(obj) 
　　　　　{ 
　　　　　　var email = obj.email.value; 
　　　　　　var pattern = /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(/.[a-zA-Z0-9_-])+/; 
　　　　　　flag = pattern.test(email); 
　　　　　　if(flag) 
　　　　　　{ 
　　　　　　　alert(“Your email address is correct!”); 
　　　　　　　return true; 
　　　　　　} 
　　　　　　else 
　　　　　　　{ 
　　　　　　　　alert(“Please try again!”); 
　　　　　　　　return false; 
　　　　　　　 } 
　　　　　 } 
　　　　 // stop hiding --> 
　　　  
　　　 
　　  
　　 <form onSubmit=/"return verifyAddress(this);/"> 
　　　<input name=/"email/" type=/"text/"> 
　　　<input type=/"submit/"> 
　　　</form> 

 

 

×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

 

匹配中文字符的正则表达式： [/u4e00-/u9fa5]

匹配双字节字符(包括汉字在内)：[^/x00-/xff]

应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

String.prototype.len=function(){return this.replace([^/x00-/xff]/g,"aa").length;}

匹配空行的正则表达式：/n[/s| ]*/r

匹配HTML标记的正则表达式：/<(.*)>.*<///1>|<(.*) //>/

匹配首尾空格的正则表达式：(^/s*)|(/s*$)

应用：javascript中没有像vbscript那样的trim函数，我们就可以利用这个表达式来实现，如下：

应用：javascript中没有像vbscript那样的trim函数，我们就可以利用这个表达式来实现，如下：

String.prototype.trim = function()
{
    return this.replace(/(^/s*)|(/s*$)/g, "");
}

利用正则表达式分解和转换IP地址：

下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascript程序：

function IP2V(ip)
{
 re=/(/d+)/.(/d+)/.(/d+)/.(/d+)/g  //匹配IP地址的正则表达式
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
 throw new Error("Not a valid IP address!")
}
}

不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：

var ip="10.100.20.168"
ip=ip.split(".")
alert("IP值是："+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))

匹配Email地址的正则表达式：/w+([-+.]/w+)*@/w+([-.]/w+)*/./w+([-.]/w+)*

匹配网址URL的正则表达式：http://([/w-]+/.)+[/w-]+(/[/w- ./?%&=]*)?

利用正则表达式去除字串中重复的字符的算法程序：[注：此程序不正确，原因见本贴回复]

var s="abacabefgeeii"
var s1=s.replace(/(.).*/1/g,"$1")
var re=new RegExp("["+s1+"]","g")
var s2=s.replace(re,"") 
alert(s1+s2)  //结果为：abcefgi

我原来在CSDN上发贴寻求一个表达式来实现去除重复字符的方法，最终没有找到，这是我能想到的最简单的实现方法。思路是使用后向引用取出包括重复的字符，再以重复的字符建立第二个表达式，取到不重复的字符，两者串连。这个方法对于字符顺序有要求的字符串可能不适用。

得用正则表达式从URL地址中提取文件名的javascript程序，如下结果为page1

s="http://www.9499.net/page1.htm"
s=s.replace(/(.*//){0,}([^/.]+).*/ig,"$2")
alert(s)

利用正则表达式限制网页表单里的文本框输入内容：

用正则表达式限制只能输入中文：οnkeyup="value=value.replace(/[^/u4E00-/u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^/u4E00-/u9FA5]/g,''))"

用正则表达式限制只能输入全角字符： οnkeyup="value=value.replace(/[^/uFF00-/uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^/uFF00-/uFFFF]/g,''))"

用正则表达式限制只能输入数字：οnkeyup="value=value.replace(/[^/d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^/d]/g,''))"

用正则表达式限制只能输入数字和英文：οnkeyup="value=value.replace(/[/W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^/d]/g,''))"

 

正则表达式，相关链接 
http://blog.csdn.net/laily/category/19548.aspx 
http://blog.csdn.net/laily/archive/2004/06/30/30525.aspx 微软的正则表达式教程（五）：选择/编组和后向引用 

http://blog.csdn.net/laily/archive/2004/06/30/30522.aspx 微软的正则表达式教程（四）：限定符和定位符 

http://blog.csdn.net/laily/archive/2004/06/30/30517.aspx 微软的正则表达式教程（三）：字符匹配 

http://blog.csdn.net/laily/archive/2004/06/30/30514.aspx 微软的正则表达式教程（二）：正则表达式语法和优先权顺序 

http://blog.csdn.net/laily/archive/2004/06/30/30511.aspx 微软的正则表达式教程（一）：正则表达式简介 

http://blog.csdn.net/laily/archive/2004/06/30/30360.aspx 小程序大作为：高级查找/替换、正则表达式练习器、Javascript脚本程序调试器 

http://blog.csdn.net/laily/archive/2004/06/24/25872.aspx 经典正则表达式 

正则表达式，正规表达式，正则表达式匹配，正则表达式语法，模式匹配，正规表达式匹配 javascript正则表达式 ASP正则表达式 ASP.NET正则表达式 C#正则表达式 JSP正则表达式 PHP正则表达式 VB.NET正则表达式 VBSCript正则表达式编程 delphi正则表达式 jscript

 

正则表达式 regular expression 
正则表达式 RegExp 
模式 pattern 
匹配 Match 
.NET命名空间： System.Text.RegularExpression 

 

补充： 
^/d+$　　//匹配非负整数（正整数 + 0） 
^[0-9]*[1-9][0-9]*$　　//匹配正整数 
^((-/d+)|(0+))$　　//匹配非正整数（负整数 + 0） 
^-[0-9]*[1-9][0-9]*$　　//匹配负整数 
^-?/d+$　　　　//匹配整数 
^/d+(/./d+)?$　　//匹配非负浮点数（正浮点数 + 0） 
^(([0-9]+/.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*/.[0-9]+)|([0-9]*[1-9][0-9]*))$　　//匹配正浮点数 
^((-/d+(/./d+)?)|(0+(/.0+)?))$　　//匹配非正浮点数（负浮点数 + 0） 
^(-(([0-9]+/.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*/.[0-9]+)|([0-9]*[1-9][0-9]*)))$　　//匹配负浮点数 
^(-?/d+)(/./d+)?$　　//匹配浮点数 
^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串 
^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串 
^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串 
^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串 
^/w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串 
^[/w-]+(/.[/w-]+)*@[/w-]+(/.[/w-]+)+$　　　　//匹配email地址 
^[a-zA-z]+://匹配(/w+(-/w+)*)(/.(/w+(-/w+)*))*(/?/S*)?$　　//匹配url

 

利用正则表达式去除字串中重复的字符的算法程序： 

var s="abacabefgeeii" 
var s1=s.replace(/(.).*/1/g,"$1") 
var re=new RegExp("["+s1+"]","g") 
var s2=s.replace(re,"") 
alert(s1+s2) //结果为：abcefgi 
=============================== 
如果var s = "abacabefggeeii" 
结果就不对了，结果为：abeicfgg 
正则表达式的能力有限

 

1.确认有效电子邮件格式 
下面的代码示例使用静态 Regex.IsMatch 方法验证一个字符串是否为有效电子邮件格式。如果字符串包含一个有效的电子邮件地址，则 IsValidEmail 方法返回 true，否则返回 false，但不采取其他任何操作。您可以使用 IsValidEmail，在应用程序将地址存储在数据库中或显示在 ASP.NET 页中之前，筛选出包含无效字符的电子邮件地址。 

[Visual Basic] 
Function IsValidEmail(strIn As String) As Boolean 
' Return true if strIn is in valid e-mail format. 
Return Regex.IsMatch(strIn, ("^([/w-/.]+)@((/[[0-9]{1,3}/.[0-9]{1,3}/.[0-9]{1,3}/.)|(([/w-]+/.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(/]?)$") 
End Function 
[C#] 
bool IsValidEmail(string strIn) 
{ 
// Return true if strIn is in valid e-mail format. 
return Regex.IsMatch(strIn, @"^([/w-/.]+)@((/[[0-9]{1,3}/.[0-9]{1,3}/.[0-9]{1,3}/.)|(([/w-]+/.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(/]?)$"); 
} 


2.清理输入字符串 
下面的代码示例使用静态 Regex.Replace 方法从字符串中抽出无效字符。您可以使用这里定义的 CleanInput 方法，清除掉在接受用户输入的窗体的文本字段中输入的可能有害的字符。CleanInput 在清除掉除 @、-（连字符）和 .（句点）以外的所有非字母数字字符后返回一个字符串。 

[Visual Basic] 
Function CleanInput(strIn As String) As String 
' Replace invalid characters with empty strings. 
Return Regex.Replace(strIn, "[^/w/.@-]", "") 
End Function 
[C#] 
String CleanInput(string strIn) 
{ 
// Replace invalid characters with empty strings. 
return Regex.Replace(strIn, @"[^/w/.@-]", ""); 
} 


3.更改日期格式 
以下代码示例使用 Regex.Replace 方法来用 dd-mm-yy 的日期形式代替 mm/dd/yy 的日期形式。 

[Visual Basic] 
Function MDYToDMY(input As String) As String 
Return Regex.Replace(input, _ 
"/b(?<month>/d{1,2})/(?<day>/d{1,2})/(?<year>/d{2,4})/b", _ 
"${day}-${month}-${year}") 
End Function 
[C#] 
String MDYToDMY(String input) 
{ 
return Regex.Replace(input, 
"//b(?<month>//d{1,2})/(?<day>//d{1,2})/(?<year>//d{2,4})//b", 
"${day}-${month}-${year}"); 
} 
Regex 替换模式 
本示例说明如何在 Regex.Replace 的替换模式中使用命名的反向引用。其中，替换表达式 ${day} 插入由 (?<day>...) 组捕获的子字符串。 

有几种静态函数使您可以在使用正则表达式操作时无需创建显式正则表达式对象，而 Regex.Replace 函数正是其中之一。如果您不想保留编译的正则表达式，这将给您带来方便 


4.提取 URL 信息 
以下代码示例使用 Match.Result 来从 URL 提取协议和端口号。例如，“http://www.contoso.com:8080/letters/readme.html”将返回“http:8080”。 

[Visual Basic] 
Function Extension(url As String) As String 
Dim r As New Regex("^(?<proto>/w+)://[^/]+?(?<port>:/d+)?/", _ 
RegexOptions.Compiled) 
Return r.Match(url).Result("${proto}${port}") 
End Function 
[C#] 
String Extension(String url) 
{ 
Regex r = new Regex(@"^(?<proto>/w+)://[^/]+?(?<port>:/d+)?/", 
RegexOptions.Compiled); 
return r.Match(url).Result("${proto}${port}"); 
}

 

　　一、正则表达式基础知识
　　我们先从简单的开始。假设你要搜索一个包含字符“cat”的字符串，搜索用的正则表达式就是“cat”。如果搜索对大小写不敏感，单词“catalog”、“Catherine”、“sophisticated”都可以匹配。也就是说：

　　 1.1句点符号
　　假设你在玩英文拼字游戏，想要找出三个字母的单词，而且这些单词必须以“t”字母开头，以“n”字母结束。另外，假设有一本英文字典，你可以用正则表达式搜索它的全部内容。要构造出这个正则表达式，你可以使用一个通配符??句点符号“.”。这样，完整的表达式就是“t.n”，它匹配“tan”、“ten”、“tin”和“ton”，还匹配“t#n”、“tpn”甚至“tn”，还有其他许多无意义的组合。这是因为句点符号匹配所有字符，包括空格、Tab字符甚至换行符：

　　 1.2方括号符号
　　为了解决句点符号匹配范围过于广泛这一问题，你可以在方括号（“[]”）里面指定看来有意义的字符。此时，只有方括号里面指定的字符才参与匹配。也就是说，正则表达式“t[aeio]n”只匹配“tan”、“Ten”、“tin”和“ton”。但“Toon”不匹配，因为在方括号之内你只能匹配单个字符：

　　 1.4表示匹配次数的符号
　　表一显示了表示匹配次数的符号，这些符号用来确定紧靠该符号左边的符号出现的次数：

　　假设我们要在文本文件中搜索美国的社会安全号码。这个号码的格式是999-99-9999。用来匹配它的正则表达式如图一所示。在正则表达式中，连字符（“-”）有着特殊的意义，它表示一个范围，比如从0到9。因此，匹配社会安全号码中的连字符号时，它的前面要加上一个转义字符“/”。

　　图一：匹配所有123-12-1234形式的社会安全号码
　　假设进行搜索的时候，你希望连字符号可以出现，也可以不出现??即，999-99-9999和999999999都属于正确的格式。这时，你可以在连字符号后面加上“？”数量限定符号，如图二所示：

　　图二：匹配所有123-12-1234和123121234形式的社会安全号码
　　下面我们再来看另外一个例子。美国汽车牌照的一种格式是四个数字加上二个字母。它的正则表达式前面是数字部分“[0-9]{ 4}”，再加上字母部分“[A-Z]{ 2}”。图三显示了完整的正则表达式。

　　图三：匹配典型的美国汽车牌照号码，如8836KV
　　1.5“否”符号
　　“^”符号称为“否”符号。如果用在方括号内，“^”表示不想要匹配的字符。例如，图四的正则表达式匹配所有单词，但以“X”字母开头的单词除外。

　　图四：匹配所有单词，但“X”开头的除外
　　1.6圆括号和空白符号
　　假设要从格式为“June26,1951”的生日日期中提取出月份部分，用来匹配该日期的正则表达式可以如图五所示：

　　图五：匹配所有MothDD,YYYY格式的日期
　　新出现的“/s”符号是空白符号，匹配所有的空白字符，包括Tab字符。如果字符串正确匹配，接下来如何提取出月份部分呢？只需在月份周围加上一个圆括号创建一个组，然后用OROAPI（本文后面详细讨论）提取出它的值。修改后的正则表达式如图六所示：

　　图六：匹配所有MonthDD,YYYY格式的日期，定义月份值为第一个组
　　 1.7其它符号
　　为简便起见，你可以使用一些为常见正则表达式创建的快捷符号。如表二所示：
　　表二：常用符号

　　例如，在前面社会安全号码的例子中，所有出现“[0-9]”的地方我们都可以使用“/d”。修改后的正则表达式如图七所示：

/*------------------------ 
功能：替换任何空白字符 
-------------------------*/ 
function TrimString (strVal) 
{ 
strTmp = strVal + ""; 
if (strTmp.length == 0) 
return (strTmp); 
reVal = /^/s*/; 
strTmp = strTmp.replace (reVal, ''); 
reVal = //s*$/; 
return (strTmp.replace (reVal, '')); 
} 

/*------------------------ 
功能：检测是否是有效数字 
-------------------------*/ 
function Check_Num( num ) 
{ 
num = ( TrimString( num ) ); 
if (num.length == 0) 
return (false); 
return ( Number( num ) ); 
} 

/*------------------------ 
功能：检测是否是有效日期 
-------------------------*/ 
function Check_Date (strDate) 
{ 
strDate = (TrimString (strDate)); 
if (strDate.length == 0) 
return (false); 
reVal = /^([1-2]/d{3})[//|/-](0?[1-9]|10|11|12)[//|/-]([1-2]?[0-9]|0[1-9]|30|31)$/; 
return (reVal.test (strDate)); 
} 

/*------------------------ 
功能：检测是否是有效Email 
-------------------------*/ 
function Check_Email (strEmail) 
{ 
strEmail = (TrimString (strEmail)); 
if (strEmail.length == 0) 
return (false); 

reVal = /^[/-!#/$%&'/*/+///.//0-9=/?A-Z/^_`a-z{|}~]+@[/-!#/$%&'/*/+///.//0-9=/?A-Z/^_`a-z{|}~]+(/.[/-!#/$%&'/*/+///.//0-9=/?A-Z/^_`a-z{|}~]+)+$/; 
return (reVal.test (strEmail)); 
} 

/*------------------------ 
功能：检测是否是有效时间 
-------------------------*/ 
function Check_Time (strTime) 
{ 
strTime = (TrimString (strTime)); 
if (strTime.length == 0) 
return (false); 

reVal = /^(([0-9]|[01][0-9]|2[0-3])(:([0-9]|[0-5][0-9])){0,2}|(0?[0-9]|1[0-1])(:([0-9]|[0-5][0-9])){0,2}/s?[aApP][mM])?$/; 
return (reVal.test (strTime)); 
} 

/*------------------------ 
功能：检测是否是有效日期特定格式 
-------------------------*/ 
function Check_Date_1 (strDate) 
{ 
strDate = (TrimString (strDate)); 
if (strDate.length == 0) 
return (false); 
reVal = /^([1-2]/d{3})[//](0?[1-9]|10|11|12)[//]([1-2]?[0-9]|0[1-9]|30|31)$/; 
return (reVal.test (strDate)); 
} 

/*------------------------ 
功能：检测是否是有效日期特定格式 
-------------------------*/ 
function Check_Date_2 (strDate) 
{ 
strDate = (TrimString (strDate)); 
if (strDate.length == 0) 
return (false); 
reVal = /^([1-2]/d{3})[/-](0[1-9]|10|11|12)[/-]([1-2][0-9]|0[1-9]|30|31)$/; 
return (reVal.test (strDate)); 
} 

/*-------------------------------------- 
功能：换行定行 
---------------------------------------*/ 
function enter( form, temp ) 
{ 
if ( window.event.keyCode == 13 ) 
{ 
eval( form + temp + ".focus()" ); 
eval( form + temp + ".select()" ); 
} 
else 
return (false); 
} 

/*-------------------------------------- 
功能：检查字符串长度 
---------------------------------------*/ 
function ByteString (strVal) 
{ 
nLen = 0; 

for (i = 0; i < strVal.length; i ++) 
{ 
if (strVal.charCodeAt (i) > 255) 
nLen += 2; 
else 
nLen ++; 
}; 
return (nLen); 
} 

/*-------------------------------------- 
功能：按要求截取字符串长度 
---------------------------------------*/ 
function SubString(strVal,nStrLen) 
{ 
nLen = 0; 
nTemp = 0; 
for (i = 0; i < strVal.length; i ++) 
{ 
if (strVal.charCodeAt (i) > 255) 
nLen += 2; 
else 
nLen ++; 
if(nLen <= nStrLen) 
nTemp = i; 
else 
break; 
}; 
return(strVal.substr(0,nTemp+1)); 
} 

/*------------------------ 
功能：检测密码，密码只能由英文字母、数字、减号、下划线、$、#、*、(和)构成，且首位必须是英文字母 
-------------------------*/ 
function Check_Pass( strPass ) 
{ 
strPass = ( TrimString( strPass ) ); 
if (strPass.length == 0) 
return (false); 
reVal = /^[a-zA-Z]{1}[a-zA-Z0-9-_$#*()]{0,29}$/; 
return ( reVal.test (strPass) ); 
} 

这是所有的,不过是PHP的,你自己转换一下吧~~ 

# re: 正则表达式 2005-02-28 00:59 yongsheng

^(((19)|(20))/d{2})(((((-|/)0?)|0)[1-9])|((-|/)?1[0-2]))((((((-|/)0?)|0)[1-9])|((-|/)?[1-2][0-9]))|((-|/)?3[0-1]))$ 


2004-1-1格式

# re: 正则表达式 2005-03-07 14:33 yongsheng

一、验证类 
1、数字验证内 
1.1 整数 
1.2 大于0的整数 （用于传来的ID的验证) 
1.3 负整数的验证 
1.4 整数不能大于iMax 
1.5 整数不能小于iMin 
2、时间类 
2.1 短时间，形如 (13:04:06) 
2.2 短日期，形如 (2003-12-05) 
2.3 长时间，形如 (2003-12-05 13:04:06) 
2.4 只有年和月。形如(2003-05,或者2003-5) 
2.5 只有小时和分钟,形如(12:03) 
3、表单类 
3.1 所有的表单的值都不能为空 
3.2 多行文本框的值不能为空。 
3.3 多行文本框的值不能超过sMaxStrleng 
3.4 多行文本框的值不能少于sMixStrleng 
3.5 判断单选框是否选择。 
3.6 判断复选框是否选择. 
3.7 复选框的全选，多选，全不选，反选 
3.8 文件上传过程中判断文件类型 
4、字符类 
4.1 判断字符全部由a-Z或者是A-Z的字字母组成 
4.2 判断字符由字母和数字组成。 
4.3 判断字符由字母和数字，下划线,点号组成.且开头的只能是下划线和字母 
4.4 字符串替换函数.Replace(); 
5、浏览器类 
5.1 判断浏览器的类型 
5.2 判断ie的版本 
5.3 判断客户端的分辨率 

6、结合类 
6.1 email的判断。 
6.2 手机号码的验证 
6.3 身份证的验证 


二、功能类 

1、时间与相关控件类 
1.1 日历 
1.2 时间控件 
1.3 万年历 
1.4 显示动态显示时钟效果（文本，如OA中时间） 
1.5 显示动态显示时钟效果 (图像，像手表) 
2、表单类 
2.1 自动生成表单 
2.2 动态添加，修改，删除下拉框中的元素 
2.3 可以输入内容的下拉框 
2.4 多行文本框中只能输入iMax文字。如果多输入了，自动减少到iMax个文字（多用于短信发送) 

3、打印类 
3.1 打印控件 
4、事件类 
4.1 屏蔽右键 
4.2 屏蔽所有功能键 
4.3 --> 和<-- F5 F11,F9,F1 
4.4 屏蔽组合键ctrl+N 
5、网页设计类 
5.1 连续滚动的文字，图片（注意是连续的，两段文字和图片中没有空白出现） 
5.2 html编辑控件类 
5.3 颜色选取框控件 
5.4 下拉菜单 
5.5 两层或多层次的下拉菜单 
5.6 仿IE菜单的按钮。（效果如rongshuxa.com的导航栏目) 
5.7 状态栏，title栏的动态效果（例子很多，可以研究一下） 
5.8 双击后，网页自动滚屏 
6、树型结构。 
6.1 asp+SQL版 
6.2 asp+xml+sql版 
6.3 java+sql或者java+sql+xml 
7、无边框效果的制作 
8、连动下拉框技术 
9、文本排序 


一、验证类 
1、数字验证内 
1.1 整数 
/^(-|/+)?/d+$/.test(str) 
1.2 大于0的整数 （用于传来的ID的验证) 
/^/d+$/.test(str) 
1.3 负整数的验证 
/^-/d+$/.test(str) 
2、时间类 
2.1 短时间，形如 (13:04:06) 
function isTime(str) 
{ 
var a = str.match(/^(/d{1,2})(:)?(/d{1,2})/2(/d{1,2})$/); 
if (a == null) {alert('输入的参数不是时间格式'); return false;} 
if (a[1]>24 || a[3]>60 || a[4]>60) 
{ 
alert("时间格式不对"); 
return false 
} 
return true; 
} 
2.2 短日期，形如 (2003-12-05) 
function strDateTime(str) 
{ 
var r = str.match(/^(/d{1,4})(-|//)(/d{1,2})/2(/d{1,2})$/); 
if(r==null)return false; 
var d= new Date(r[1], r[3]-1, r[4]); 
return (d.getFullYear()==r[1]&&(d.getMonth()+1)==r[3]&&d.getDate()==r[4]); 
} 
2.3 长时间，形如 (2003-12-05 13:04:06) 
function strDateTime(str) 
{ 
var reg = /^(/d{1,4})(-|//)(/d{1,2})/2(/d{1,2}) (/d{1,2}):(/d{1,2}):(/d{1,2})$/; 
var r = str.match(reg); 
if(r==null)return false; 
var d= new Date(r[1], r[3]-1,r[4],r[5],r[6],r[7]); 
return (d.getFullYear()==r[1]&&(d.getMonth()+1)==r[3]&&d.getDate()==r[4]&&d.getHours()==r[5]&&d.getMinutes()==r[6]&&d.getSeconds()==r[7]); 
} 
2.4 只有年和月。形如(2003-05,或者2003-5) 
2.5 只有小时和分钟,形如(12:03) 
3、表单类 
3.1 所有的表单的值都不能为空 
<input οnblur="if(this.value.replace(/^/s+|/s+$/g,'')=='')alert('不能为空!')"> 
3.2 多行文本框的值不能为空。 
3.3 多行文本框的值不能超过sMaxStrleng 
3.4 多行文本框的值不能少于sMixStrleng 
3.5 判断单选框是否选择。 
3.6 判断复选框是否选择. 
3.7 复选框的全选，多选，全不选，反选 
3.8 文件上传过程中判断文件类型 
4、字符类 
4.1 判断字符全部由a-Z或者是A-Z的字字母组成 
<input οnblur="if(/[^a-zA-Z]/g.test(this.value))alert('有错')"> 
4.2 判断字符由字母和数字组成。 
<input οnblur="if(/[^0-9a-zA-Z]/g.test(this.value))alert('有错')"> 
4.3 判断字符由字母和数字，下划线,点号组成.且开头的只能是下划线和字母 
/^([a-zA-z_]{1})([/w]*)$/g.test(str) 
4.4 字符串替换函数.Replace(); 
5、浏览器类 
5.1 判断浏览器的类型 
window.navigator.appName 
5.2 判断ie的版本 
window.navigator.appVersion 
5.3 判断客户端的分辨率 
window.screen.height; window.screen.width; 

6、结合类 
6.1 email的判断。 
function ismail(mail) 
{ 
return(new RegExp(/^/w+((-/w+)|(/./w+))*/@[A-Za-z0-9]+((/.|-)[A-Za-z0-9]+)*/.[A-Za-z0-9]+$/).test(mail)); 
} 
6.2 手机号码的验证 
6.3 身份证的验证 
function isIdCardNo(num) 
{ 
if (isNaN(num)) {alert("输入的不是数字！"); return false;} 
var len = num.length, re; 
if (len == 15) 
re = new RegExp(/^(/d{6})()?(/d{2})(/d{2})(/d{2})(/d{3})$/); 
else if (len == 18) 
re = new RegExp(/^(/d{6})()?(/d{4})(/d{2})(/d{2})(/d{3})(/d)$/); 
else {alert("输入的数字位数不对！"); return false;} 
var a = num.match(re); 
if (a != null) 
{ 
if (len==15) 
{ 
var D = new Date("19"+a[3]+"/"+a[4]+"/"+a[5]); 
var B = D.getYear()==a[3]&&(D.getMonth()+1)==a[4]&&D.getDate()==a[5]; 
} 
else 
{ 
var D = new Date(a[3]+"/"+a[4]+"/"+a[5]); 
var B = D.getFullYear()==a[3]&&(D.getMonth()+1)==a[4]&&D.getDate()==a[5]; 
} 
if (!B) {alert("输入的身份证号 "+ a[0] +" 里出生日期不对！"); return false;} 
} 
return true; 
} 

3.7 复选框的全选，多选，全不选，反选 
<form name=hrong> 
<input type=checkbox name=All οnclick="checkAll('mm')">全选<br/> 
<input type=checkbox name=mm οnclick="checkItem('All')"><br/> 
<input type=checkbox name=mm οnclick="checkItem('All')"><br/> 
<input type=checkbox name=mm οnclick="checkItem('All')"><br/> 
<input type=checkbox name=mm οnclick="checkItem('All')"><br/> 
<input type=checkbox name=mm οnclick="checkItem('All')"><br/><br/> 


<input type=checkbox name=All2 οnclick="checkAll('mm2')">全选<br/> 
<input type=checkbox name=mm2 οnclick="checkItem('All2')"><br/> 
<input type=checkbox name=mm2 οnclick="checkItem('All2')"><br/> 
<input type=checkbox name=mm2 οnclick="checkItem('All2')"><br/> 
<input type=checkbox name=mm2 οnclick="checkItem('All2')"><br/> 
<input type=checkbox name=mm2 οnclick="checkItem('All2')"><br/> 

</form> 

<SCRIPT LANGUAGE="JavaScript"> 
function checkAll(str) 
{ 
var a = document.getElementsByName(str); 
var n = a.length; 
for (var i=0; i<n; i++) 
a[i].checked = window.event.srcElement.checked; 
} 
function checkItem(str) 
{ 
var e = window.event.srcElement; 
var all = eval("document.hrong."+ str); 
if (e.checked) 
{ 
var a = document.getElementsByName(e.name); 
all.checked = true; 
for (var i=0; i<a.length; i++) 
{ 
if (!a[i].checked){ all.checked = false; break;} 
} 
} 
else all.checked = false; 
} 
</SCRIPT> 

3.8 文件上传过程中判断文件类型 
<input type=file οnchange="alert(this.value.match(/^(.*)(/.)(.{1,8})$/)[3])"> 

画图: 
<OBJECT 
id=S 
style="LEFT: 0px; WIDTH: 392px; TOP: 0px; HEIGHT: 240px" 
height=240 
width=392 
classid="clsid:369303C2-D7AC-11D0-89D5-00A0C90833E6"> 
</OBJECT> 
<SCRIPT> 
S.DrawingSurface.ArcDegrees(0,0,0,30,50,60); 
S.DrawingSurface.ArcRadians(30,0,0,30,50,60); 
S.DrawingSurface.Line(10,10,100,100); 
</SCRIPT> 

写注册表： 
<SCRIPT> 
var WshShell = WScript.CreateObject("WScript.Shell"); 
WshShell.RegWrite ("HKCU//Software//ACME//FortuneTeller//", 1, "REG_BINARY"); 
WshShell.RegWrite ("HKCU//Software//ACME//FortuneTeller//MindReader", "Goocher!", "REG_SZ"); 
var bKey = WshShell.RegRead ("HKCU//Software//ACME//FortuneTeller//"); 
WScript.Echo (WshShell.RegRead ("HKCU//Software//ACME//FortuneTeller//MindReader")); 
WshShell.RegDelete ("HKCU//Software//ACME//FortuneTeller//MindReader"); 
WshShell.RegDelete ("HKCU//Software//ACME//FortuneTeller//"); 
WshShell.RegDelete ("HKCU//Software//ACME//"); 
</SCRIPT> 

TABLAE相关(客户端动态增加行列） 
<HTML> 
<SCRIPT LANGUAGE="JScript"> 
function numberCells() { 
var count=0; 
for (i=0; i < document.all.mytable.rows.length; i++) { 
for (j=0; j < document.all.mytable.rows(i).cells.length; j++) { 
document.all.mytable.rows(i).cells(j).innerText = count; 
count++; 
} 
} 
} 
</SCRIPT> 
<BODY οnlοad="numberCells()"> 
<TABLE id=mytable border=1> 
<TR><TH>&nbsp;</TH><TH>&nbsp;</TH><TH>&nbsp;</TH><TH>&nbsp;</TH></TR> 
<TR><TD>&nbsp;</TD><TD>&nbsp;</TD><TD>&nbsp;</TD><TD>&nbsp;</TD></TR> 
<TR><TD>&nbsp;</TD><TD>&nbsp;</TD><TD>&nbsp;</TD><TD>&nbsp;</TD></TR> 
</TABLE> 
</BODY> 
</HTML> 

１．身份证严格验证： 

<script> 
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:"国外"} 

function cidInfo(sId){ 
var iSum=0 
var info="" 
if(!/^/d{17}(/d|x)$/i.test(sId))return false; 
sId=sId.replace(/x$/i,"a"); 
if(aCity[parseInt(sId.substr(0,2))]==null)return "Error:非法地区"; 
sBirthday=sId.substr(6,4)+"-"+Number(sId.substr(10,2))+"-"+Number(sId.substr(12,2)); 
var d=new Date(sBirthday.replace(/-/g,"/")) 
if(sBirthday!=(d.getFullYear()+"-"+ (d.getMonth()+1) + "-" + d.getDate()))return "Error:非法生日"; 
for(var i = 17;i>=0;i --) iSum += (Math.pow(2,i) % 11) * parseInt(sId.charAt(17 - i),11) 
if(iSum%11!=1)return "Error:非法证号"; 
return aCity[parseInt(sId.substr(0,2))]+","+sBirthday+","+(sId.substr(16,1)%2?"男":"女") 
} 

document.write(cidInfo("380524198002300016"),"<br/>"); 
document.write(cidInfo("340524198002300019"),"<br/>") 
document.write(cidInfo("340524197711111111"),"<br/>") 
document.write(cidInfo("34052419800101001x"),"<br/>"); 
</script> 

２．验证ＩＰ地址 
<SCRIPT LANGUAGE="JavaScript"> 
function isip(s){ 
var check=function(v){try{return (v<=255 && v>=0)}catch(x){return false}}; 
var re=s.split(".") 
return (re.length==4)?(check(re[0]) && check(re[1]) && check(re[2]) && check(re[3])):false 
} 

var s="202.197.78.129"; 
alert(isip(s)) 
</SCRIPT> 



３．加sp1后还能用的无边框窗口！！ 
<HTML XMLNS:IE> 
<meta http-equiv="Content-Type" content="text/html; charset=gb2312"> 
<IE:Download ID="include" STYLE="behavior:url(#default#download)" /> 
<title>Chromeless Window</title> 

<SCRIPT LANGUAGE="JScript"> 
/*--- Special Thanks For andot ---*/ 

/* 
This following code are designed and writen by Windy_sk <seasonx@163.net> 
You can use it freely, but u must held all the copyright items! 
*/ 

/*--- Thanks For andot Again ---*/ 

var CW_width = 400; 
var CW_height = 300; 
var CW_top = 100; 
var CW_left = 100; 
var CW_url = "/"; 
var New_CW = window.createPopup(); 
var CW_Body = New_CW.document.body; 
var content = ""; 
var CSStext = "margin:1px;color:black; border:2px outset;border-style:expression(οnmοuseοut=οnmοuseup=function(){this.style.borderStyle='outset'}, οnmοusedοwn=function(){if(event.button!=2)this.style.borderStyle='inset'});background-color:buttonface;width:16px;height:14px;font-size:12px;line-height:11px;cursor:Default;"; 

//Build Window 
include.startDownload(CW_url, function(source){content=source}); 

function insert_content(){ 
var temp = ""; 
CW_Body.style.overflow = "hidden"; 
CW_Body.style.backgroundColor = "white"; 
CW_Body.style.border = "solid black 1px"; 
content = content.replace(/<a ([^>]*)>/g,"<a οnclick='parent.open(this.href);return false' $1>"); 
temp += "<table width=100% height=100% cellpadding=0 cellspacing=0 border=0>"; 
temp += "<tr style=';font-size:12px;background:#0099CC;height:20;cursor:default' οndblclick=/"Max.innerText=Max.innerText=='1'?'2':'1';parent.if_max=!parent.if_max;parent.show_CW();/" οnmοuseup='parent.drag_up(event)' οnmοusemοve='parent.drag_move(event)' οnmοusedοwn='parent.drag_down(event)' onselectstart='return false' οncοntextmenu='return false'>"; 
temp += "<td style='color:#ffffff;padding-left:5px'>Chromeless Window For IE6 SP1</td>"; 
temp += "<td style='color:#ffffff;padding-right:5px;' align=right>"; 
temp += "<span id=Help οnclick=/"alert('Chromeless Window For IE6 SP1 - Ver 1.0//n//nCode By Windy_sk//n//nSpecial Thanks For andot')/" style=/""+CSStext+"font-family:System;padding-right:2px;/">?</span>"; 
temp += "<span id=Min οnclick='parent.New_CW.hide();parent.blur()' style=/""+CSStext+"font-family:Webdings;/" title='Minimum'>0</span>"; 
temp += "<span id=Max οnclick=/"this.innerText=this.innerText=='1'?'2':'1';parent.if_max=!parent.if_max;parent.show_CW();/" style=/""+CSStext+"font-family:Webdings;/" title='Maximum'>1</span>"; 
temp += "<span id=Close οnclick='parent.opener=null;parent.close()' style=/""+CSStext+"font-family:System;padding-right:2px;/" title='Close'>x</span>"; 
temp += "</td></tr><tr><td colspan=2>"; 
temp += "<div id=include style='overflow:scroll;overflow-x:hidden;overflow-y:auto; HEIGHT: 100%; width:"+CW_width+"'>"; 
temp += content; 
temp += "</div>"; 
temp += "</td></tr></table>"; 
CW_Body.innerHTML = temp; 
} 

setTimeout("insert_content()",1000); 

var if_max = true; 
function show_CW(){ 
window.moveTo(10000, 10000); 
if(if_max){ 
New_CW.show(CW_top, CW_left, CW_width, CW_height); 
if(typeof(New_CW.document.all.include)!="undefined"){ 
New_CW.document.all.include.style.width = CW_width; 
New_CW.document.all.Max.innerText = "1"; 
} 

}else{ 
New_CW.show(0, 0, screen.width, screen.height); 
New_CW.document.all.include.style.width = screen.width; 
} 
} 

window.onfocus = show_CW; 
window.onresize = show_CW; 

// Move Window 
var drag_x,drag_y,draging=false 

function drag_move(e){ 
if (draging){ 
New_CW.show(e.screenX-drag_x, e.screenY-drag_y, CW_width, CW_height); 
return false; 
} 
} 

function drag_down(e){ 
if(e.button==2)return; 
if(New_CW.document.body.offsetWidth==screen.width && New_CW.document.body.offsetHeight==screen.height)return; 
drag_x=e.clientX; 
drag_y=e.clientY; 
draging=true; 
e.srcElement.setCapture(); 
} 

function drag_up(e){ 
draging=false; 
e.srcElement.releaseCapture(); 
if(New_CW.document.body.offsetWidth==screen.width && New_CW.document.body.offsetHeight==screen.height) return; 
CW_top = e.screenX-drag_x; 
CW_left = e.screenY-drag_y; 
} 

</SCRIPT> 
</HTML> 

电话号码的验证 

要求： 
　　(1)电话号码由数字、"("、")"和"-"构成 
　　(2)电话号码为3到8位 
　　(3)如果电话号码中包含有区号，那么区号为三位或四位 
　　(4)区号用"("、")"或"-"和其他部分隔开 
　　(5)移动电话号码为11或12位，如果为12位,那么第一位为0 
　　(6)11位移动电话号码的第一位和第二位为"13" 
　　(7)12位移动电话号码的第二位和第三位为"13" 
　　根据这几条规则，可以与出以下正则表达式： 
　　(^[0-9]{3,4}/-[0-9]{3,8}$)|(^[0-9]{3,8}$)|(^/([0-9]{3,4}/)[0-9]{3,8}$)|(^0{0,1}13[0-9]{9}$) 


<script language="javascript"> 
function PhoneCheck(s) { 
var str=s; 
var reg=/(^[0-9]{3,4}/-[0-9]{3,8}$)|(^[0-9]{3,8}$)|(^/([0-9]{3,4}/)[0-9]{3,8}$)|(^0{0,1}13[0-9]{9}$)/ 
alert(reg.test(str)); 
} 
</script> 
<input type=text name="iphone"> 
<input type=button οnclick="PhoneCheck(document.all.iphone.value)" value="Check"> 

具有在输入非数字字符不回显的效果，即对非数字字符的输入不作反应。 
function numbersonly(field,event){ 
var key,keychar; 
if(window.event){ 
key = window.event.keyCode; 
} 
else if (event){ 
key = event.which; 
} 
else{ 
return true 
} 
keychar = String.fromCharCode(key); 
if((key == null)||(key == 0)||(key == 8)||(key == 9)||(key == 13)||(key == 27)){ 
return true; 
} 
else if(("0123456789.").indexOf(keychar)>-1){ 
window.status = ""; 
return true; 
} 
else { 
window.status = "Field excepts numbers only"; 
return false; 
} 
} 

验证ip 

str=document.RegExpDemo.txtIP.value; 
if(/^(/d{1,3})/.(/d{1,3})/.(/d{1,3})/.(/d{1,3})$/.test(str)==false) 
{ 
window.alert('错误的IP地址格式'); 
document.RegExpDemo.txtIP.select(); 
document.RegExpDemo.txtIP.focus(); 
return; 
} 
if(RegExp.$1<1 || RegExp.$1>254||RegExp.$2<0||RegExp.$2>254||RegExp.$3<0||RegExp.$3>254||RegExp.$4<1||RegExp.$4>254) 
{ 
window.alert('错误的IP地址'); 
document.RegExpDemo.txtIP.select(); 
document.RegExpDemo.txtIP.focus(); 
return; 
} 
//剔除 如 010.020.020.03 前面 的0 
var str=str.replace(/0(/d)/g,"$1"); 
str=str.replace(/0(/d)/g,"$1"); 
window.alert(str); 


//一下是取数据的类 
//Obj参数指定数据的来源(限定Table),默认第一行为字段名称行 
//GetTableData类提供MoveNext方法,参数是表的行向上或向下移动的位数,正数向下移动,负数向上. 
//GetFieldData方法获得指定的列名的数据 
//Sort_desc方法对指定的列按降序排列 
//Sort_asc方法对指定的列按升序排列 
//GetData方法返回字段值为特定值的数据数组,提供数据,可以在外部进行其他处理 
//Delete方法删除当前记录,数组减少一行 
//初始化,Obj:table的名字,Leftlen:左面多余数据长度,Rightlen:右面多余数据长度, 
function GetTableData(Obj,LeftLen,RightLen){ 
var MyObj=document.all(Obj); 
var iRow=MyObj.rows.length; 
var iLen=MyObj.rows[0].cells.length; 
var i,j; 

TableData=new Array(); 
for (i=0;i< iRow;i++){ 
TableData[i]=new Array(); 
for (j=0;j<iLen;j++){ 
TableStr=MyObj.rows(i).cells(j).innerText; 
TableStr=TableStr.substring(LeftLen, TableStr.length-RightLen).Trim(); 
TableStr=TableStr.replace(/ /gi,"").replace(//r/n/ig,""); 
TableData[i][j]=TableStr; 
} 
} 

this.TableData=TableData; 
this.cols=this.TableData[0].length; 
this.rows=this.TableData.length; 
this.rowindex=0; 
} 


function movenext(Step){ 
if (this.rowindex>=this.rows){ 
return 
} 

if (Step=="" || typeof(Step)=="undefined") { 
if (this.rowindex<this.rows-1) 
this.rowindex++; 
return; 

} 
else{ 
if (this.rowindex + Step<=this.rows-1 && this.rowindex + Step>=0 ){ 
this.rowindex=this.rowindex + Step; 
} 
else 
{ 
if (this.rowindex + Step<0){ 
this.rowindex= 0; 
return; 
} 
if (this.rowindex + Step>this.rows-1){ 
this.rowindex= this.rows-1; 
return; 
} 
} 
} 
} 


function getfielddata(Field){ 
var colindex=-1; 
var i=0; 
if (typeof(Field) == "number"){ 
colindex=Field; 
} 
else 
{ 
for (i=0;i<this.cols && this.rowindex<this.rows ;i++){ 
if (this.TableData[0][i]==Field){ 
colindex=i; 
break; 
} 
} 
} 
if (colindex!=-1) { 
return this.TableData[this.rowindex][colindex]; 
} 

} 



function sort_desc(){//降序 
var colindex=-1; 
var highindex=-1; 
desc_array=new Array(); 
var i,j; 
for (n=0; n<arguments.length; n++){ 
Field=arguments[arguments.length-1-n]; 
for (i=0;i<this.cols;i++){ 
if (this.TableData[0][i]==Field){ 
colindex=i; 
break; 
} 
} 
if ( colindex==-1 ) 
return; 
else 
{ 
desc_array[0]=this.TableData[0]; 
for(i=1;i<this.rows;i++){ 
desc_array[i]=this.TableData[1]; 
highindex=1; 
for(j=1;j<this.TableData.length;j++){ 
if (desc_array[i][colindex]<this.TableData[j][colindex]){ 
desc_array[i]=this.TableData[j]; 
highindex=j; 
} 

} 
if (highindex!=-1) 
this.TableData=this.TableData.slice(0,highindex).concat(this.TableData.slice(highindex+1,this.TableData.length)); 
} 
} 


this.TableData=desc_array; 
} 
return; 
} 



function sort_asc(){//升序 
var colindex=-1; 
var highindex=-1; 
var i,j; 
for (n=0; n<arguments.length; n++){ 
asc_array=new Array(); 
Field=arguments[arguments.length-1-n]; 
for (i=0;i<this.cols;i++){ 
if (this.TableData[0][i]==Field){ 
colindex=i; 
break; 
} 
} 
if ( colindex==-1 ) 
return; 
else 
{ 
asc_array[0]=this.TableData[0]; 
for(i=1;i<this.rows;i++){ 
asc_array[i]=this.TableData[1]; 
highindex=1; 
for(j=1;j<this.TableData.length;j++){//找出最小的列值 
if (asc_array[i][colindex]>this.TableData[j][colindex]){ 
asc_array[i]=this.TableData[j]; 
highindex=j; 

} 

} 
if (highindex!=-1) 
this.TableData=this.TableData.slice(0,highindex).concat(this.TableData.slice(highindex+1,this.TableData.length)); 

} 
} 


this.TableData=asc_array; 
} 
return; 
} 



function getData(Field,FieldValue){ 
var colindex=-1; 
var i,j; 

GetData=new Array(); 
if (typeof(Field)=="undefined" || typeof(FieldValue)=="undefined" ){ 
return this.TableData; 
} 

for(j=0;j<this.cols;j++){ 
if (this.TableData[0][j]==Field){ 
colindex=j; 
} 
} 
if (colindex!=-1){ 

for(i=1;i<this.rows;i++){ 
if (this.TableData[i][colindex]==FieldValue){ 
GetData[i]=new Array(); 
GetData[i]=this.TableData[i]; 
} 
} 
} 
return GetData; 
} 
function DeletE(){ 
this.TableData=this.TableData.slice(0,this.rowindex).concat(this.TableData.slice(this.rowindex+1,this.TableData.length)); 
this.rows=this.TableData.length; 
return; 
} 
function updateField(Field,FieldValue){ 
var colindex=-1; 
var i=0; 
if (typeof(Field) == "number"){ 
colindex=Field; 
} 
else 
{ 
for (i=0;i<this.cols && this.rowindex<this.rows ;i++){ 
if (this.TableData[0][i]==Field){ 
colindex=i; 
break; 
} 
} 
} 
if (colindex!=-1) { 
this.TableData[this.rowindex][colindex]=FieldValue; 
} 


} 
function movefirst(){ 
this.rowindex=0; 
} 
function movelast(){ 
this.rowindex=this.rows-1; 
} 
function String.prototype.Trim() {return this.replace(/(^/s*)|(/s*$)/g,"");} 
GetTableData.prototype.MoveNext = movenext; 
GetTableData.prototype.GetFieldData = getfielddata; 
GetTableData.prototype.Sort_asc = sort_asc; 
GetTableData.prototype.Sort_desc = sort_desc; 
GetTableData.prototype.GetData = getData; 
GetTableData.prototype.Delete = DeletE; 
GetTableData.prototype.UpdateField = updateField; 
GetTableData.prototype.MoveFirst = movefirst; 

具体的例子：http://202.119.73.208/NetEAn/com/test/jsprint.htm 

在每个文本框的onblur事件中调用校验代码,并且每个文本框中onKeyDown事件中写一个enter转tab函数 

//回车键换为tab 
function enterToTab() 
{ 
if(event.srcElement.type != 'button' && event.srcElement.type != 'textarea' 
&& event.keyCode == 13) 
{ 
event.keyCode = 9; 
} 
}

转自：http://blog.csdn.net/littlekeen/archive/2005/10/13/502551.aspx