正则表达式～～～很全的------Sestid

深藏阁楼爱情的钟 2024-04-17 05:51 56阅读 0赞

**目录**

一、正则表达式 - 教程

1、实例

二、正则表达式 - 简介

为什么使用正则表达式？

发展历史

三、正则表达式 - 语法

1、普通字符

2、非打印字符

3、特殊字符

4、限定符

5、定位符

6、选择

7、反向引用

四、正则表达式 - 元字符（重点）

五、正则表达式 - 运算符优先级

总结：

一、校验数字的表达式

校验字符的表达式

三、特殊需求表达式

JS正则表达式匹配电话号........

--------------------

# 一、正则表达式 - 教程 #

正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。

正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。

正则表达式是繁琐的，但它是强大的，学会之后的应用会让你除了提高效率外，会给你带来绝对的成就感。只要认真阅读本教程，加上应用的时候进行一定的参考，掌握正则表达式不是问题。

许多程序设计语言都支持利用正则表达式进行字符串操作。

## 1、实例 ##

以下实例从字符串 str 中找出数字：

实例

从字符串 str 中提取数字部分的内容(匹配一次)：

var str = "abc123def";
    var patt1 = /[0-9]+/;
    document.write(str.match(patt1));

以下标记的文本是获得的匹配的表达式：

> 123

# 二、正则表达式 - 简介 #

除非您以前使用过正则表达式，否则您可能不熟悉一些术语。但是，毫无疑问，您已经使用过不涉及脚本的某些正则表达式概念。

例如，您很可能使用 ? 和 \* 通配符来查找硬盘上的文件。? 通配符匹配文件名中的 0 个或 1 个字符，而 \* 通配符匹配零个或多个字符。像 data(\\w)?\\.dat 这样的模式将查找下列文件：

>     data.dat
>     data1.dat
>     data2.dat
>     datax.dat
>     dataN.dat

使用 \* 字符代替 ? 字符扩大了找到的文件的数量。data.\*\\.dat 匹配下列所有文件：

>     data.dat
>     data1.dat
>     data2.dat
>     data12.dat
>     datax.dat
>     dataXYZ.dat

尽管这种搜索方法很有用，但它还是有限的。通过理解 \* 通配符的工作原理，引入了正则表达式所依赖的概念，但正则表达式功能更强大，而且更加灵活。

正则表达式的使用，可以通过简单的办法来实现强大的功能。下面先给出一个简单的示例：

![format_png][]

*  ^ 为匹配输入字符串的开始位置。
 *  \[0-9\]+匹配多个数字， \[0-9\] 匹配单个数字，\+ 匹配一个或者多个。
 *  abc$匹配字母 abc 并以 abc 结尾，$ 为匹配输入字符串的结束位置。

我们在写用户注册表单时，只允许用户名包含字符、数字、下划线和连接字符(-)，并设置用户名的长度，我们就可以使用以下正则表达式来设定。

![format_png 1][]

以上的正则表达式可以匹配 **runoob、runoob1、run-oob、run\_oob**， 但不匹配 **ru**，因为它包含的字母太短了，小于 3 个无法匹配。也不匹配 **runoob$**, 因为它包含特殊字符。

实例

匹配以数字开头，并以 abc 结尾的字符串。：

var str = "123abc"; 
    var patt1 = /^[0-9]+abc$/; 
    document.write(str.match(patt1));

以下标记的文本是获得的匹配的表达式：

> 123abc

## 为什么使用正则表达式？ ##

典型的搜索和替换操作要求您提供与预期的搜索结果匹配的确切文本。虽然这种技术对于对静态文本执行简单搜索和替换任务可能已经足够了，但它缺乏灵活性，若采用这种方法搜索动态文本，即使不是不可能，至少也会变得很困难。

通过使用正则表达式，可以：

*  测试字符串内的模式。  
    例如，可以测试输入字符串，以查看字符串内是否出现电话号码模式或信用卡号码模式。这称为数据验证。
 *  替换文本。  
    可以使用正则表达式来识别文档中的特定文本，完全删除该文本或者用其他文本替换它。
 *  基于模式匹配从字符串中提取子字符串。  
    可以查找文档内或输入域内特定的文本。

例如，您可能需要搜索整个网站，删除过时的材料，以及替换某些 HTML 格式标记。在这种情况下，可以使用正则表达式来确定在每个文件中是否出现该材料或该 HTML 格式标记。此过程将受影响的文件列表缩小到包含需要删除或更改的材料的那些文件。然后可以使用正则表达式来删除过时的材料。最后，可以使用正则表达式来搜索和替换标记。

