正则表达式RegExp

作用：

1. 匹配特殊字符或有特殊搭配原则的字符的最佳选择（就是看字符串是不是想要的样子，比如aabb式）
2. 校验输入的内容是否符合格式要求

创建方式

直接量

• 1

var reg = /abc/;
//匹配的规则为abc
var str = "abcd"
console.log(reg.test(str))	

• 2

var reg = /abce/;
var str = "abcd"
console.log(reg.test(str))

• 3

var reg = /abce/;
var str = "abcde"
console.log(reg.test(str))

new RegExp()

var reg = new RegExp("abc");
var str = "abcd";
console.log(reg.test(str))

和上面的那一种差不多

区别

var reg = /abc/;
var reg1 = new RegExp(reg);

正则表达式中new后面的不仅能放字符串，还能放已知的正则表达式
这时候reg与reg1是两个不同的表达式

var reg = /abc/;
var reg1 = new RegExp(reg);

这样reg1与reg则为同一个

属性

i(ignoreCase 忽略大小写)

var reg = /abc/i;
var str = "ABCD"
console.log(reg.test(str))

g（全局匹配）

var reg = /ab/;
var str = "ababab";
console.log(str.match(reg));

str.match(reg)意思是str里面所有的和reg一样的文本都会被匹配，并生成数组
_{这里还没加g}

var reg/ab/g;
var str = "abcabcabcd"
console.log(str.match(reg))

m（多行文本匹配）

var reg = /^a/;//这是只匹配在开头的a
var str = "bcd\na;// \n表示换行
console.log(str)
console.log(str.match(reg))

str.match(reg)默认只会匹配单行，也就是第一行第二行的a虽然满足是开头的要求，但不会被匹配，所以就有了多行匹配这种东西

var reg = /^a/m;
var str = "bcd\na;
console.log(str)
console.log(str.match(reg))

tip

三个属性可以写在一起，不分先后顺序，下面这几种一样（两个也行）

var reg = /abc/img;
var reg = /abc/mig;
var reg = /abc/igm;
var reg = /abc/gim;
var reg = /abc/mgi;
var reg = /abc/gmi;

语法

表达式

表达式	描述
[abc]	查找方括号之间的任何字符。
[0-9]	查找任何从 0 至 9 的数字。
[^abc]	查找任何不在方括号之间的字符。
(red|blue|green)	查找任何指定选项。

• 匹配三个数值相连的字符串

var reg = /[1234567890][1234567890][1234567890]/m;
var str = "oasduif897asdohf12";
console.log(str.match(reg));

这里的意思大概就是连续三个字符，第一个要在第一个中括号里，第二个要在第二个中括号里，第三个要在第三个中括号里

var reg = /123/m只能匹配123，不能匹配其他三个连续的数字

• 第一种要在中括号里写上所有要匹配的字符，数字还好说，就10个，我要是相匹配字母怎么办？敲26个？再加上大写的话就52个？这么累的活我才懒得干，让电脑做不行吗？当然可以。
  比如数字可以直接写[0-9]，英文字母也可以写[a-z]，[A-Z]
  不仅如此，我还可以更懒（怎么感觉懒才是促进人类发展的动力），大小写字母我可以只写[A-z]
  这里是按照ASCII表来排序的，只要连着，直接写范围就行了
  那问题就来了，我要是想用两段范围怎么办呢？

  var reg = /0-9A-z/
  

  那就写两段呗
• ^在表达式里面的意思和js中的!差不多，表示“非”
• (red|blue|green)这里小括号里面也是范围，只是中括号变成了小括号，意思是匹配的字符是red或blue或green

  var reg = /(red|blue)[0-9]/
  //表示匹配出来的值只能是red加一个数字或blue加一个数字
  

元字符

（简单来说就是更加风骚的表达式）
不用加中括号直接写的东西

// \w ===[0-9A-z_]
// \W ===[^\w]小写w的补集
var reg = /\w/g;

元字符	描述	意义
.	查找单个字符，除了换行和行结束符。	[^\r\n]
\w	查找单词字符。	[0-9A-z]
\W	查找非单词字符。	除了[0-9A-z]之外的
\d	查找数字。	[0-9]
\D	查找非数字。	除了[0-9A-z]之外的
\s	查找空白字符。	空白符 制表符(\t) 回车符(\r) 换行符(\n) 垂直换行符(\v) 换页符(\f)
\S	查找非空白字符。	除了\s之外的
\b	匹配单词边界。	(⊙﹏⊙)看下面的自己意会
\B	匹配非单词边界。	除了\b之外的
\uxxxx	查找以十六进制数 xxxx 规定的 Unicode 字符。	就是用Unicode编码去匹配字符

• 意会\b的看这里

  var reg = /c\b/g;  //查找是单词后边界的c
  var str = "abc def ghi"
  

  这样可以找到c👆

  var reg = /c\b/g;
  var str = "acb def ghi"
  

  这样就找不到👆

• 一个表达式可以同时写多个元字符

• 表达式中的空格有意义，就表示一个空格

• Unicode可以匹配一切字符

• 匹配一切字符的话可以var reg = /[\s\S]/

量词

var reg = /\w+/g;
var str = "abc"

