| character |
|
| x |
Character x |
| \\ |
Backslash character |
| \0n |
With octal character value of 0 n- (0 <= n- <=. 7) |
| \ 0 nn |
With octal character value of 0 NN (0 <= n- <=. 7) |
| \0mnn |
With octal character value of 0 MNN (0 <= m <= 3,0 <= n- <=. 7) |
| \ x hh |
With a hex value 0x characters hh |
| \ U Hhhh |
With a hex value 0x characters hhhh |
| \t |
Tab ( '\ u0009') |
| \n |
New line (line feed) ( '\ u000A') |
| \r |
Carriage return ( '\ u000D') |
| \f |
Feed character ( '\ u000C') |
| \a |
Alarm (Bell) character ( '\ u0007') |
| \e |
Escape character ( '\ u001B') |
| \cx |
Corresponding to the x control word |
|
|
|
| Character Classes |
|
| [abc] |
a, b or C (Simple Profile) |
| [^abc] |
Any characters, in addition to a, b or C (negative) |
| [A-zA-Z] |
a to z or A to Z, including two letters (range) |
| [a-d[m-p]] |
to d or a to m p: [a-dm-p] (union) |
| [a-z&&[def]] |
d, e or f (intersection) |
| [a-z&&[^bc]] |
a through z, and in addition b c: [ad-z] (subtracted) |
| [a-z&&[^m-p]] |
a through z, and not m through p: [a-lq-z] (subtracted) |
|
|
|
| Predefined character classes |
|
| . |
Any character (with a line terminator may or may not match the match) |
| \d |
Digital: [0-9] |
| \D |
Non-numeric: [^ 0-9] |
| \s |
Whitespace: [\ t \ n \ x0B \ f \ r] |
| \S |
Non-whitespace characters: [^ \ s] |
| \w |
Word characters: [a-zA-Z_0-9] |
| \W |
Non-English characters: [^ \ w] |
|
|
|
| POSIX character classes (US-ASCII only) |
|
| \p{Lower} |
Lowercase characters: [az] |
| \p{Upper} |
Uppercase alphabetic characters: [AZ] |
| \p{ASCII} |
All ASCII: [\ x00- \ x7F] |
| \p{Alpha} |
Alphabetic characters: [\ p {Lower} \ p {Upper}] |
| \p{Digit} |
Decimal number: [0-9] |
| \p{Alnum} |
Alphanumeric characters: [\ p {Alpha} \ p {Digit}] |
| \ P {dot} |
! Punctuation: "# $% & '() * +, - / :; <=> @ [\] ^ _` {|} ~.? |
| \p{Graph} |
Visible characters: [\ p {Alnum} \ p {Punct}] |
| \p{Print} |
Printable characters: [\ p {Graph} \ x20] |
| \p{Blank} |
Space or tab: [\ t] |
| \p{Cntrl} |
Control characters: [\ x00- \ x1F \ x7F] |
| \p{XDigit} |
Hexadecimal digits: [0-9a-fA-F] |
| \p{Space} |
Whitespace: [\ t \ n \ x0B \ f \ r] |
|
|
|
| java.lang.Character class (simple java character type ) |
|
| \p{javaLowerCase} |
Equivalent to java.lang.Character.isLowerCase () |
| \p{javaUpperCase} |
等效于 java.lang.Character.isUpperCase() |
| \p{javaWhitespace} |
等效于 java.lang.Character.isWhitespace() |
| \p{javaMirrored} |
等效于 java.lang.Character.isMirrored() |
|
|
|
| Unicode 块和类别的类 |
|
| \p{InGreek} |
Greek 块（简单块）中的字符 |
| \p{Lu} |
大写字母（简单类别） |
| \p{Sc} |
货币符号 |
| \P{InGreek} |
所有字符，Greek 块中的除外（否定） |
| [\p{L}&&[^\p{Lu}]] |
所有字母，大写字母除外（减去） |
|
|
|
| 边界匹配器 |
|
| ^ |
行的开头 |
| $ |
行的结尾 |
| \b |
单词边界 |
| \B |
非单词边界 |
| \A |
输入的开头 |
| \G |
上一个匹配的结尾 |
| \Z |
输入的结尾，仅用于最后的结束符（如果有的话） |
| \z |
输入的结尾 |
|
|
|
| Greedy 数量词 |
|
| X? |
X，一次或一次也没有 |
| X* |
X，零次或多次 |
| X+ |
X，一次或多次 |
| X{n} |
X，恰好 n 次 |
| X{n,} |
X，至少 n 次 |
| X{n,m} |
X，至少 n 次，但是不超过 m 次 |
|
|
|
| Reluctant 数量词 |
|
| X?? |
X，一次或一次也没有 |
| X*? |
X，零次或多次 |
| X+? |
X，一次或多次 |
| X{n}? |
X，恰好 n 次 |
| X{n,}? |
X，至少 n 次 |
| X{n,m}? |
X，至少 n 次，但是不超过 m 次 |
|
|
|
| Possessive 数量词 |
|
| X?+ |
X，一次或一次也没有 |
| X*+ |
X，零次或多次 |
| X++ |
X，一次或多次 |
| X{n}+ |
X，恰好 n 次 |
| X{n,}+ |
X，至少 n 次 |
| X{n,m}+ |
X，至少 n 次，但是不超过 m 次 |
|
|
|
| Logical 运算符 |
|
| XY |
X 后跟 Y |
| X|Y |
X 或 Y |
| (X) |
X，作为捕获组 |
|
|
|
| Back 引用 |
|
| \n |
任何匹配的 nth 捕获组 |
|
|
|
| 引用 |
|
| \ |
Nothing，但是引用以下字符 |
| \Q |
Nothing，但是引用所有字符，直到 \E |
| \E |
Nothing，但是结束从 \Q 开始的引用 |
|
|
|
| 特殊构造（非捕获） |
|
| (?:X) |
X，作为非捕获组 |
| (?idmsux-idmsux) |
|
| (?idmsux-idmsux:X) |
|
| (?=X) |
X，通过零宽度的正 lookahead |
| (?!X) |
X，通过零宽度的负 lookahead |
| (?<=X) |
X，通过零宽度的正 lookbehind |
| (?<!X) |
X，通过零宽度的负 lookbehind |
| (?>X) |
X，作为独立的非捕获组 |
// *表示匹配多个 Pattern p = Pattern.compile("a*b"); Matcher m = p.matcher("aaaaab"); if (m.matches()){ System.out.println("匹配了"); }
在仅使用一次正则表达式时，可以方便地通过此类定义 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句
boolean b = Pattern.matches("a*b", "aaaaab");
等效于上面的三个语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。
此类的实例是不可变的，可供多个并发线程安全使用。Matcher 类的实例用于此目的则不安全。
// JavaScript中的效验的写法
<script>
//1.出现任意数字3次
//a. 创建正则表达式
var reg1 = /^\d{3}$/; //出现任意数字3次
//b. 校验字符串
var str1 = "3451";
var flag1 = reg1.test(str1);
//alert("flag1="+flag1);
//2.只能是英文字母的, 出现6~10次之间
var reg2 =/^[a-zA-Z]{6,10}$/;
var str2 = "abcdef11g";
//alert(reg2.test(str2));
//3 用户名：只能由英文字母和数字组成，长度为4～16个字符，并且以英文字母开头
var reg3 =/^[a-zA-Z][a-zA-Z0-9]{3,15}$/;
var str3 = "zs";
// alert(reg3.test(str3));
//4. 手机号码: 以1开头, 第二位是3,4,5,6,7,8,9的11位数字
//var reg4 =/^1[3456789]\d{9}$/i; //忽略大小写的
var reg4 =/^1[3456789]\d{9}$/; //不忽略大小写的
var str4 = "188245899";
alert(reg4.test(str4));
</script>
------------------------------------------------------------------------------------------------------------------------------------------
Pattern p = Pattern.compile("^.*$");// 任何字符可以匹配
Matcher m = p.matcher("aaaaab11好");
if (m.matches()){
System.out.println("匹配了");
}
// 匹配整数和小数 // [0-9]\d* 匹配整数 // [0-9]\d*\.\d{0,2}? 匹配两位的小数 Pattern p = Pattern.compile("^[0-9]\\d*|[0-9]\\d*\\.\\d{0,2}?$"); Matcher m = p.matcher("0.01"); if (m.matches()){ System.out.println("匹配了"); }
匹配中文字符的正则表达式： [\u4e00-\u9fa5]
评注：匹配中文还真是个头疼的事，有了这个表达式就好办了
匹配双字节字符(包括汉字在内)：[^\x00-\xff]
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
匹配空白行的正则表达式：\n\s*\r
评注：可以用来删除空白行
匹配HTML标记的正则表达式：<(\S*?)[^>]*>.*?</\1>|<.*? />
评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力
匹配首尾空白字符的正则表达式：^\s*|\s*$
评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式
匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
评注：表单验证时很实用
匹配网址URL的正则表达式：[a-zA-z]+://[^\s]*
评注：网上流传的版本功能很有限，上面这个基本可以满足需求
匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
评注：表单验证时很实用
匹配国内电话号码：\d{3}-\d{8}|\d{4}-\d{7}
评注：匹配形式如 0511-4405222 或 021-87888822
匹配腾讯QQ号：[1-9][0-9]{4,}
评注：腾讯QQ号从10000开始
匹配中国邮政编码：[1-9]\d{5}(?!\d)
评注：中国邮政编码为6位数字
匹配身份证：\d{15}|\d{18}
评注：中国的身份证为15位或18位
匹配ip地址：\d+\.\d+\.\d+\.\d+
评注：提取ip地址时有用
匹配特定数字：
^[1-9]\d*$ //匹配正整数
^-[1-9]\d*$ //匹配负整数
^-?[1-9]\d*$ //匹配整数
^[1-9]\d*|0$ //匹配非负整数（正整数 + 0）
^-[1-9]\d*|0$ //匹配非正整数（负整数 + 0）
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ //匹配正浮点数
^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ //匹配负浮点数
^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$ //匹配浮点数
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$ //匹配非负浮点数（正浮点数 + 0）
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$ //匹配非正浮点数（负浮点数 + 0）
评注：处理大量数据时有用，具体应用时注意修正
匹配特定字符串：
^[A-Za-z]+$ //匹配由26个英文字母组成的字符串
^[A-Z]+$ //匹配由26个英文字母的大写组成的字符串
^[a-z]+$ //匹配由26个英文字母的小写组成的字符串
^[A-Za-z0-9]+$ //匹配由数字和26个英文字母组成的字符串
^\w+$ //匹配由数字、26个英文字母或者下划线组成的字符串
匹配中文字符的正则表达式： [\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函数，我们就可以利用这个表达式来实现，如下：
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
这个方法对于字符顺序有要求的字符串可能不适用。
得用正则表达式从URL地址中提取文件名的javascript程序，如下结果为page1
s="http://www.9499.net/page1.htm"
s=s.replace(/(.*\/){0,}([^\.]+).*/ig,"$2")
alert(s)
利用正则表达式限制网页表单里的文本框输入内容：
用正则表达式限制只能输入中文：onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,′′)" onbeforepaste="clipboardData.setData(′text′,clipboardData.getData(′text′).replace(/[^\u4E00-\u9FA5]/g,′′))"
用正则表达式限制只能输入全角字符： onkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,′′)" onbeforepaste="clipboardData.setData(′text′,clipboardData.getData(′text′).replace(/[^\uFF00-\uFFFF]/g,′′))"
用正则表达式限制只能输入数字：onkeyup="value=value.replace(/[^\d]/g,′′) "onbeforepaste="clipboardData.setData(′text′,clipboardData.getData(′text′).replace(/[^\d]/g,′′))"
用正则表达式限制只能输入数字和英文：onkeyup="value=value.replace(/[\W]/g,′′) "onbeforepaste="clipboardData.setData(′text′,clipboardData.getData(′text′).replace(/[^\d]/g,′′))"
public class Regular
{
/**
* 匹配Email地址
* @param email
* @return Boolean
*/
public Boolean checkEmail(String email)
{
return(email.matches("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*"));
}
/**
* 匹配国内电话号码
* 匹配形式如 0511-4405222 或 021-87888822
* @param email
* @return Boolean
*/
public Boolean checkTel(String tel)
{
return(tel.matches("\\d{3}-\\d{8}|\\d{4}-\\d{7}"));
}
/**
* 匹配身份证
* 中国的身份证为15位或18位
* @param id
* @return Boolean
*/
public Boolean checkIdentityCardmail(String id)
{
return(id.matches("\\d{14}[0-9X]|\\d{17}[0-9X]"));
}
/**
* 匹配中文字符一次或多次
* @param ch
* @return Boolean
*/
public Boolean checkChinese(String ch)
{
return(ch.matches("[\u4e00-\u9fa5]+"));
}
/**
* 匹配双字节字符一次或多次
* @param tc
* @return Boolean
*/
public Boolean checkTwoChar(String tc)
{
return(tc.matches("[^\\x00-\\xff]+"));
}
/**
* 匹配HTML标记的正则表达式
* @param html
* @return Boolean
*/
public Boolean checkHTML(String html)
{
return(html.matches("<(\\S*?)[^>]*>.*?|<.*?/>"));
}
摘抄至网上资源...