--------------------

## 发展历史 ##

正则表达式的"祖先"可以一直上溯至对人类神经系统如何工作的早期研究。Warren McCulloch 和 Walter Pitts 这两位神经生理学家研究出一种数学方式来描述这些神经网络。

1956 年, 一位叫 Stephen Kleene 的数学家在 McCulloch 和 Pitts 早期工作的基础上，发表了一篇标题为"神经网事件的表示法"的论文，引入了正则表达式的概念。正则表达式就是用来描述他称为"正则集的代数"的表达式，因此采用"正则表达式"这个术语。

随后，发现可以将这一工作应用于使用 Ken Thompson 的计算搜索算法的一些早期研究，Ken Thompson 是 Unix 的主要发明人。正则表达式的第一个实用应用程序就是 Unix 中的 qed 编辑器。

如他们所说，剩下的就是众所周知的历史了。从那时起直至现在正则表达式都是基于文本的编辑器和搜索工具中的一个重要部分。

# 三、正则表达式 - 语法 #

## 1、普通字符 ##

普通字符包括没有显式指定为元字符的所有可打印和不可打印字符。这包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号。

--------------------

## 2、非打印字符 ##

非打印字符也可以是正则表达式的组成部分。下表列出了表示非打印字符的转义序列：

<table> 
 <thead> 
  <tr> 
   <th style="width:87px;">字符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:87px;">\cx</td> 
   <td>匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。</td> 
  </tr> 
  <tr> 
   <td style="width:87px;">\f</td> 
   <td>匹配一个换页符。等价于 \x0c 和 \cL。</td> 
  </tr> 
  <tr> 
   <td style="width:87px;">\n</td> 
   <td>匹配一个换行符。等价于 \x0a 和 \cJ。</td> 
  </tr> 
  <tr> 
   <td style="width:87px;">\r</td> 
   <td>匹配一个回车符。等价于 \x0d 和 \cM。</td> 
  </tr> 
  <tr> 
   <td style="width:87px;">\s</td> 
   <td>匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。注意 Unicode 正则表达式会匹配全角空格符。</td> 
  </tr> 
  <tr> 
   <td style="width:87px;">\S</td> 
   <td>匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。</td> 
  </tr> 
  <tr> 
   <td style="width:87px;">\t</td> 
   <td>匹配一个制表符。等价于 \x09 和 \cI。</td> 
  </tr> 
  <tr> 
   <td style="width:87px;">\v</td> 
   <td>匹配一个垂直制表符。等价于 \x0b 和 \cK。</td> 
  </tr> 
 </tbody> 
</table>

## 3、特殊字符 ##

所谓特殊字符，就是一些有特殊含义的字符，如上面说的 runoo\*b 中的 \*，简单的说就是表示任何字符串的意思。如果要查找字符串中的 \* 符号，则需要对 \* 进行转义，即在其前加一个 \\: runo\\\*ob 匹配 runo\*ob。

许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符\\ 放在它们前面。下表列出了正则表达式中的特殊字符：

