正则表达式{简洁易懂}

为什么需要使用正则表达式？

正则可以实现模糊匹配，在实际开发中，往往需要匹配某一个范围的数据，比如：验证用户输入的邮箱是否正确；

除了@等固定的字符之外，输入的其他字符我们是无法估量和统计的，这个时候，精确匹配无能为力，只能使用模糊匹配；

创建正则表达式的方式：

在js中如果要使用正则，需要创建正则表达式对象。

1.构造函数：new RegExp("正则 常用的修饰符：

/i 忽略大小写  /g 全局匹配主体",[修饰符])

 2.字面量：/正则主体和/修饰符

正则对象的方法：

1.test：检测一个字符串是否匹配某一个规则。
	​ 返回值：匹配返回true，不匹配返回false。
let reg = /hello/g;
let str = "hello,hanmeimei,hello";
// let str = "hi,hanmeimei";
console.log(reg.test(str));

2.exec：捕获匹配到的内容
    ​ 0：匹配的文本
    ​ ndex：返回文本出现的位置
    ​ input：整行文本
let reg = /hello/g;
let str = "hello,hanmeimei,hello";
console.log(reg.exec(str));

两种模糊匹配

横向模糊匹配

1. 横向模糊匹配指的是，一个正则课匹配的字符串的长度不是固定的，可以是多种情况

2. 实现的方式是使用的量词，譬如{M,N},这个表示的就是最少出现的次数M次，最多出现的次数是N次；

案例：

let string = "abc abbc abbbc abbbbc abbbbbc abbbbbbc";
let regex = /ab{2,5}c/g.test(string);
//ab{2,5}c/表示匹配这样一个字符串：第一个字符是“a”
//接下来是2到5个字符“b”，最后是字符“c”。测试如下：
console.log(regex); // => ["abbc", "abbbc", "abbbbc", "abbbbbc"]

【注意】：上面代码中/ab{2,5}c/g多了一个它是正则的一个修饰符，g表示全局匹配，

纵向模糊匹配

1. 纵向模糊指的是，一个正则匹配的字符串，具体到某一位字符时，它可以不是某个确定的字符，可以有多种可能。

2. 其实现的方式是使用字符组。譬如[abc]，表示该字符是可以字符“a”、“b”、“c”中的任何一个。

案例:  

let string = "a0b a1b a2b a3b a4b";
let regex = /a[123]b/g.test(string);
console.log(regex); // => ["a1b", "a2b", "a3b"]

字符串中使用正则

match()

• 将字符串中与正则相匹配的内容捕获除了来

• 如果加上修饰符g，则一次性返回所有匹配的内容到数组中，如果不加则与exec的返回值一样

• 匹配失败，返回null

案例：

let str = "Lorem ipsum dolor sitip amet";
console.log(str.match(/ip/g));//返回的是ip，ip;

replace()

• 将一些字符替换成另一些字符

 案例：

let str = "Lorem ipsum dolor sitip amet";
//将ip修改成id
str = str.replace("ip","id");
console.log(str);//运行结果//Lorem idsum dolor sitip amet

split(字符/正则) 分割

案例:

let str = "Lorem ipsum dolor sitip amet";
//从ip的位置分割字符除串
let arr = str.split("ip")
// let arr = str.split(/ip/)
console.log(arr))//运行结果:'Lorem ', 'sum dolor sit', ' amet']

search:

• 找到符合条件的字符第一次出现的位置

案例：

let str = "Lorem ipsum dolor sitip amet";
//从上面字符串中找到IP的位置，下标
let index = str.search("ip")
// let index = str.search(/ip/)    console.log(index);//6

元字符

1. 元字符：组成正则的基本符号，有特殊的含义

2. "."通配符：匹配单个的任意字符

   • 【范围】匹配范围 匹配范围中任意一个

   • 【a-z】小写字母 【A-Z】大写字母 【0-9】任意数字

3. 【^范围】是【范围】的取反，匹配任意一个范围的字符。

常见的简写形式

• \d 匹配单个数字 相当于[0-9]
• \D 匹配单个非数字，相当于0-9;

let str = "1$"//true
let str = "111adasd1"//true
console.log(/\S/.test(str));
\d:匹配单个数字{相当于[0-9]},
//字符串中只要有一个数子就是为true
    

let str = "1asd$"//true
let str = "1111"//false
console.log(/\S/.test(str));
\D:匹配单个非数字，{相当于[^0-9]},
//如果为全是数字的话就是false，只要带一个非数字美就返回true；

• \w 匹配单个的数字，字母，下划线 相等于[a-zA-Z0-9_];
• \W 匹配单个非数字，非字母，非下划线 相当于 a-zA-Z0-9_

