正则表达式 基础认识分享

一.正则表达式 基础认识

1.是一套规则，主要是用来处理字符串

2.体会正则表达式的强大，正则是在查询字符串中效率是最高的一种方式

使用字符串处理方式的思路 把所有的字母全换成*
let str = "1a2b3c"
let arr = ['a', 'b', 'c']
for (let i = 0; i < arr.length; i++) {
   str = str.replace(arr[i], '*')
}
console.log(str) //1*2*3* 把所有的字母全替换成 *

使用正则表达式的思路 把所有的字母全换成 * 
//查找所有的字母，全部匹配g
str = str.replace(/[a-z]/g, '*')
console.log(str)

3.元字符 ：

\n :换行
\r :换行
换行符 ：Linux \n   MaxCOS(类Unix) \r  windows: \n\r

正斜杠： /   反斜杠 ：\ 有转义的含义
\d是转义d的意思
\d :数字的意思 0 - 9
\D :非数字
\s:空格
\S:非空格
\w:字符(数字，字母，_) 只表示一位，任意一个
\W:非字符(除了\w之外的所有东西)
. :小数点，匹配任意字符，但是不包括 \n,\r
\b:独立部分(单词边界，单词起始，结束，连词符(除了\w之外的都属于连词符))
\B:非独立部分

 let str = '1a2'
 //判断这个里面是否包含数字
 //创建一个正则对象 匹配任意的一个数字
 let reg = /\d/
 let res = reg.test(str)
 console.log(res)  //true 匹配成功 

4.量词 ：规定 / 控制 某个字符出现的次数 ，量词管辖前的一个字符就是某个字符 ，除外()

写法：{} 
量词的每种次数之间都是或者关系
{min , max}
{0,8} :最少出现0次，最多只能出现8次
所有的量词都是贪婪模式 都是从最高次开始

//特殊写法
{0,1} :最少出现0次，最多只能出现1次, 可有可无  简写为 ?    {0,1} === ?
{0,}  :最少出现0次，最多只能出现无限次 ，简称 0到正无穷,简写 *
{1,}  ：最少出现1次，最多只能出现无限次，简称1到正无穷 ，简写 +

let str = `123abc456`
//不要随便写空格 匹配数字，最少出现一次，最多出现无数次
let reg = /\d{1,}/
let res = reg.test(str)
console.log(res)  //true 匹配成功 


let str = `123abc456`
//表示匹配d字符 最少出现3次，最多出现10次
// 不写\就是代表字符本身
let reg = /d{3,10}/
let res = reg.test(str)
console.log(res)  //false 匹配成功 

let str = `123abcdd456`
//有两个d也是true 原因是匹配是一个字符一个字符的去匹配的
let reg = /d{0,1}/  两种写法等价  /d?/
let res = reg.test(str)
console.log(res)  //true 匹配成功 

5.标识符

g:global  全局匹配
i:ignore case  不区分大小写，忽略大小写
m:multiline  换行匹配 没有卵用
这三个标识符没有前后关系 需要谁就可以写谁 ，没有顺序

let str = `123abcdd456`
let reg = /A/igm
let res = reg.test(str)
console.log(res)  //true 匹配成功

6.起始符和结束符

起始符：^
结束符：$

let str = `123abcdd456`
//从最开始进行匹配 就是开头是 2 但是这个地方很明显 这个是以1开头的
//匹配的内容必须是字符串的起始
let reg = /^23/ig
let res = reg.test(str)
console.log(res)  //false 匹配成功 

let reg = /456$/ig
let res = reg.test(str)
console.log(res)  //true 匹配成功 

7.正则表达式里面涉及到的一些方法

1.reg.test(str) :匹配字符串是否符合正则表达式，符合返回true 不符合返回false  str源字符串
2.str.match(需要匹配的规则/子字符串)
这个是字符串方法，会返回一个数组，

//传子字符串
let str = `123cba456`
let reg = /456/
let res = str.match('123')
console.log(res)
//['123', index: 0, input: '123cba456', groups: undefined]
0: "123"
groups: undefined
index: 0
input: "123cba456"
length: 1
[[Prototype]]: Array(0)

//传正则表达式  正则没有标识符g :返回第一次匹配成功的结果，同时index属性返回下标，input返回目标字符串
let str = `123cba456`
let reg = /\d/
let res = str.match(reg)
console.log(res)
['1', index: 0, input: '123cba456', groups: undefined]0: "1"groups: undefinedindex: 0input: "123cba456"length: 1[[Prototype]]: Array(0)

//正则有标识符g，返回一个数组，数组里都是匹配成功的结果(字符串)，没有index和input
let str = `123cba456`
let reg = /\d\d/g   等价与  /\d{2}/  //全局匹配 两个连续的数字
let res = str.match(reg)
console.log(res)  //['12', '45']