<table> 
 <thead> 
  <tr> 
   <th style="width:105px;">特殊字符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:105px;">$</td> 
   <td>匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 \$。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">( )</td> 
   <td>标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 $ 和 $。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">*</td> 
   <td>匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">+</td> 
   <td>匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">.</td> 
   <td>匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 \. 。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">[</td> 
   <td>标记一个中括号表达式的开始。要匹配 [，请使用 \[。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">?</td> 
   <td>匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">\</td> 
   <td>将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配 "("。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">^</td> 
   <td>匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">{ </td> 
   <td>标记限定符表达式的开始。要匹配 {，请使用 \{。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">|</td> 
   <td>指明两项之间的一个选择。要匹配 |，请使用 \|。</td> 
  </tr> 
 </tbody> 
</table>

## 4、限定符 ##

限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有 \* 或 + 或 ? 或 \{n\} 或 \{n,\} 或 \{n,m\} 共6种。

正则表达式的限定符有：

<table> 
 <thead> 
  <tr> 
   <th style="width:116px;">字符</th> 
   <th style="width:694px;">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:116px;">*</td> 
   <td style="width:694px;">匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。</td> 
  </tr> 
  <tr> 
   <td style="width:116px;">+</td> 
   <td style="width:694px;">匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。</td> 
  </tr> 
  <tr> 
   <td style="width:116px;">?</td> 
   <td style="width:694px;">匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 、 "does" 中的 "does" 、 "doxy" 中的 "do" 。? 等价于 {0,1}。</td> 
  </tr> 
  <tr> 
   <td style="width:116px;">{n}</td> 
   <td style="width:694px;">n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。</td> 
  </tr> 
  <tr> 
   <td style="width:116px;">{n,}</td> 
   <td style="width:694px;">n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。</td> 
  </tr> 
  <tr> 
   <td style="width:116px;">{n,m}</td> 
   <td style="width:694px;">m 和 n 均为非负整数，其中n &lt;= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。</td> 
  </tr> 
 </tbody> 
</table>

## 5、定位符 ##

定位符使您能够将正则表达式固定到行首或行尾。它们还使您能够创建这样的正则表达式，这些正则表达式出现在一个单词内、在一个单词的开头或者一个单词的结尾。

定位符用来描述字符串或单词的边界，^ 和 $ 分别指字符串的开始与结束，\\b 描述单词的前或后边界，\\B 表示非单词边界。

正则表达式的定位符有：

<table> 
 <thead> 
  <tr> 
   <th style="width:152px;">字符</th> 
   <th style="width:698px;">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>^</td> 
   <td style="width:698px;">匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与 \n 或 \r 之后的位置匹配。</td> 
  </tr> 
  <tr> 
   <td>$</td> 
   <td style="width:698px;">匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与 \n 或 \r 之前的位置匹配。</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td style="width:698px;">匹配一个单词边界，即字与空格间的位置。</td> 
  </tr> 
  <tr> 
   <td>\B</td> 
   <td style="width:698px;">非单词边界匹配。</td> 
  </tr> 
 </tbody> 
</table>

**注意**：不能将限定符与定位符一起使用。由于在紧靠换行或者单词边界的前面或后面不能有一个以上位置，因此不允许诸如 ^\* 之类的表达式。

若要匹配一行文本开始处的文本，请在正则表达式的开始使用 ^ 字符。不要将 ^ 的这种用法与中括号表达式内的用法混淆。

若要匹配一行文本的结束处的文本，请在正则表达式的结束处使用 $ 字符。

## 6、选择 ##

用圆括号将所有选择项括起来，相邻的选择项之间用|分隔。但用圆括号会有一个副作用，使相关的匹配会被缓存，此时可用?:放在第一个选项前来消除这种副作用。

其中 ?: 是非捕获元之一，还有两个非捕获元是 ?= 和 ?!，这两个还有更多的含义，前者为正向预查，在任何开始匹配圆括号内的正则表达式模式的位置来匹配搜索字符串，后者为负向预查，在任何开始不匹配该正则表达式模式的位置来匹配搜索字符串。

--------------------

## 7、反向引用 ##

对一个正则表达式模式或部分模式两边添加圆括号将导致相关匹配存储到一个临时缓冲区中，所捕获的每个子匹配都按照在正则表达式模式中从左到右出现的顺序存储。缓冲区编号从 1 开始，最多可存储 99 个捕获的子表达式。每个缓冲区都可以使用 \\n 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。

可以使用非捕获元字符 ?:、?= 或 ?! 来重写捕获，忽略对相关匹配的保存。

反向引用的最简单的、最有用的应用之一，是提供查找文本中两个相同的相邻单词的匹配项的能力。以下面的句子为例：

>     Is is the cost of of gasoline going up up?

上面的句子很显然有多个重复的单词。如果能设计一种方法定位该句子，而不必查找每个单词的重复出现，那该有多好。下面的正则表达式使用单个子表达式来实现这一点：

实例

查找重复的单词：

var str = "Is is the cost of of gasoline going up up"; 
    var patt1 = /\b([a-z]+) \1\b/ig; 
    document.write(str.match(patt1));

结果：

> Is is,of of,up up

捕获的表达式，正如 \[a-z\]+ 指定的，包括一个或多个字母。正则表达式的第二部分是对以前捕获的子匹配项的引用，即，单词的第二个匹配项正好由括号表达式匹配。\\1 指定第一个子匹配项。

单词边界元字符确保只检测整个单词。否则，诸如 "is issued" 或 "this is" 之类的词组将不能正确地被此表达式识别。

正则表达式后面的全局标记 g 指定将该表达式应用到输入字符串中能够查找到的尽可能多的匹配。

表达式的结尾处的不区分大小写 i 标记指定不区分大小写。

多行标记指定换行符的两边可能出现潜在的匹配。

反向引用还可以将通用资源指示符 (URI) 分解为其组件。假定您想将下面的 URI 分解为协议（ftp、http 等等）、域地址和页/路径：

>     http://www.runoob.com:80/html/html-tutorial.html

下面的正则表达式提供该功能：

实例

输出所有匹配的数据：

var str = "http://www.runoob.com:80/html/html-tutorial.html"; 
    var patt1 = /(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/; 
    arr = str.match(patt1);
    for (var i = 0; i < arr.length ; i++) {
        document.write(arr[i]);
        document.write("<br>"); 
    }

结果：

> http://www.runoob.com:80/html/html-tutorial.html  
> http  
> www.runoob.com  
> :80  
> /html/html-tutorial.html

第三行代码 str.match(patt1) 返回一个数组，实例中的数组包含 5 个元素，索引 0 对应的是整个字符串，索引 1 对应第一个匹配符（括号内），以此类推。

第一个括号子表达式捕获 Web 地址的协议部分。该子表达式匹配在冒号和两个正斜杠前面的任何单词。

第二个括号子表达式捕获地址的域地址部分。子表达式匹配 : 和 / 之后的一个或多个字符。

第三个括号子表达式捕获端口号（如果指定了的话）。该子表达式匹配冒号后面的零个或多个数字。只能重复一次该子表达式。

最后，第四个括号子表达式捕获 Web 地址指定的路径和 / 或页信息。该子表达式能匹配不包括 \# 或空格字符的任何字符序列。

将正则表达式应用到上面的 URI，各子匹配项包含下面的内容：

*  第一个括号子表达式包含 **http**
 *  第二个括号子表达式包含 **www.runoob.com**
 *  第三个括号子表达式包含 **:80**
 *  第四个括号子表达式包含 **/html/html-tutorial.html**

# 四、正则表达式 - 元字符（重点） #

下表包含了元字符的完整列表以及它们在正则表达式上下文中的行为：

<table> 
 <thead> 
  <tr> 
   <th style="width:136px;">字符</th> 
   <th style="width:673px;">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>\</td> 
   <td> <p>将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。</p> </td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td> <p>匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。</p> </td> 
  </tr> 
  <tr> 
   <td>$</td> 
   <td> <p>匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。</p> </td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td> <p>匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。</p> </td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td> <p>匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。</p> </td> 
  </tr> 
  <tr> 
   <td>?</td> 
   <td> <p>匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 。? 等价于 {0,1}。</p> </td> 
  </tr> 
  <tr> 
   <td>{n}</td> 
   <td> <p>n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。</p> </td> 
  </tr> 
  <tr> 
   <td>{n,}</td> 
   <td> <p>n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。</p> </td> 
  </tr> 
  <tr> 
   <td>{n,m}</td> 
   <td> <p>m 和 n 均为非负整数，其中n &lt;= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。</p> </td> 
  </tr> 
  <tr> 
   <td>?</td> 
   <td> <p>当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。</p> </td> 
  </tr> 
  <tr> 
   <td>.</td> 
   <td> <p>匹配除换行符（\n、\r）之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用像"<strong>(.|\n)</strong>"的模式。</p> </td> 
  </tr> 
  <tr> 
   <td>(pattern)</td> 
   <td> <p>匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 '$' 或 '$'。</p> </td> 
  </tr> 
  <tr> 
   <td>(?:pattern)</td> 
   <td> <p>匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。</p> </td> 
  </tr> 
  <tr> 
   <td>(?=pattern)</td> 
   <td> <p>正向肯定预查（look ahead positive assert），在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，"Windows(?=95|98|NT|2000)"能匹配"Windows2000"中的"Windows"，但不能匹配"Windows3.1"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。</p> </td> 
  </tr> 
  <tr> 
   <td>(?!pattern)</td> 
   <td> <p>正向否定预查(negative assert)，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如"Windows(?!95|98|NT|2000)"能匹配"Windows3.1"中的"Windows"，但不能匹配"Windows2000"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。</p> </td> 
  </tr> 
  <tr> 
   <td>(?&lt;=pattern)</td> 
   <td>反向(look behind)肯定预查，与正向肯定预查类似，只是方向相反。例如，"<code>(?&lt;=95|98|NT|2000)Windows</code>"能匹配"<code>2000Windows</code>"中的"<code>Windows</code>"，但不能匹配"<code>3.1Windows</code>"中的"<code>Windows</code>"。</td> 
  </tr> 
  <tr> 
   <td>(?&lt;!pattern)</td> 
   <td>反向否定预查，与正向否定预查类似，只是方向相反。例如"<code>(?&lt;!95|98|NT|2000)Windows</code>"能匹配"<code>3.1Windows</code>"中的"<code>Windows</code>"，但不能匹配"<code>2000Windows</code>"中的"<code>Windows</code>"。</td> 
  </tr> 
  <tr> 
   <td>x|y</td> 
   <td> <p>匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。</p> </td> 
  </tr> 
  <tr> 
   <td>[xyz]</td> 
   <td> <p>字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。</p> </td> 
  </tr> 
  <tr> 
   <td>[^xyz]</td> 
   <td> <p>负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'、'l'、'i'、'n'。</p> </td> 
  </tr> 
  <tr> 
   <td>[a-z]</td> 
   <td> <p>字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。</p> </td> 
  </tr> 
  <tr> 
   <td>[^a-z]</td> 
   <td> <p>负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。</p> </td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td> <p>匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。</p> </td> 
  </tr> 
  <tr> 
   <td>\B</td> 
   <td> <p>匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。</p> </td> 
  </tr> 
  <tr> 
   <td>\cx</td> 
   <td> <p>匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。</p> </td> 
  </tr> 
  <tr> 
   <td>\d</td> 
   <td> <p>匹配一个数字字符。等价于 [0-9]。</p> </td> 
  </tr> 
  <tr> 
   <td>\D</td> 
   <td> <p>匹配一个非数字字符。等价于 [^0-9]。</p> </td> 
  </tr> 
  <tr> 
   <td>\f</td> 
   <td> <p>匹配一个换页符。等价于 \x0c 和 \cL。</p> </td> 
  </tr> 
  <tr> 
   <td>\n</td> 
   <td> <p>匹配一个换行符。等价于 \x0a 和 \cJ。</p> </td> 
  </tr> 
  <tr> 
   <td>\r</td> 
   <td> <p>匹配一个回车符。等价于 \x0d 和 \cM。</p> </td> 
  </tr> 
  <tr> 
   <td>\s</td> 
   <td> <p>匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。</p> </td> 
  </tr> 
  <tr> 
   <td>\S</td> 
   <td> <p>匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。</p> </td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td> <p>匹配一个制表符。等价于 \x09 和 \cI。</p> </td> 
  </tr> 
  <tr> 
   <td>\v</td> 
   <td> <p>匹配一个垂直制表符。等价于 \x0b 和 \cK。</p> </td> 
  </tr> 
  <tr> 
   <td>\w</td> 
   <td> <p>匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'。</p> </td> 
  </tr> 
  <tr> 
   <td>\W</td> 
   <td> <p>匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]'。</p> </td> 
  </tr> 
  <tr> 
   <td>\xn</td> 
   <td> <p>匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，'\x41' 匹配 "A"。'\x041' 则等价于 '\x04' &amp; "1"。正则表达式中可以使用 ASCII 编码。</p> </td> 
  </tr> 
  <tr> 
   <td>\num</td> 
   <td> <p>匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)\1' 匹配两个连续的相同字符。</p> </td> 
  </tr> 
  <tr> 
   <td>\n</td> 
   <td> <p>标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。</p> </td> 
  </tr> 
  <tr> 
   <td>\nm</td> 
   <td> <p>标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。</p> </td> 
  </tr> 
  <tr> 
   <td>\nml</td> 
   <td> <p>如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。</p> </td> 
  </tr> 
  <tr> 
   <td>\un</td> 
   <td> <p>匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。</p> </td> 
  </tr> 
 </tbody> 
</table>

# 五、正则表达式 - 运算符优先级 #

正则表达式从左到右进行计算，并遵循优先级顺序，这与算术表达式非常类似。

相同优先级的从左到右进行运算，不同优先级的运算先高后低。下表从最高到最低说明了各种正则表达式运算符的优先级顺序：

<table> 
 <thead> 
  <tr> 
   <th style="width:136px;">运算符</th> 
   <th style="width:610px;">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>\</td> 
   <td>转义符</td> 
  </tr> 
  <tr> 
   <td>(), (?:), (?=), []</td> 
   <td>圆括号和方括号</td> 
  </tr> 
  <tr> 
   <td>*, +, ?, {n}, {n,}, {n,m}</td> 
   <td>限定符</td> 
  </tr> 
  <tr> 
   <td>^, $, \任何元字符、任何字符</td> 
   <td>定位点和序列（即：位置和顺序）</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>替换，"或"操作<br> 字符具有高于替换运算符的优先级，使得"m|food"匹配"m"或"food"。若要匹配"mood"或"food"，请使用括号创建子表达式，从而产生"(m|f)ood"。</td> 
  </tr> 
 </tbody> 
</table>

# 总结： #

## 一、校验数字的表达式 ##

*  数字：**^\[0-9\]\*$**
 *  n位的数字：**^\\d\{n\}$**
 *  至少n位的数字**：^\\d\{n,\}$**
 *  m-n位的数字：**^\\d\{m,n\}$**
 *  零和非零开头的数字：**^(0|\[1-9\]\[0-9\]\*)$**
 *  非零开头的最多带两位小数的数字：**^(\[1-9\]\[0-9\]\*)+(\\.\[0-9\]\{1,2\})?$**
 *  带1-2位小数的正数或负数：**^(\\-)?\\d+(\\.\\d\{1,2\})$**
 *  正数、负数、和小数：**^(\\-|\\+)?\\d+(\\.\\d+)?$**
 *  有两位小数的正实数：**^\[0-9\]+(\\.\[0-9\]\{2\})?$**
 *  有1~3位小数的正实数：**^\[0-9\]+(\\.\[0-9\]\{1,3\})?$**
 *  非零的正整数：**^\[1-9\]\\d\*$ 或 ^(\[1-9\]\[0-9\]\*)\{1,3\}$ 或 ^\\+?\[1-9\]\[0-9\]\*$**
 *  非零的负整数：**^\\-\[1-9\]\[\]0-9"\*$ 或 ^-\[1-9\]\\d\*$**
 *  非负整数：**^\\d+$ 或 ^\[1-9\]\\d\*|0$**
 *  非正整数：**^-\[1-9\]\\d\*|0$ 或 ^((-\\d+)|(0+))$**
 *  非负浮点数：**^\\d+(\\.\\d+)?$ 或 ^\[1-9\]\\d\*\\.\\d\*|0\\.\\d\*\[1-9\]\\d\*|0?\\.0+|0$**
 *  非正浮点数：**^((-\\d+(\\.\\d+)?)|(0+(\\.0+)?))$ 或 ^(-(\[1-9\]\\d\*\\.\\d\*|0\\.\\d\*\[1-9\]\\d\*))|0?\\.0+|0$**
 *  正浮点数：**^\[1-9\]\\d\*\\.\\d\*|0\\.\\d\*\[1-9\]\\d\*$ 或 ^((\[0-9\]+\\.\[0-9\]\*\[1-9\]\[0-9\]\*)|(\[0-9\]\*\[1-9\]\[0-9\]\*\\.\[0-9\]+)|(\[0-9\]\*\[1-9\]\[0-9\]\*))$**
 *  负浮点数：**^-(\[1-9\]\\d\*\\.\\d\*|0\\.\\d\*\[1-9\]\\d\*)$ 或 ^(-((\[0-9\]+\\.\[0-9\]\*\[1-9\]\[0-9\]\*)|(\[0-9\]\*\[1-9\]\[0-9\]\*\\.\[0-9\]+)|(\[0-9\]\*\[1-9\]\[0-9\]\*)))$**
 *  浮点数：**^(-?\\d+)(\\.\\d+)?$ 或 ^-?(\[1-9\]\\d\*\\.\\d\*|0\\.\\d\*\[1-9\]\\d\*|0?\\.0+|0)$**

--------------------

## 校验字符的表达式 ##

*  汉字：**^\[\\u4e00-\\u9fa5\]\{0,\}$**
 *  英文和数字：**^\[A-Za-z0-9\]+$ 或 ^\[A-Za-z0-9\]\{4,40\}$**
 *  长度为3-20的所有字符：**^.\{3,20\}$**
 *  由26个英文字母组成的字符串：**^\[A-Za-z\]+$**
 *  由26个大写英文字母组成的字符串：**^\[A-Z\]+$**
 *  由26个小写英文字母组成的字符串：**^\[a-z\]+$**
 *  由数字和26个英文字母组成的字符串：**^\[A-Za-z0-9\]+$**
 *  由数字、26个英文字母或者下划线组成的字符串：**^\\w+$ 或 ^\\w\{3,20\}$**
 *  中文、英文、数字包括下划线：**^\[\\u4E00-\\u9FA5A-Za-z0-9\_\]+$**
 *  中文、英文、数字但不包括下划线等符号：**^\[\\u4E00-\\u9FA5A-Za-z0-9\]+$ 或 ^\[\\u4E00-\\u9FA5A-Za-z0-9\]\{2,20\}$**
 *  可以输入含有^%&',;=?$\\"等字符：**\[^%&',;=?$\\x22\]+**
 *  禁止输入含有~的字符：**\[^~\\x22\]+**

--------------------

## 三、特殊需求表达式 ##

*  Email地址：**^\\w+(\[-+.\]\\w+)\*@\\w+(\[-.\]\\w+)\*\\.\\w+(\[-.\]\\w+)\*$**
 *  域名：**\[a-zA-Z0-9\]\[-a-zA-Z0-9\]\{0,62\}(/.\[a-zA-Z0-9\]\[-a-zA-Z0-9\]\{0,62\})+/.?**
 *  InternetURL：**\[a-zA-z\]+://\[^\\s\]\* 或 ^http://(\[\\w-\]+\\.)+\[\\w-\]+(/\[\\w-./?%&=\]\*)?$**
 *  手机号码：**^(13\[0-9\]|14\[5|7\]|15\[0|1|2|3|5|6|7|8|9\]|18\[0|1|2|3|5|6|7|8|9\])\\d\{8\}$**
 *  电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：**^(\\(\\d\{3,4\}-)|\\d\{3.4\}-)?\\d\{7,8\}$**
 *  国内电话号码(0511-4405222、021-87888822)：**\\d\{3\}-\\d\{8\}|\\d\{4\}-\\d\{7\}**
 *  电话号码正则表达式（支持手机号码，3-4位区号，7-8位直播号码，1－4位分机号）: **((\\d\{11\})|^((\\d\{7,8\})|(\\d\{4\}|\\d\{3\})-(\\d\{7,8\})|(\\d\{4\}|\\d\{3\})-(\\d\{7,8\})-(\\d\{4\}|\\d\{3\}|\\d\{2\}|\\d\{1\})|(\\d\{7,8\})-(\\d\{4\}|\\d\{3\}|\\d\{2\}|\\d\{1\}))$)**
 *  身份证号(15位、18位数字)，最后一位是校验位，可能为数字或字符X：**(^\\d\{15\}$)|(^\\d\{18\}$)|(^\\d\{17\}(\\d|X|x)$)**
 *  帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：**^\[a-zA-Z\]\[a-zA-Z0-9\_\]\{4,15\}$**
 *  密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：**^\[a-zA-Z\]\\w\{5,17\}$**
 *  强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在 8-10 之间)：**^(?=.\*\\d)(?=.\*\[a-z\])(?=.\*\[A-Z\])\[a-zA-Z0-9\]\{8,10\}$**
 *  强密码(必须包含大小写字母和数字的组合，可以使用特殊字符，长度在8-10之间)：**^(?=.\*\\d)(?=.\*\[a-z\])(?=.\*\[A-Z\]).\{8,10\}$**
 *  日期格式：**^\\d\{4\}-\\d\{1,2\}-\\d\{1,2\}**
 *  一年的12个月(01～09和1～12)：**^(0?\[1-9\]|1\[0-2\])$**
 *  一个月的31天(01～09和1～31)：**^((0?\[1-9\])|((1|2)\[0-9\])|30|31)$**
 *  钱的输入格式：
    
    1.  有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：**^\[1-9\]\[0-9\]\*$**
    2.  这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：**^(0|\[1-9\]\[0-9\]\*)$**
    3.  一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：**^(0|-?\[1-9\]\[0-9\]\*)$**
    4.  这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧。下面我们要加的是说明可能的小数部分：**^\[0-9\]+(.\[0-9\]+)?$**
    5.  必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：**^\[0-9\]+(.\[0-9\]\{2\})?$**
    6.  这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：**^\[0-9\]+(.\[0-9\]\{1,2\})?$**
    7.  这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：**^\[0-9\]\{1,3\}(,\[0-9\]\{3\})\*(.\[0-9\]\{1,2\})?$**
    8.  1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：**^(\[0-9\]+|\[0-9\]\{1,3\}(,\[0-9\]\{3\})\*)(.\[0-9\]\{1,2\})?$**
    9.  备注：这就是最终结果了,别忘了"+"可以用"\*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里
 *  xml文件：**^(\[a-zA-Z\]+-?)+\[a-zA-Z0-9\]+\\\\.\[x|X\]\[m|M\]\[l|L\]$**
 *  中文字符的正则表达式：**\[\\u4e00-\\u9fa5\]**
 *  双字节字符：**\[^\\x00-\\xff\] (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))**
 *  空白行的正则表达式：**\\n\\s\*\\r (可以用来删除空白行)**
 *  HTML标记的正则表达式：**<(\\S\*?)\[^>\]\*>.\*?|<.\*? /> ( 首尾空白字符的正则表达式：^\\s\*|\\s\*$或(^\\s\*)|(\\s\*$) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)**
 *  腾讯QQ号：**\[1-9\]\[0-9\]\{4,\} (腾讯QQ号从10000开始)**
 *  中国邮政编码：**\[1-9\]\\d\{5\}(?!\\d) (中国邮政编码为6位数字)**
 *  IP地址：**((?:(?:25\[0-5\]|2\[0-4\]\\\\d|\[01\]?\\\\d?\\\\d)\\\\.)\{3\}(?:25\[0-5\]|2\[0-4\]\\\\d|\[01\]?\\\\d?\\\\d))**

