正则表达式语法：
一个正则表达式就是由普通字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
/
将下一个字符标记为一个特殊字符、或一个原义字符、或一个 后向引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'/n' 匹配一个换行符。序列 '//' 匹配 "/" 而 "/(" 则匹配 "("。
^
匹配输入字符串的开始位置。
$
匹配输入字符串的结束位置。
*
匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。 * 等价于{0,}。
+
匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
?
匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。
{n}
n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,}
n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
{n,m}
m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。 "o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
?
当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。
.
匹配除 "/n" 之外的任何单个字符。要匹配包括 '/n' 在内的任何字符，请使用象 '[./n]' 的模式。
(pattern)
匹配pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在Visual Basic Scripting Edition 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 '/(' 或 '/)'。
(?:pattern)
匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。
(?=pattern)
正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如， 'Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)
负向预查，在任何不匹配Negative lookahead matches the search string at any point where a string not matching pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如'Windows (?!95|98|NT|2000)' 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows 2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
x|y
匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
[xyz]
字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
[^xyz]
负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'。
[a-z]
字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。
[^a-z]
负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。
/b
匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er/b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
/B
匹配非单词边界。'er/B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
/cx
匹配由x指明的控制字符。例如， /cM 匹配一个 Control-M 或回车符。 x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
/d
匹配一个数字字符。等价于 [0-9]。
/D
匹配一个非数字字符。等价于 [^0-9]。
/f
匹配一个换页符。等价于 /x0c 和 /cL。
/n
匹配一个换行符。等价于 /x0a 和 /cJ。
/r
匹配一个回车符。等价于 /x0d 和 /cM。
/s
匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ /f/n/r/t/v]。
/S
匹配任何非空白字符。等价于 [^ /f/n/r/t/v]。
/t
匹配一个制表符。等价于 /x09 和 /cI。
/v
匹配一个垂直制表符。等价于 /x0b 和 /cK。
/w
匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
/W
匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
/xn
匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如， '/x41' 匹配 "A"。'/x041' 则等价于 '/x04' & "1"。正则表达式中可以使用 ASCII 编码。.
/num
匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)/1' 匹配两个连续的相同字符。
/n
标识一个八进制转义值或一个后向引用。如果 /n 之前至少 n 个获取的子表达式，则 n 为后向引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
/nm
标识一个八进制转义值或一个后向引用。如果 /nm 之前至少有is preceded by at least nm 个获取得子表达式，则 nm 为后向引用。如果 /nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的后向引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 /nm 将匹配八进制转义值 nm。
/nml
如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
/un
匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， /u00A9 匹配版权符号 (?)。
正则表达式使用详解
/
将下一个字符标记为一个特殊字符、或一个原义字符、或一个 后向引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'/n' 匹配一个换行符。序列 '//' 匹配 "/" 而 "/(" 则匹配 "("。
^
匹配输入字符串的开始位置。
$
匹配输入字符串的结束位置。
*
匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。 * 等价于{0,}。
+
匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
?
匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。
{n}
n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,}
n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
{n,m}
m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。 "o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
?
当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。
.
匹配除 "/n" 之外的任何单个字符。要匹配包括 '/n' 在内的任何字符，请使用象 '[./n]' 的模式。
(pattern)
匹配pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在Visual Basic Scripting Edition 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 '/(' 或 '/)'。
(?:pattern)
匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。
(?=pattern)
正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如， 'Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)
负向预查，在任何不匹配Negative lookahead matches the search string at any point where a string not matching pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如'Windows (?!95|98|NT|2000)' 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows 2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
x|y
匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
[xyz]
字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
[^xyz]
负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'。
[a-z]
字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。
[^a-z]
负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。
/b
匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er/b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
/B
匹配非单词边界。'er/B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
/cx
匹配由x指明的控制字符。例如， /cM 匹配一个 Control-M 或回车符。 x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
/d
匹配一个数字字符。等价于 [0-9]。
/D
匹配一个非数字字符。等价于 [^0-9]。
/f
匹配一个换页符。等价于 /x0c 和 /cL。
/n
匹配一个换行符。等价于 /x0a 和 /cJ。
/r
匹配一个回车符。等价于 /x0d 和 /cM。
/s
匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ /f/n/r/t/v]。
/S
匹配任何非空白字符。等价于 [^ /f/n/r/t/v]。
/t
匹配一个制表符。等价于 /x09 和 /cI。
/v
匹配一个垂直制表符。等价于 /x0b 和 /cK。
/w
匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
/W
匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
/xn
匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如， '/x41' 匹配 "A"。'/x041' 则等价于 '/x04' & "1"。正则表达式中可以使用 ASCII 编码。.
/num
匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)/1' 匹配两个连续的相同字符。
/n
标识一个八进制转义值或一个后向引用。如果 /n 之前至少 n 个获取的子表达式，则 n 为后向引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
/nm
标识一个八进制转义值或一个后向引用。如果 /nm 之前至少有is preceded by at least nm 个获取得子表达式，则 nm 为后向引用。如果 /nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的后向引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 /nm 将匹配八进制转义值 nm。
/nml
如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
/un
匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， /u00A9 匹配版权符号 (?)。
如果我们问那些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/
上述正则表达式规定字符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编写以下脚本，验证用户输入的邮件地址的有效性。
--------------------------------------------------------
<html>
<head>
<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 -->
</script>
</head>
<body>
<form onSubmit="return verifyAddress(this);">
<input name="email" type="text">
<input type="submit">
</form>
</body>
</html>
--------------------------------------------------------
入门简介
简单的说，正则表达式是一种可以用于模式匹配和替换的强有力的工具。我们可以在几乎所有的基于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/
上述正则表达式规定字符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编写以下脚本，验证用户输入的邮件地址的有效性。
--------------------------------------------------------
<html>
<head>
<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 -->
</script>
</head>
<body>
<form onSubmit="return verifyAddress(this);">
<input name="email" type="text">
<input type="submit">
</form>
</body>
</html>
--------------------------------------------------------
经常使用的正则表达式举例
^ 对行首
$ 对行尾
^[the]对以the开头行 #估计是^the的笔误
[Ss]igna[lL]对匹配单词signal、signaL、
Signal、SignaL
[Ss]igna[lL]/. 对同上，但加一句点
[mayMAY] 对包含may大写或小写字母的行
^USER$ 对只包含USER的行
[tty]$ 对以tty结尾的行
/. 对带句点的行
^d..x..x..x 对用户、用户组及其他用户组成员有可执行权限的目录
^[^l] 对排除关联目录的目录列表
[.*0] 对0之前或之后加任意字符
[000*] 对000或更多个
[iI] 对大写或小写I
[iI] [nN] 对大写或小写i或n
[^$] 对空行
[^.*$] 对匹配行中任意字符串
^......$ 对包括6个字符的行
[a-zA-Z] 对任意单字符
[a-z][a-z]* 对至少一个小写字母
[^0-9/$] 对非数字或美元标识
[^0-0A-Za-z] 对非数字或字母
[123] 对1到3中一个数字
[Dd]evice 对单词device或Device
De..ce 对前两个字母为De，后跟两个任意字符，最后为ce
/^q对以^q开始行
^.$ 对仅有一个字符的行
^/.[0-9][0-9] 对以一个句点和两个数字开始的行
'"Device"' 对单词device
De[Vv]ice/. 对单词Device或deVice
[0-9]/{2/}-[0-9]/{2/}-[0-9]/{4/} 对日期格式dd-mm-yyyy
[0-9]/{3/}/.[0-9]/{3/}/.[0-9]/{3/}/.[0-9]/{3/}对IP地址格式nnn.nnn.nnn.nnn
[^.*$] 对匹配任意行
常用的正则表达式：$ 对行尾
^[the]对以the开头行 #估计是^the的笔误
[Ss]igna[lL]对匹配单词signal、signaL、
Signal、SignaL
[Ss]igna[lL]/. 对同上，但加一句点
[mayMAY] 对包含may大写或小写字母的行
^USER$ 对只包含USER的行
[tty]$ 对以tty结尾的行
/. 对带句点的行
^d..x..x..x 对用户、用户组及其他用户组成员有可执行权限的目录
^[^l] 对排除关联目录的目录列表
[.*0] 对0之前或之后加任意字符
[000*] 对000或更多个
[iI] 对大写或小写I
[iI] [nN] 对大写或小写i或n
[^$] 对空行
[^.*$] 对匹配行中任意字符串
^......$ 对包括6个字符的行
[a-zA-Z] 对任意单字符
[a-z][a-z]* 对至少一个小写字母
[^0-9/$] 对非数字或美元标识
[^0-0A-Za-z] 对非数字或字母
[123] 对1到3中一个数字
[Dd]evice 对单词device或Device
De..ce 对前两个字母为De，后跟两个任意字符，最后为ce
/^q对以^q开始行
^.$ 对仅有一个字符的行
^/.[0-9][0-9] 对以一个句点和两个数字开始的行
'"Device"' 对单词device
De[Vv]ice/. 对单词Device或deVice
[0-9]/{2/}-[0-9]/{2/}-[0-9]/{4/} 对日期格式dd-mm-yyyy
[0-9]/{3/}/.[0-9]/{3/}/.[0-9]/{3/}/.[0-9]/{3/}对IP地址格式nnn.nnn.nnn.nnn
[^.*$] 对匹配任意行
匹配html的嵌入代码
<[^>]*>
匹配[....]的嵌入码
/[[^]]/{1,/}/]
删除仅由空字符组成的行
sed '/^[[:space:]]*$/d' filename
匹配html标签
//(<[^>]*>/)/
例如：从html文件中剔除html标签
sed 's//(<[^>]*>/)//g;/^[[:space:]]*$/d' file.html
例如：要从下列代码中去除"[]"及其中包括的代码
[b:4c6c2a6554][color=red:4c6c2a6554]一. 替换[/color:4c6c2a6554][/b:4c6c2a6554]
sed 's//[[^]]/{1,/}/]//g' filename
匹配日期：
sed 's//[[^]]/{1,/}/]//g' filename
Month, Day, Year [A-Z][a-z]/{3,9/}, [0-9]/{1,2/}, [0-9]/{4/}
2003-01-28 或 2003.10.18 或 2003/10/10 或 2003 10 10
/([0-9]/{4/}[ /-.][0-2][0-9][ /-.][0-3][0-9]/)
匹配IP地址
2003-01-28 或 2003.10.18 或 2003/10/10 或 2003 10 10
/([0-9]/{4/}[ /-.][0-2][0-9][ /-.][0-3][0-9]/)
/([0-9]/{1,3/}/.[0-9]/{1,3/}/.[0-9]/{1,3/}/.[0-9]/{1,3/}/)
/(/([0-9]/{1,3/}/./)/{3/}[0-9]/{1,3/}/)
匹配数字串
/(/([0-9]/{1,3/}/./)/{3/}[0-9]/{1,3/}/)
[-+]*[0-9]/{1,/} 整数
[-+]*[0-9]/{1,/}/.[0-9]/{1,/} 浮点数
从字串中解析出两个子串(前2各字符和后9个字符)
[-+]*[0-9]/{1,/}/.[0-9]/{1,/} 浮点数
echo "WeLoveChinaUnix"|sed -e 'H;s//(../).*//1/;x;s/.*/(./{9/}/)$//1/;x;G;s//n/ /'
We ChinaUnix
分解日期串
We ChinaUnix
echo 20030922|sed 's//(..../)/(../)/(../)//1 /2 /3/'|read year month day
echo $year $month $day
文件内容倒序输出
echo $year $month $day
sed '1!G;h;$!d' oldfile >newfile
| 各种工具之正则表达式语法比较 | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
正则表达式是具有贪婪性的，我们从下面这例谈起：
已知str="uid=100(guest) gid=100(others) groups=10(users),11(floppy)"
现在想要得到这个字符串中的第一个括号内的值，即guest该怎么办？假设$str的括号外的内容是不固定的，不能依据uid之类的关键字或空格去查找，所依据的只能是找第一对括号内的内容。
很自然的我们想到用sed，因为sed具有很强的模式匹配的功能，而且能够将匹配的部分内容强行记下来用于输出。这样，我们就会想：
echo $str|sed 's/模式串//1/'
只要模式串写好了,在匹配的过程中把guest这个字符串抠出来，让sed记住，然后用/1输出就可以了。怎么写这个模式串？
.*想要匹配"uid=100"
(...)告诉sed要查找括弧内的文本
/(.*/)让sed记住匹配内容的常用手段，这里匹配的.*将来就能用/1取出来
.*想要匹配" gid=100(others) groups=10(users),11(floppy)"部分
于是我们就写成了echo $str|sed 's/.*(/(.*/)).*//1/'
结果呢，得到的是"floppy"，为什么？
正则表达式是有贪婪性的，它总是与最长的可能长度匹配，而且越是排在前面的通配符优先级越高。这一例，第一个.*可以匹配"uid=100(guest) gid=100(others) groups=10(users),11"，仍然能保证后面通配符的匹配，那一对()匹配了floppy左右的括号，最后的.*自然是可有可无的，所以sed记住的就是floppy。
怎么办？我们必须打破正则表达式的贪吃性，用更明确的描述来实现这一点：
我们考虑如果在模式串中第一个.*中告诉sed这个.*是不能含有"("的，不久可以将.*限制到"uid=100"了吗？这个意思我们完全可以用[^(]*来表达，于是我们修订刚才的代码，变成：
echo $str|sed 's/[^(]*(/(.*/)).*//1/'
似乎应该很好了，执行的结果却是"guest) gid=100(others) groups=10(users),11(floppy"，为什么？
原来仍然是正则表达是的贪婪性在作怪，虽然我们有效的阻止了第一个.*的贪吃，但是我们对/(.*/)中的.*却未加限制，于是它尽可能匹配了"guest) gid=100(others) groups=10(users),11(floppy",还能保证后面").*"的匹配性。我们再作限制，告诉sed，/(.*/)中的.*不能含有")"，让它跨不过guest：
echo $str|sed 's/[^(]*(/([^)]*/)).*//1/'
这回，输出结果终于是我们想要得"guest"了。
问题解决了，我们也了解了正则表达式（或说通配符）的贪婪性，于是就可以留个问题给大家，让大家自己体会体会：
怎么样取出str中第二对括号的内容"others"？
怎么样取出str中第三对括号的内容"users"？
怎么样取出str中第四对括号的内容"floppy"？（这个还用说吗，就利用正则表达式的贪婪性，我们最开始不就实现它了嘛）
已知str="uid=100(guest) gid=100(others) groups=10(users),11(floppy)"
现在想要得到这个字符串中的第一个括号内的值，即guest该怎么办？假设$str的括号外的内容是不固定的，不能依据uid之类的关键字或空格去查找，所依据的只能是找第一对括号内的内容。
很自然的我们想到用sed，因为sed具有很强的模式匹配的功能，而且能够将匹配的部分内容强行记下来用于输出。这样，我们就会想：
echo $str|sed 's/模式串//1/'
只要模式串写好了,在匹配的过程中把guest这个字符串抠出来，让sed记住，然后用/1输出就可以了。怎么写这个模式串？
.*想要匹配"uid=100"
(...)告诉sed要查找括弧内的文本
/(.*/)让sed记住匹配内容的常用手段，这里匹配的.*将来就能用/1取出来
.*想要匹配" gid=100(others) groups=10(users),11(floppy)"部分
于是我们就写成了echo $str|sed 's/.*(/(.*/)).*//1/'
结果呢，得到的是"floppy"，为什么？
正则表达式是有贪婪性的，它总是与最长的可能长度匹配，而且越是排在前面的通配符优先级越高。这一例，第一个.*可以匹配"uid=100(guest) gid=100(others) groups=10(users),11"，仍然能保证后面通配符的匹配，那一对()匹配了floppy左右的括号，最后的.*自然是可有可无的，所以sed记住的就是floppy。
怎么办？我们必须打破正则表达式的贪吃性，用更明确的描述来实现这一点：
我们考虑如果在模式串中第一个.*中告诉sed这个.*是不能含有"("的，不久可以将.*限制到"uid=100"了吗？这个意思我们完全可以用[^(]*来表达，于是我们修订刚才的代码，变成：
echo $str|sed 's/[^(]*(/(.*/)).*//1/'
似乎应该很好了，执行的结果却是"guest) gid=100(others) groups=10(users),11(floppy"，为什么？
原来仍然是正则表达是的贪婪性在作怪，虽然我们有效的阻止了第一个.*的贪吃，但是我们对/(.*/)中的.*却未加限制，于是它尽可能匹配了"guest) gid=100(others) groups=10(users),11(floppy",还能保证后面").*"的匹配性。我们再作限制，告诉sed，/(.*/)中的.*不能含有")"，让它跨不过guest：
echo $str|sed 's/[^(]*(/([^)]*/)).*//1/'
这回，输出结果终于是我们想要得"guest"了。
问题解决了，我们也了解了正则表达式（或说通配符）的贪婪性，于是就可以留个问题给大家，让大家自己体会体会：
怎么样取出str中第二对括号的内容"others"？
怎么样取出str中第三对括号的内容"users"？
怎么样取出str中第四对括号的内容"floppy"？（这个还用说吗，就利用正则表达式的贪婪性，我们最开始不就实现它了嘛）
" 匹配行首与行尾。
" 匹配数据集。
" 只匹配字母和数字。
" 匹配一定范围内的字符串集。
当从一个文件或命令输出中抽取或过滤文本时，可以使用正则表达式（ R E），正则表达式是一些特殊或不很特殊的字符串模式的集合。
" 匹配数据集。
" 只匹配字母和数字。
" 匹配一定范围内的字符串集。
基本元字符集及其含义
原帖由 "网中人" 发表：
abc: 表示 abc 三個連續的字符, 但彼此獨立而非集合. (可簡單視為三個 char. set)
(abc): 表示 abc 這三個連續字符的集合. (可簡單視為一個 char. set)
a|b: 表示單一字符, 或 a 或 b .
(abc|xyz): 表示或 abc 或 xyz 這兩個 char. set 之一. (註二)
[abc]: 表示單一字符, 可為 a 或 b 或 c . (與 wildcard 之 [abc] 原理相同)
[^abc]: 表示單一字符, 不為 a 或 b 或 c 即可. (與 wildcard 之 [!abc] 原理相同)
. : 表示任意單一字符. (與 wildcard 之 ? 原理相同)
abc: 表示 abc 三個連續的字符, 但彼此獨立而非集合. (可簡單視為三個 char. set)
(abc): 表示 abc 這三個連續字符的集合. (可簡單視為一個 char. set)
a|b: 表示單一字符, 或 a 或 b .
(abc|xyz): 表示或 abc 或 xyz 這兩個 char. set 之一. (註二)
[abc]: 表示單一字符, 可為 a 或 b 或 c . (與 wildcard 之 [abc] 原理相同)
[^abc]: 表示單一字符, 不為 a 或 b 或 c 即可. (與 wildcard 之 [!abc] 原理相同)
. : 表示任意單一字符. (與 wildcard 之 ? 原理相同)
^ 只只匹配行首
$ 只只匹配行尾
* 只一个单字符后紧跟*，匹配0个或多个此单字符
[ ] 只匹配[ ]内字符。可以是一个单字符，也可以是字符序列。可以使用-
表示[ ]内字符序列范围，如用[ 1 - 5 ]代替[ 1 2 3 4 5 ]
/ 只用来屏蔽一个元字符的特殊含义。因为有时在s h e l l中一些元字符有
特殊含义。/可以使其失去应有意义
. 只匹配任意单字符
p a t t e r n / { n / } 只用来匹配前面p a t t e r n出现次数。n为次数
p a t t e r n / { n，/ } m 只含义同上，但次数最少为n
p a t t e r n / { n，m / } 只含义同上，但p a t t e r n出现次数在n与m之间
现在详细讲解其中特殊含义。
1、使用句点匹配单字符
$ 只只匹配行尾
* 只一个单字符后紧跟*，匹配0个或多个此单字符
[ ] 只匹配[ ]内字符。可以是一个单字符，也可以是字符序列。可以使用-
表示[ ]内字符序列范围，如用[ 1 - 5 ]代替[ 1 2 3 4 5 ]
/ 只用来屏蔽一个元字符的特殊含义。因为有时在s h e l l中一些元字符有
特殊含义。/可以使其失去应有意义
. 只匹配任意单字符
p a t t e r n / { n / } 只用来匹配前面p a t t e r n出现次数。n为次数
p a t t e r n / { n，/ } m 只含义同上，但次数最少为n
p a t t e r n / { n，m / } 只含义同上，但p a t t e r n出现次数在n与m之间
现在详细讲解其中特殊含义。
例一：beng.n:以b e g开头，中间夹一个任意字符。
例二：. . . .X C. . . .：共10个字符，前四个之后为XC
例三：列出所有用户都有写权限的目录或文件 ：
ls -l |grep ...x..x..x
2、行首以^匹配字符串或字符序列
^只允许在一行的开始匹配字符或单词。
例如，使用ls -l命令，并匹配目录。
$ ls -l | grep ^d
3、在行尾以$匹配字符串或字符
可以说$与^正相反，它在行尾匹配字符串或字符， $符号放在匹配单词后。
例一：列出文件httpd1.conf中所有以单词common结尾的行
$grep common$ httpd1.conf
或
$cat httpd1.conf | grep common$
例二：匹配所有空行:^ $
或
$cat httpd1.conf | grep common$
例三：只返回包含一个字符的行：^.$
4、用/屏蔽一个特殊字符的含义
下列字符一般可以认为是特殊字符：
$ . ' " * [] ^ | () / + ?
如：
/ .
反斜杠后面的字符不再是特殊字符，而是一个普通字符，即句点。
/ .
反斜杠后面的字符不再是特殊字符，而是一个普通字符，即句点。
假定要匹配包含^的各行，将反斜杠放在它前面就可以屏蔽其特殊含义：
/ ^
/ ^
在正则表达式中匹配以* . p a s结尾的所有文件：
/ * / . p a s
即可屏蔽字符*的特定含义。
5、使用/{/}匹配模式结果出现的次数
/ * / . p a s
即可屏蔽字符*的特定含义。
使用*可匹配所有匹配结果任意次，但如果只要指定次数，就应使用/ { / }，
此模式有三种形式，即：
pattern/{n/} 匹配模式出现n次。
pattern/{n,/} 匹配模式出现最少n次。
pattern/{n,m} 匹配模式出现n到m次之间，n , m为0 - 2 5 5中任意整数。
例一：匹配字母A出现两次，并以B结尾：
pattern/{n/} 匹配模式出现n次。
pattern/{n,/} 匹配模式出现最少n次。
pattern/{n,m} 匹配模式出现n到m次之间，n , m为0 - 2 5 5中任意整数。
A / { 2 / } B
匹配值为A A B
例二：匹配A至少4次：
A / { 4 , / } B
可以得结果A A A A B或A A A A A A A B，但不能为A A A B。
例三：如给出出现次数范围，例如A出现2次到4次之间：
A / { 2 , 4 / } B
则结果为A A B、A A A B、A A A A B，而不是A B或A A A A A B等。
例四：假定从下述列表中抽取代码：
1234XC9088
4523XX9001
0011XA9912
9931Xc3445
格式如下：前4个字符是数字，接下来是x x，最后4个也是数字，操作如下：
4523XX9001
0011XA9912
9931Xc3445
[ 0 - 9 ] / { 4 / }X X[ 0 - 9 ] / { 4 / }
具体含义如下：
1) 匹配数字出现4次。
2) 后跟代码x x。
3) 最后是数字出现4次。
结果如下
1) 匹配数字出现4次。
2) 后跟代码x x。
3) 最后是数字出现4次。
1234XC9088 -no match
4523XX9001 -match
0011XA9912 -no match
9931Xc3445 -no match
4523XX9001 -match
0011XA9912 -no match
9931Xc3445 -no match
正则表达式的贪婪性
$ unset A
$ [ -n "$A" ] && [ "$A" -lt 100 ] || echo 'too big!'
too big!
为何上面的结果也可得到呢？ 做个记号
$ [ -n "$A" ] && [ "$A" -lt 100 ] || echo 'too big!'
too big!
总结：
fork:在子行程中的环境如何变更，均不会影响父行程的环境。
正常来说，当我们执行一个 shell script 时，其实是先产生一个 sub-shell 的子行程，然后 sub-shell 再去产生命令行的子行程。
即我们正常运行一个脚本时：
./my.script
source：所谓 source 就是让 script 在当前 shell 内执行、而不是产生一个 sub-shell 来执行。
由于所有执行结果均于当前 shell 内完成，若 script 的环境有所改变，当然也会改变当前环境了
source ./my.script
或：
. ./my.script
（）和{ }
或：
. ./my.script
如果希望把几个命令合在一起执行， s h e l l提供了两种方法。既可以在当前s h e l l也可以在子s h e l l中执行一组命令。
1、()：
为了在当前s h e l l中执行一组命令，可以用命令分隔符隔开每一个命令，并把所有的命令用圆括号（）括起来。
它的一般形式为：
使用{ }来代替（），那么相应的命令将在子s h e l l中作为一个整体被执行，只有在{ }中所有命令的输出作为一个整体被重定向时，其中的命令才被放到子s h e l l中执行，否则在当前s h e l l执行。它的一般形式为：
此段有误，现更下如下：
1、()：
为了在当前s h e l l中执行一组命令，可以用命令分隔符隔开每一个命令，并把所有的命令用圆括号（）括起来。
它的一般形式为：
（命令1;命令2;. . .）
2、{}：
使用{ }来代替（），那么相应的命令将在子s h e l l中作为一个整体被执行，只有在{ }中所有命令的输出作为一个整体被重定向时，其中的命令才被放到子s h e l l中执行，否则在当前s h e l l执行。它的一般形式为：
{命令1;命令2;. . . }
(cmd1;cmd2;...;cmdN)#在一个子shell里执行一组命令
{cmd1;cmd2;...;cmdN}# 在当前shell里执行一组命令
这是一个基本概念
[jason@firewall jason]$ A=1;echo $A;{ A=2; };echo $A
1
2
[jason@firewall jason]$ A=1;echo $A;( A=2; );echo $A
1
1
{ A=2; }改变了当前shell变量的值
( A=2; )未改变当前shell变量的值
例一：上面的例子中：
{cmd1;cmd2;...;cmdN}# 在当前shell里执行一组命令
这是一个基本概念
[jason@firewall jason]$ A=1;echo $A;{ A=2; };echo $A
1
2
[jason@firewall jason]$ A=1;echo $A;( A=2; );echo $A
1
1
{ A=2; }改变了当前shell变量的值
( A=2; )未改变当前shell变量的值
$ comet month_end.txt || exit
现在如果该脚本执行失败了，我希望先给自己发个邮件，然后再退出，可以用下面的方法来实现：
$ comet month_end || (echo "Comet did no work" | mail sam ; exit)
上例中由于 只使用了命令分隔符而没有把它们组合在一起， s h e l l将直接执行最后一个命令（e x i t）。
例二：下面是原来的那个例子：
$ sort quarter_end.txt > quarter.sorted && lp quarter.sorted
使用命令组合的方法，如果s o r t命令执行成功了，先将输出文件拷贝到一个日志区，然后再打印。
$ sort quarter_end.txt > quarter.sorted && (cp quarter.sorted /logs/quarter.sorted; lp quarter.sorted)