瑞士军刀---正则表达式

摘要：简介正则表达式，又称正规表示法正规表达式规则表达式常规表示法英语，在代码中常简写为或，计算机科学的一个概念。返回布尔值，该值指示在正则表达式中使用的标志的状态。包含正则表达式模式和适用标志的对象的实例。

正则表达式，又称正规表示法、正规表达式、规则表达式、常规表示法（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在很多文本编辑器里，正则表达式通常被用来检索、替换那些符合某个模式的文本。

说人话就是：对字符串执行模式匹配的强大工具。

Javascript中的正则表达式相较于其他语言来说实现的并不完整，但仍然是十分强大的，能够帮助我们完成绝大多数模式匹配任务。

在javascript中，正则表达式的定义和数组以及对象的定义一样有俩种方式。 一种是直接量，另一种是构造函数。

Javascript可以使用类似Perl的语法定义一个正则表达式

var r = /pattern/flags;

其中pattern是任何简单或复杂的正则表达式，flags是用以表达正则表达式行为的一个或者多个标识。

flags

g 表示全局(global)模式，即模式将被应用于所有字符串

i 表示不区分大小写

m 多行模式

举个栗子：

var reg1 = /ip/g; // 匹配字符串中所有"ip"的实例

var reg2 = /com/gi; // 匹配以"com"结尾的三个字符的组合，不区分大小写

Javascript中正则表达式的构造函数为RegExp，即Regular Expression的缩写，它接收两个参数，第一个为要匹配的字符串模式，另一个是可选的标识位。

var reg = new RegExp("nice", "g"); // 匹配字符串中所有的"nice"

注意：第一个参数是一个字符串nice，而不是正则表达式的直接量/nice/。

双重转义

所有元字符都需要进行双重转义

所有元字符都需要进行双重转义

所有元字符都需要进行双重转义

使用构造函数定义正则表达式，由于构造函数的第一个参数必须是一个字符串，在匹配元字符时，需要双重转义。

//  匹配{user}
var reg1 = new RegExp("{user}", "g"); // wrong

// 由于在字符串中需要转义为，所以，如果要匹配{user}，正则表达式需要写为
var reg1 = new RegExp("{user}", "g");

在正则表达式的模式中，有一些字符是有特殊含义的，被称为元字符，如果要匹配元字符，则必须对其进行转义，如果用构造函数，则要进行双重转义。

这些元字符分别是(一共14个)：

{ ( [   ^ $ |  ? * + . ] ) }

| 字符 | 匹配 |
| ------------- |:-------------:|
|字母数字字符|自身|
| |查找 NUL 字符。|
| |查找换行符。|
|f |查找换页符。|
| |查找回车符。|
| |查找制表符。|
|v |查找垂直制表符。|
|xxx |查找以八进制数 xxx 规定的字符。|
|xdd |查找以十六进制数 dd 规定的字符。|
|uxxxx |查找以十六进制数 xxxx 规定的 Unicode 字符。|

不管一个直接量字符字符代表何种含义，单个字符始终只匹配单个字符

| 字符 |等价于| 匹配 |
| ------------- |:-------------:| :-------------:|
| . | ¹|查找单个字符，除了换行和行结束符。 |
| w| [a-zA-Z_0-9]|任意ASCII单字字符，等价于[a-zA-Z0-9_]|
| W| ² |查找非单词字符。 |
|d |[0-9]|查找数字。|
|D |³|查找非数字字符。|
|s |[ x0Bf ]|查找空白字符。|
|S |⁴|查找非空白字符。|
|[]||来表示单个字符有或的关系，如/[bc]/，匹配b或者c|
|^||来表示不匹配后面跟着的字符，如/⁵，/不匹配b或c|
|-||来表示一个范围，如/[a-z]/，匹配a-z的字母，可以和负向类结合/^0-9/|
|组合类：||以上几种类组合而成的字符类，如/a-z0-9 /，匹配a-z的字母或者0-9的数字或者换行符|

注意：在javascript类不能嵌套，就是不支持联合类和交叉类，/a-m[p-z]/和/a-m⁶/在JavaScript中是非法的

| 字符 | 含义|
| ------------- |:-------------:|
| ^ | 匹配字符串的开头，在多行检索中，匹配一行的开头|
| $| 匹配字符串的结尾，在多行检索中，匹配一行的结尾|
| |匹配单词边界。|
|B |匹配非单词边界。|