let str = "$"//false
let str = "1"//true
console.log(/\S/.test(str));
\w 匹配单个的数字，字母，下划线 相等于[a-zA-Z0-9_];
//如果是数字，下划线，字母只要不是特殊的字符就为true


let str = "$"//true
let str = "1 "//false
console.log(/\S/.test(str));
\W 匹配单个非数字，非字母，非下划线，相当于[^a-zA-Z0-9_]
//只要不是数字，字母，下划线，是特殊的字符就为true,是数字，字母，下划线就是false

• \s 匹配单个空白字符 空格 换行（\n），制表(\t)
• \S 匹配单个非空白字符

let str = "a";//为false
let str = "1 "//true
console.log(/\S/.test(str));
\s 匹配单个空白字符  空格 换行（\n），制表(\t)
//只要字符串中有空格换行 制表符就为true，不带这些的话都为false
                          
let str = "";//为false
let str = "1 "//true
console.log(/\S/.test(str));
\S 匹配单个非空白字符//只有什么都没写就为false，如果单个数字或者字母 符号加上空格就为true

限定元字符

1. 限定元字符：写在普通元字符或者字母的后面，修饰前面一个字符的出现次数

2. 量词：量词也称重复，掌握{m,n}的准确含义后，只需要记住一些简写的形式

常见的简写形式

{m}

{m}表示至少出现m次；//相当于{m，m}
let pattern = /ab/,
str = 'ab aabb aaabbbbbbbaaa';
 console.log(pattern.test(str)); //ab ab ab ab

{m,}

{m,}没有上限，至少匹配m次；
let pattern = /ab{2,}/,
    //表示a出现一次 b出现没有上限
str = 'ab aabb aaabbbbbbbaaa';
console.log(pattern.test(str));//ab abbbbb

{m,n}

{m,n} 至少匹配m次，最多匹配n次。
let pattern = /ab{2,4}/,
    //表示a出现一次，b最多出现4次
	str = 'ab aabb aaabbbbbaaa';
console.log(pattern.test(str));//结果为abb abbbb

?

 ? 等价于{0,1} 要么不出现，要么出现一次。
 let  pattern = /ab?/,
     //要么不出现，要么出现一次。
 str = 'ab aabb aaabbbbbbcc';
 console.log(pattern.test(str));//运行结果ab a ab

*

* 等价于{0,} 匹配任意次（包含零次）。
let pattern = /ab*/,
    //匹配任意次（包含零次）。
    str = 'ab aabb aaabbbbbbcc';
console.log(pattern.test(str));

+

 + 等价于{1,} 至少出现一次。
 let pattern = /ab*/,
     //至少出现一次
     str = 'ab aabb aaabbbbbbcc';
console.log(pattern.test(str));

【注意】：

               如果需要修饰多个字符的出现次数，用（）包裹起来。

行首行尾限定符

【注意】：行首行尾一起使用，表示字符必须匹配中间的规则才可以。

^行首匹配 必须以后面的字符开头

//行首必须事ccb开始的
let pattern = /^ccb/,
    str = 'ccbcc';
console.log(pattern.test(str));

$行尾匹配 必须以前面的字符结尾

//行首行尾一起使用，表示字符必须匹配中间的规则才可以
var pattern = /^ccb$/,
    str = 'ccb';
console.log(pattern.test(str));

贪婪和非贪婪

贪婪：

1. 当一个字符串用正则匹配时，会尽可能多的去匹配。正则弄人的就是贪婪模式

//其中正则/\d{2,5}/，表示数字连续出现2到5次。会匹配2位、3位、4位、5位连续数字。

//但是其是贪婪的，它会尽可能多的匹配。你能给我6个，我就要5个。你能给我3个，我就3要个。反正只要在能力范围内，越多越好。
var string = "123 1234 12345 123456";
var regex = /\d{2,5}/g.test(string);
console.log(regex); // => ["123", "1234", "12345", "12345"]

非贪婪：

1. 当一个字符串使用正则匹配时，会尽可能少的去匹配。

   写限定符时，在后面加一个？即可；

 通过在量词后面加个问号就能实现惰性匹配，因此所有惰性匹配情形如下：

var string = "123 1234 12345 123456";
//其中/\d{2,5}?/表示，虽然2到5次都行，当2个就够的时候，就不在往下尝试了。
var regex = /\d{2,5}?/g;
console.log( string.match(regex) ); // => ["12", "12", "34", "12", "34", "12", "34", "56"]

 通过在量词后面加个问号就能实现惰性匹配，因此所有惰性匹配情形如下：

{m,n}?
{m,}?\
*??
+?
*?