//匹配不成功放回null
let str = `123cba456`
let reg = /0{2}/g
let res = str.match(reg)
console.log(res)  //null

3.str.replace(正则表达式,要替换的字符) ：也是一个字符串方法
str = str.replace(/[a-z]/g, '*')

8.贪婪和非贪婪匹配 ：有量词存在的时候才会有这个概念

贪婪匹配：直接写量词就是贪婪匹配，会优先从最高开始匹配
非贪婪匹配：就是在量词后加上问号? ，会优先从最少次数开始匹配

//贪婪匹配
let str = `123cba456`
let reg = /\w{1,3}/g
let res = str.match(reg)
console.log(res)  //['123', 'cba', '456']

//非贪婪匹配
let str = `123cba456`
let reg = /\w{1,3}?/g
let res = str.match(reg)
console.log(res)  //['1', '2', '3', 'c', 'b', 'a', '4', '5', '6']
//特殊 如果有0次匹配
let str = `123cba456`
let reg = /\w{0,3}?/g
let res = str.match(reg)
console.log(res)  //['', '', '', '', '', '', '', '', '', '']

9.() 子集 ：被括号括起来的属于一个整体，用子集后面都跟着量词

let str = 'ABabbabbb'
//有子集
let reg1 = /(ab)+/ig
//没有子集 + 是一个量词 最少出现一次 最多出现无限次
//量词只能管辖到前一个字符
let reg2 = /ab+/ig
let res1 = str.match(reg1)
let res2 = str.match(reg2)
console.log(res1)  //['ABab', 'ab'] 这个重复的是ab
console.log(res2)  // ['AB', 'abb', 'abbb']  这个每个重复的是b      

10.[] 范围词 ：里面的所有字符都是 或者关系，某个区间的字符，里面的每个字符之间都是或者关系，匹配里面的任意一个都可，只要包含其中一个即可

let str = "abcd4efd_gsah15dgsa_dgsha89gdjgABCDEFG_"
//a-z :之间所有的字符 任意一个
//量词匹配多少个字符？？？38 = 26 + 10 + 2
let reg = /[AZa-z0-9]+/g
let res = str.match(reg)
console.log(res)  //['abcd4efd', 'gsah15dgsa', 'dgsha89gdjgA']

二.正则进阶认识

1.非: 就是取反，在范围词里面加上一个^ 即可

匹配数字不是5的
let s = '0123456789'
//可以使用范围词
let reg = /[0-4][6-9]/
或者
不匹配5 除了5其他都要
let reg = /[^5]/g
let res = s.match(reg)
console.log(res) //['0','1','2','3','4','6','7','8','9']

加上一个量词匹配 2到无穷
let reg = /[^5]{2,}/g
let res = s.match(reg)
console.log(res) //['01234','6789']


let s = '2020-12-04 20:54:30'
要求把所有时间都切割
所以我们不要的符号是 - 空格 ： +是量词匹配 使用贪婪模式匹配，最多无穷次 最少一次 可以简写为 + 
let reg = /[^-\s:]+/g
let res = s.match(reg)
console.log(res) //['2020','12','04','20','54','30']

2.| 或者 ：和范围词的含义相同

区别范围词

let str = 'abdsadabtyebwaqi'
let reg = /a|b/g  匹配单个字符 a 或者 b  === /[ab]/
let res = str.match(reg)
console.log(res) // ['a','b','a','a','b','b','a'] 

let str = 'abbbbabbcbc'
需求：要连在一起的 ab 或者是 bc | 左边和右边是一个或者关系
let reg = /ab|bc/g 
let res = str.match(reg)
console.log(res) // ['ab','ab','bc','bc'] 

使用场景 关键词匹配
let str = '风屿真帅，风屿牛逼，666， 我爱你,I love you'
let reg = /风屿|牛逼|我爱你/
let res = str.match(reg)
console.log(res) // ['风屿','牛逼','我爱你'] 

3.匹配中文 \u4e00-\u9fa5 Unicode ASCII

let str = '风屿真帅666,I love you'
let reg = /[\u4e00-\u9fa5]/  中这个区间只能匹配中文
let res = str.match(reg)
console.log(res) // ['风','屿','真','帅'] 

4.断言：

匹配模式:
(?:模式) ：不捕获匹配
子集 ：默认为捕获匹配
let reg = /a(bc)d/  //abcd    
console.log(str.match(reg))  // ['abcd','bc',index:0...... ] 第一个值是 整个正则匹配的内容 第二个值是 子集的内容 

//把子集换非捕获匹配
let reg = /a(?:bc)(d)/  //abcd    
console.log(str.match(reg))  // 中间的(ac)子集是非捕获匹配，所以在数组中不会出现 bc子集  ['abcd','b',index:0...... ] 第一个值是 整个正则匹配的内容 第二个值是 子集的内容