| 常用量词 | {m,n}等价形式|描述 |
| ------------- |:-------------:| :-------------:|
|？|{0,1}|最多出现1次,例如，do(es)? 匹配 do 或 does 中的 do|
|* |{0,}|可能出现，也可能不出现，出现次数无上限，例如，zo* 匹配 z 和 zoo。|
|+ |{1,}|最少出现1次,例如，zo+ 匹配 zo 和 zoo，但不匹配 z|

在正则表达式概念中，称 +、*、？为常用量词，称{n,m}形式的为通用量词。

**？的使用
**
情景：美式应用和英式语言的单词写法不同，比如traveler和traveller.

var str1 = "traveler";
var str2 = "traveller";
var pattern = /travell?er/;
console.log(pattern.test(str1));
console.log(str2.search(str2));

结果打印：
true
0

匹配各类标签（前端应用）

匹配所以tag: /<⁷+>/

匹配open tag: /<⁸⁷*>/

匹配close tag: /7+>/

匹配self-closing tag: /⁹+/>/

贪婪量词：先匹配整个字符串，如果不匹配则去掉最后一个字符再匹配，直到没有任何字符。它是从后向前匹配。所有简单量词都是贪婪的。

惰性量词：和贪婪量词相反，即先匹配第一个字符，不匹配则匹配第一第二个字符，直到最后整个字符串。所有简单量词后面加?就是惰性的了。

支配量词：只匹配整个字符串一次，不匹配就结束，也称最懒量词，所有简单量词后面加+就是支配的了，但是javascript不支持，所以它连出场的机会也没有了。。

举个栗子（complex-quantifiers.js）：

var re1 = /.*bbb/g;        //  定义贪婪量词
var re2 = /.*?bbb/g;    //  定义简单惰性
//  var re3 = /.*+bbb/g;//支配性,javascript不支持，nodejs报错
var  str="abbbaabbbaaabbb1234";

console.log(re1.test(str));  //true
console.log(re1.exec(str));  //null
console.log(str.match(re1));  //abbbaabbbaaabbbb

console.log(re2.test(str));  //true
console.log(re2.exec(str));  //aabbb
console.log(str.match(re2)); //abbb,aabbb,aaabbb

贪婪模式详解

到目前为止，我们只能一个字符到匹配，虽然量词的出现，能帮助我们处理一排密紧密相连的同类型字符。但这是不够的，下面该轮到小括号出场了，中括号表示范围内选择，大括号表示重复次数。小括号允许我们重复多个字符。

举个栗子（group.js）：

//分组+量词
console.log(/(dog){2}/.test("dogdog"))//true
//分组+范围
console.log("baddad".match(/([bd]ad?)*/))//baddad,dad
//分组+分组
console.log("mon and dad".match(/(mon( and dad)?)/))//mon and dad,mon and dad, and dad

|优先级| 符号|说明|
| ------------- |:-------------:| :-------------:|
|最高 ||转义符|
|高 |( )、(?: )、(?= )、[ ]|单元和字符类|
|中 |*、+、?、{n}、{n,}、{m,n}|量词|
|低 |^、$、任何元字符、任何字符|描点|
|最低|||替换，选择|

参考加减乘除，先算括号内的记忆方式

global 属性 | ignoreCase 属性 | multiline 属性 | source 属性

global: 返回布尔值，该值指示使用正则表达式的 global 标志 (g) 的状态。 默认值为 false。 只读。

ignoreCase: 返回布尔值，该值指示在正则表达式中使用的 ignoreCase 标志 (i) 的状态。 默认值为 false。 只读。

multiline: 返回布尔值，该值指示在正则表达式中使用的 multiline 标志 (m) 的状态。 默认值为 false。 只读。

source: 返回正则表达式模式的文本的一个副本。 只读。

lastIndex: 如果使用了全局模式，这个变量保存的是字符串中尝试下次匹配的偏移值。在exec和test中都会用到这个变量。 可写

RegExp 对象有 3 个方法：test()、exec() 以及 compile()

RegExp.test(string)

test 方法检查字符串中是否存在某种模式，如果存在，则返回 true，否则返回 false。test 方法不修改全局 RegExp 对象的属性。

语法：

rgExp.test(str) 

//  参数
rgExp 必需。 包含正则表达式模式和适用标志的 Regular Expression 对象的实例。
str 必需。 将对其执行搜索的字符串。

栗子：

var str = "huangge is an handsome man";

var reg1 = new RegExp( "handsome", "g" );
var result = reg1.test(str);
console.log("huangge is an handsome man: " + result);

RegExp.exec(string)