# JS正则表达式匹配电话号........ #

[正则][Link 1]表达式（regular expression）是一个描述字符模式的对象。使用[JavaScript][]正则表达式可以进行强大的模式匹配和文本检索与替换功能。

**手机号码正则表达式验证。**

或者

感谢Sestid的提醒，我查了一下了解了“ 小括号就是括号内看成一个整体 ,中括号就是匹配括号内的其中一个”[·][Link 2]

下面简单的解释一下：

`^1(3|4|5|7|8)\d{9}$`

表示以1开头，第二位可能是3/4/5/7/8等的任意一个，在加上后面的\\d表示数字\[0-9\]的9位，总共加起来11位结束。

具体请参考这篇文章解说：[JS最新手机号码检验正则表达式][JS] （绝对能让你明白）

我猜你可能会喜欢关于[JavaScript][]正则的文章：[正则][Link 3]

1.  [JavaScript][]中的*正则*表达式总结（大量的正则）
2.  [JavaScript正则表达式][JavaScript 1]（例子）

**固定电话号码正则表达式**：

身份证正则：

//身份证正则表达式(15位)
    isIDCard1=/^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$/;
    //身份证正则表达式(18位)
    isIDCard2=/^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$/;
    身份证正则合并：(^\d{15}$)|(^\d{17}([0-9]|X)$)