这里的+表示\w重复1次到多次

符号	描述
n+	匹配任何包含至少一个n的字符串。
n*	匹配任何包含0个或多个n的字符串。
n?	匹配任何包含0个或1个n的字符串。
n{X}	匹配任何包含X个n的序列的字符串。
n{X,Y}	匹配任何包含X个至Y个n的序列的字符串。
n{X, }	匹配任何包含至少X个n的序列的字符串。
n$	匹配任何结尾为n的字符串。
^n	匹配任何开头为n的字符串。
?=n	匹配任何其后紧接指定字符串n的字符串。
?!n	匹配任何其后没有紧接指定字符串n的字符串。

查找后面跟了一个 b 的 a

var str = "abaaa";
var reg = /a(?=b)/g;

查找后面不跟 b 的 a

var str = "abaaa";
var reg = /a(?!b)/g;

方法

RegExp对象属性

属性	描述
global	RegExp对象是否具有标志 g。
ignoreCase	RegExp对象是否具有标志 i。
multiline	RegExp对象是否具有标志 m。
lastIndex	一个整数，标志开始下一次匹配的字符位置。

var reg = /ab/g;
var str = "abababab"
console.log(reg.global);

lastIndex看RegExp对象方法

RegExp对象方法

方法	描述
exec	检索字符串中指定的值，返回一个数组（未匹配到则返回 null）。
test	检索字符串中指定的值，它返回 true 或 false。

这是exec的例子👇

var reg = /ab/g;
var str = "abababab"

在控制台上执行reg.exec(str)

index表示游标位置，
第一次游标在第一个字母前（即index为0），匹配到一个ab，
第二次游标在第二个字母与第三个字母之间（即index为2），匹配到一个ab，
第三次游标在第四个字母与第五个字母之间（即index为4），匹配到一个ab，
第四次游标在第六个字母与第七个字母之间（即index为6），匹配到一个ab，
第五次游标在第八个后（即index为8），匹配不到值，返回null，
再次匹配又会回到第0位，重新再来。

这里reg中必须加 g ，不然始终从index = 0开始匹配

上面提到的lastIndex属性就是指这里说的游标位置

既然游标的位置是一个属性，那么我们就可以给他改

String对象方法

方法	描述
match	找到一个或多个正则表达式的匹配，返回一个数组，在未匹配到时会返回 null。
search	检索与正则表达式相匹配的值，返回匹配到的位置索引，或者在失败时返回-1。
replace	替换与正则表达式匹配的子串。
split	把字符串分割为字符串数组。

• match
  如果想匹配一个XXXX形式（比如：aaaa）的值，可以这样写

var reg = /(\w)\1\1\1/g;
var str = "aaaa";

或者一个AABB式

var reg = /(\w)\1(\w)\2/g;
var str = "aabb";

这里 ( ) 里面表示一个子表达式，后面的\1表示和第一个子表达式一样，\2表示和第二个子表达式一样

如果这时候再用exec方法来显示的话会变成

而使用match方法的话

var reg = /(\w)\1(\w)\2/;
var str = "aabb";

（reg后面没写 g ）
这样和exec（reg后面有 g）方法显示一样
但是如果这里加上 g，他就翻脸了

花里胡哨的子表达式什么的都没了

• search

var reg = /abc/g;
var str = "qweabc";
console.log(str.search(reg));

如果没匹配到则显示 -1

• replace
  不用正则表达式时

var str = "aa";
console.log(str.replace("a","A"));

在非正则表达式时不能全局匹配替换，只能替换掉第一个
使用reg后才能替换掉全部的（别忘了reg后面加个g）

var reg = /a/g
var str = "aa";
console.log(str.replace(reg,"A"));

这里再玩个好玩的
把aabb替换为bbaa

var reg = /(\W)\1(\W)\2/g;
var str = "恍恍惚惚";
console.log(str.replace(reg, "$2$2$1$1"));

$ 和reg里面的 \1 的 \ 差不多是同一个意思，都是指子表达式，$1 就是指第一个 (\W)
这里还可以玩的更加花里胡哨

var reg = /(\W)\1(\W)\2/g;
var str = "恍恍惚惚";
console.log(str.replace(reg, function($, $1, $2) {
    return $2 + $2 + $1 + $1
}));

系统会自动把正则表达式匹配到的东西作为参数传到function中，这里的 $ , $1 , $2 可以随意起名，我用 $ 仅仅是为了好理解一些

贪婪匹配

人心都是贪婪的，正则表达式也是如此。
贪婪匹配是指在整个表达式匹配成功的前提下，尽可能多的匹配，
非贪婪匹配相反，是尽可能少的匹配
默认情况下都是使用贪婪匹配原则，如果要使用非贪婪匹配，在后面加 ? 即可

• 贪婪匹配

var reg = /a+/;
var str = "aaaaaa";
console.log(reg.exec(str))

• 非贪婪匹配

var reg = /a+?/;
var str = "aaaaaa";
console.log(reg.exec(str))

字符串去重

var reg = /(\w)\1*/g;
var str = "aaaaaabbbbbbbbbbbbccccccc";
console.log(str.replace(reg, "$1"))