exec 方法使用正则表达式模式对字符串执行需找匹配，如果成功，则返回表示匹配信息的数组，否则返回null。默认情况下，它返回第一次匹配的结果

语法：

rgExp.exec(str) 

//  参数
rgExp 必需。 包含正则表达式模式和适用标志的 Regular Expression 对象的实例。
str 必需。 对其执行搜索的 String 对象或字符串文本。

返回值

如果成功匹配，exec 方法返回一个数组，并且更新正则表达式对象的属性。返回的数组包括匹配的字符串作为第一个元素，紧接着一个元素对应一个成功匹配被捕获的字符串的捕获括号（capturing parenthesis）。

如果匹配失败，exec 方法将返回 null。

栗子（regexp-exec.js）：

var reg= /d{4}-d{2}-d{2}/g;
var str = "aaa2015-08-11aaaaaabbss2015-08-22bbb";
var result = reg.exec(str);
console.log(result);


结果如下：

[ "2015-08-11",
  index: 3,
  input: "aaa2015-08-11aaaaaabbss2015-08-22bbb" ]

RegExp.compile(string)

将正则表达式编译为内部格式，从而更快地执行。

语法：

rgExp.compile(pattern, [flags]) 

//  参数
rgExp 必需。 Regular Expression 对象的一个实例。 可以是变量名或文本。
pattern 必需。 一个字符串表达式，包含要编译的正则表达式模式
flags 可选。 可以组合使用的可用标志有：
    g（全局搜索出现的所有模式）
    i（忽略大小写）
    m（多行搜索）

compile 方法将 pattern 转换为内部的格式，从而执行得更快。 例如，这允许在循环中更有效地使用正则表达式。 当重复使用相同的表达式时，编译过的正则表达式使执行加速。 然而，如果正则表达式发生更改，则这种编译毫无益处。

String.match(RegExp)

这个方法类似RegExp.exec(string),只是调换了RegExp和string的位置。 另一个区别就是，无论是否指定全局，RegExp.exec(string)只是返回单词匹配结果。 而string.match()会返回一个字符串数组，其中包含了各次匹配成功的文本

举个栗子(string-match.js)：

var reg= /d{4}-d{2}-d{2}/g;
var str = "aaa2015-08-11aaaaaabbss2015-08-22bbb";
var result = str.match(reg);
console.log(result);

打印的结果为：

[ "2015-08-11", "2015-08-22" ]

String.search(RegEexp)

这个用来寻找某个正则表达式在字符串第一次匹配成功的位置，如果不成功，则返回-1

举个栗子(string-search.js)：

var str1 = "sssssaa111";
var str2 = "sssssaaaaa";

var pattern = /d/;
console.log ("st1  " + str1.search(pattern));
console.log ("st2  " + str2.search(pattern));

打印的结果为：

st1  7
st2  -1

String.replace（RegExp,replacement）

这个方法用来正则表达式替换。 将匹配到的文本替换为replacement。默认情况替换一次。如果设定了全局模式，则所有能匹配的文本都会替换。
举个栗子(string-replace.js)：

var reg = /d{4}-d{2}-d{2}/;
var str = "2015-08-11 2015-08-22";

console.log(str.replace(reg, "Date:"));

打印的结果为：

ate: 2015-08-22

String.split（RegExp [,limit]）

这个方法使用一个正则表达式切分字符串，正则表达式是否使用全局对结果没有影响
举个栗子(string-split.js)：

var str = "one two  three    four";
var pattern = /s+/;
console.log(str.split(pattern))

打印的结果为：

[ "one", "two", "three", "four" ]

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

匹配双字节字符(包括汉字在内)：¹⁰
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

匹配空白行的正则表达式： s*

匹配HTML标记的正则表达式：<(S?)⁷>.?|<.? />

匹配首尾空白字符的正则表达式：^s|s$

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

匹配网址URL的正则表达式：[a-zA-z]+://¹¹*

匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^a-zA-Z{4,15}$

匹配国内电话号码：d{3}-d{8}|d{4}-d{7}

匹配腾讯QQ号：1-9{4,}

匹配中国邮政编码：[1-9]d{5}(?!d)

匹配身份证：d{15}|d{18}

匹配ip地址：d+.d+.d+.d+

^[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个英文字母或者下划线组成的字符串

↩

a-zA-Z_0-9 ↩

0-9 ↩

x0Bf ↩

bc ↩

b-e ↩

> ↩

/> ↩

>/ ↩

x00-xff ↩

s ↩