其他

提取信息中的网络链接:(h|H)(r|R)(e|E)(f|F) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?
    提取信息中的邮件地址:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
    提取信息中的图片链接:(s|S)(r|R)(c|C) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?
    提取信息中的IP地址:(\d+)\.(\d+)\.(\d+)\.(\d+)
    提取信息中的中国电话号码（包括移动和固定电话）:($\d{3,4}$|\d{3,4}-|\s)?\d{7,14}
    提取信息中的中国邮政编码:[1-9]{1}(\d+){5}
    提取信息中的中国身份证号码:\d{18}|\d{15}
    提取信息中的整数：\d+
    提取信息中的浮点数（即小数）：(-?\d*)\.?\d+
    提取信息中的任何数字 ：(-?\d*)(\.\d+)?
    提取信息中的中文字符串：[\u4e00-\u9fa5]*
    提取信息中的双字节字符串 (汉字)：[^\x00-\xff]*

使用：

test()方法在字符串中查找是否存在指定的正则表达式，并返回布尔值，如果存在则返回true，否则返回false。

//code from http://caibaojian.com/regexp-example.html
    var pattern = new RegExp('Box','i');
    var str = 'box';
    alert(pattern.test(str)); //true
    var pattern = /Box/i;
    var str = 'box';
    alert(pattern.test(str)); //true
    var pattern = /Box/i;
    var str = 'This is a box';
    alert(pattern.test(str)); //true

2019.6.5新增16和19开头的手机号码段。

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cucnVub29iLmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAxNC8wMy9DRUJCNDlCQi1CMUFELTQ1MzktQUM3QS1CNDBEREM2MkQxQjIuanBn?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cucnVub29iLmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wOS9yZWdleHAtY24ucG5n?x-oss-process=image/format,png
[Link 1]: http://caibaojian.com/t/%E6%AD%A3%E5%88%99
[JavaScript]: http://caibaojian.com/t/javascript
[Link 2]: http://caibaojian.com/regexp-example.html
[JS]: http://caibaojian.com/phone-regexp.html
[Link 3]: http://so.caibaojian.com/cse/search?s=3469010351857949875&entry=1&q=%E6%AD%A3%E5%88%99
[JavaScript 1]: http://caibaojian.com/demo/javascript/regexp.html