学习练习使用正则表达式

正则表达式(Regular Expression)是一种文本模式，使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。它繁琐也强大，几乎所有所有编程语言都支持利用正则表达式进行字符串操作。

语法

元字符： 

w[-w.+]*@([A-Za-z0-9][-A-Za-z0-9]+.)+[A-Za-z]{2,14}

字符	描述
d	匹配一个数字字符。等价于 [0-9]。【Digital】
D	匹配一个非数字字符。等价于 [^0-9]。
w	匹配字母，数字，下划线。等价于[A-Za-z0-9]。【Word】
W	匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]
s	匹配任何空白字符，包括空格，制表符，换页符。
S	匹配任何非空白字符。等价于 [^ f v]
.	匹配除换行符（ 、 ）之外的任何单个字符。要匹配包括 ' ' 在内的任何字符，请使用像"(.
f	匹配一个换页符
	匹配一个换行符
	匹配一个回车符
	匹配一个制表符
v	匹配一个垂直制表符
^	匹配输入字符串开始的位置。
$	匹配输入字符串结尾的位置。
	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
B	与  相反：erB' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
	以上为常见的元字符，可以常练些简单的匹配

 

区间(表示方法为中括号[])

[-w.+] 区间，表示 匹配符号 -，或字母、数字、下划线，或符号 . ，或符号 +

字符	描述
[0-9]	匹配 0-9 之间的数字
[A-Z]	匹配 A-Z 之间的字母，也可以组合 [A-Za-z0-9]

 

限定符

* 表示出现，匹配前面的子表达式零次或多次。

字符	描述
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}
+	匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}
?	匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 、 "does" 中的 "does" 、 "doxy" 中的 "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?'。请注意在逗号和两个数之间不能有空格
	有了区间，限定符，结合元字符，可以进行编写正则

普通字符 和 转义

w[-w.+]*@([A-Za-z0-9][-A-Za-z0-9]+.)+[A-Za-z]{2,14}

@ 是普通字符，标识必定会出现的内容。

但由于符号 /、.、(、) 等等在正则是特殊字符，所以需要用转义符  转义

https://baidu.com

子表达式--用圆括号()组成

用圆括号组成一个比较复杂的匹配模式，那么一个圆括号的部分我们可以看作是一个子表达式。

举例 var reg=/(d)([a-z]*)/gi

• (d)      就是 第一个子表达式
• ([a-z])  就是 第二个子表达式

捕获 & 反捕获---针对的是子表达式(圆括号的) ，而反捕获只是加？

多个子表达式所匹配到的内容，按照顺序出现在内存的缓冲区中捕获数组。这个我们称为捕获

举例 var reg=/(d)([a-z]*)/gi 匹配 1adkk

用js代码验证下：/(d)([a-z]*)/gi

<script>
    var str = '1adkk';
    var reg=/(d)([a-z]*)/gi
    if(reg.test(str)) {
                console.log( RegExp.$1 );
                console.log( RegExp.$2 );
                console.log( RegExp.$3 );
    }
</script>

输出结果：
1               index.html:16
adkk          index.html:17 
                 index.html:18 

输出结果：

1               index.html:16
adkk          index.html:17 
                 index.html:18 

反捕获 与 捕获相反，标记不需要捕获的内容。

用js代码验证下：/(?:d)([a-z]*)/gi

<script>
    var str = '1adkk';
    var reg=/(?:d)([a-z]*)/gi    if(reg.test(str)) {
                console.log( RegExp.$1 );
                console.log( RegExp.$2 );
                console.log( RegExp.$3 );
    }
</script>

输出结果：
adkk         index.html:16
                index.html:17 
                index.html:18 

反向引用

圆括号的内容被捕获后，可以在这个括号后被使用，从而写出一个比较实用的匹配模式，这个我们称为反向引用。

var str="1adkk"        var reg=/(d)([a-z])/gi

1.把 (d)匹配到的结果 1 放入缓存区 => 引用 $1

2.把 ([a-z])匹配的内容 a 放入缓存区 => 引用 $2

用js代码验证下：

    var str = '1adkk';
    var reg = /(d)([a-z]*)/gi;

    var result = str.replace(reg, "$2$2");
    console.log(result);
    
输出结果：  
    adkkadkk

贪婪

贪婪匹配：当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符，这匹配方式叫做贪婪匹配。

举个例子：

    var str = '1adkk adkkk adkkkk';
    var reg = /([a-z]){4,6}/gi;

    var result = str.match(reg);
    console.log(result);
    
输出结果：  
    0: "adkk"
    1: "adkkk"
    2: "adkkkk"

由结果得知：“1adkk adkkk adkkkk”这一段，其实只需要出现4个字母就匹配成功，但是它并不满足，而是匹配到了最大能匹配的字符，也就是6个。 一个量词就如此贪婪

 

懒惰 / 非贪婪

当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能少的字符，这匹配方式叫做懒惰匹配。

代码	说明
*?	重复多次，但尽可能少重复
+?	重复1次、多次，但尽可能少重复
??	重复0次、1次，但尽可能少重复
{n,m}?	重复n~m次，但尽可能少重复
{n,}?	重复n次以上，但尽可能少重复

    var str = '1adkk adkkk adkkkk';
    var reg = /(w{3,4}?)/gi;

    var result = str.match(reg);
    console.log(result);

输出结果：
    0: "1ad"
    1: "adk"
    2: "adk"
    3: "kkk"