本日我们来说一下正则表达式的基础应用
正则表达式的润饰符
i 实行对大小写不敏感的婚配
let a = 'hEllo World' let reg = /hello/i console.log(reg.test(a)) // true let str = 'hello' let reg1 = /Hello/i console.log(reg1.test(str)) // true let str1 = 'hello' let reg2 = /Hello/ console.log(reg2.test(str1)) // false上面的第一个例子字符串a带有大写英文，而我们的婚配体式格局则为悉数小写，我们会获得true，第二个例子str字符串悉数为小写，而婚配体式格局则为大小写夹杂也是获得true，第三个则是不应用润饰符i的，获得为false，所以i是对大小写不敏感的
g 实行全局婚配（查找一切婚配而非在找到第一个婚配后住手）
let a = 'hello hello hello hello' let reg = /hello/g console.log(a.replace(reg, '*')) // * * * * let a1 = 'hello Hello hello Hello' let reg1 = /Hello/g console.log(a1.replace(reg1, '*')) // hello * hello * let a2 = 'hello Hello hello Hello' let reg2 = /Hello/gi console.log(a2.replace(reg2, '*')) let a3 = 'hello _Hello hello Hello' let reg3 = /Hello/gi console.log(a3.replace(reg3, '*'))* _* * *关于g全局的婚配，我关于它的明白就是能找到的都能够，只需相符的行，看上面的四个例子，最重如果看末了一个一个例子不论是不是是一体只需相符你的划定规矩就能够
m 多行婚配
let a = 'hello\n hello hello hello' let reg = /hello/m console.log(a.replace(reg, '*')) // * hello hello hello let a1 = 'hello Hello\n hello Hello' let reg1 = /Hello/m console.log(a1.replace(reg1, '*')) // hello * hello hello let a1 = 'hello hello\n hello Hello' let reg1 = /Hello/m console.log(a1.replace(reg1, '*')) //hello hello hello *
经由过程上面的两个例子，我们已晓得m润饰符也算是查找全局的润饰符然则它婚配到一个就不会再举行婚配了
es6新增润饰y,又叫做粘连润饰符，和g润饰符相似也是全局婚配
let str = "anta" let y = /a/y console.log(str.replace(y, "&")) // &nta console.log(str.replace(y, "&")) // anta let str = "aanta" let y = /a/y console.log(str.replace(y, "&")) //&anta console.log(str.replace(y, "&")) //a&nta console.log(str.replace(y, "&")) //aanta上面第一个例子应用了y润饰符，第一次实行我们婚配到了a替代胜利，第二次的时刻没有值被婚配到，这是由于y润饰符婚配到一次后，会接着当前婚配到位置的下一个位置最先，所以在第一次替代的时刻位置为0，第二次婚配的时刻位置则变为了1，y润饰符是具有位置属性的位置婚配，下面我们就来看一下
let str = "aanta" let y = /a/y y.lastIndex = 4 console.log(str.replace(y, "&")) // aant& y.lastIndex = 1 console.log(str.replace(y, "&")) // a&nta上面的两个例子则是应用了位置，我们能够看到应用位置以后，会打乱y润饰符原有的粘连体式格局，会直接依据我们划定的位置1婚配
let str = "aanta" let y = /a/gy console.log(str.replace(y, "&")) // &&nta上面的例子是g和y润饰符合营应用，会获得我们意想不到的效果，由于它会依据粘连划定规矩磨练
RegExp.prototype.sticky 属性磨练是不是设置了y润饰符
let y1 = /a/y console.log(y1.sticky) // true let y = /a/gy console.log(y.sticky) // trueRegExp.prototype.flags 属性返回设置的润饰符
let y1 = /^a/y console.log(y1.flags) // y let y = /a/gy console.log(y.flags) // gyes6 新增润饰符s 标记.婚配一切字符
let str = "aa\nnta" let reg = /a.n/s console.log(reg.test(str)，reg.dotAll) // true true let str = "aa\nnta" let reg = /a.n/ console.log(reg.test(str)，reg.dotAll) // false false润饰符s婚配换行符n,我们会获得true，假如不必s润饰符的话会婚配不到的，上面的例子中都有检测是不是存在dotAll形式中，说白了重要就是看你有无润饰符s
正则表达式形式
[] 婚配中括号内划定规矩的字符
let str = "hello world" let reg = /[a-z]/ console.log(reg.test(str)) // true let str = "hello world" let reg = /[a-h]/g console.log(str.replace(reg, '*')) // **llo worl* let str = "he1l3 wo4ld" let reg = /[0-9]/g console.log(str.replace(reg, '#')) // he#l# wo#ld上面只是简朴的两个例子只是简朴的测试下是不是能够婚配到中括号内的相干划定规矩字符串
| 婚配多个划定规矩相当于||或
let str = "he1l3 wo4ld" let reg = /[0-9|a-d]/g console.log(str.replace(reg, '#')) // he#l# wo#l# let str = "he1l3 wo4ldc@" let reg = /[0-9|a-d|c.]/sg console.log(str.replace(reg, '#')) // he#l# wo#l##@上面第一个例子应用了g润饰符全局婚配0-9内的数字和a-d的字母替代，第二个例子应用了s和g的润饰符
正则表达式元字符
名字 应用形貌 /d 婚配数字 D 非数字字符 /s 查找空缺字符 S 非空缺字符 /b 婚配单词边境 n 婚配换行符 w 单词字符 W 非单词字符 /+ 涌现一到屡次 $ 婚配末端 \ 转义 ^ 婚配头部涌现的 t 婚配制表符 0 查找null 我们依据递次写几个简朴的例子
婚配数字，只需是数字都能婚配到 let str = "hello 1235" let reg = /\d/g console.log(str.replace(reg, '*')) // hello **** 查找空缺字符 let str = "hello 1235" let reg = /\s/g console.log(str.replace(reg, '*')) // hello*1235 婚配单词边境 let str = "hello 1235" let reg = /\b/g console.log(str.replace(reg, '*')) // *hello* *1235* 婚配换行符 let str = "hello\n123\n5" let reg = /\n/g console.log(str.replace(reg, '*')) // hello*123*5 /w婚配[a-zA-Z0-9_] let str = "Abv12_$" let reg = /\w/g console.log(str.replace(reg, '*')) // ******
婚配末端的$
let str = "Abv12"
let reg = /v$/g
console.log(reg.exec(str)) // null
let str = "Abv12v"
let reg = /v$/g
console.log(reg.exec(str)) // ["v", index: 5, input: "Abv12v", groups: undefined]
^婚配开首的
let str = "Abv12v"
let reg = /^v/g
console.log(reg.exec(str)) // null
let str = "vAbv12v"
let reg = /v$/g
console.log(reg.exec(str)) //["v", index: 0, input: "vAbv12v", groups: undefined]
^和$合营应用
let str1 = "abcd 1"
let reg1 = /^[a-z]+\s+\d+$/i
console.log(str1.replace(reg1, '*')) // *婚配abcd 1,须要对应的划定规矩分别是abcd ^[a-z] 空格s d数字$
{} 和 （） 和 ？的应用
{n} 婚配n个
{n，} 起码n个
{n, n} 起码婚配n个，最大婚配n个
（）捕捉性分组应用
let str = '2018-03-02'
let reg = /^(\d{4})-(\d{2})-(\d{2})$/
console.log(str.replace(reg, "$1/$2/$3")) // 2018/03/02上面的例子应用了（）和{}合营应用，分成了三个组，第一个组婚配四个数字，第二个和第三个婚配两位数字，然后利用了^最先婚配的四位数字最先和$婚配两位数字完毕，将-替代/
（）非捕捉性应用 非捕捉性分组经由过程将子表达式放在"?:"标记后，我明白的非捕捉性分组就是（）有根没有都一样
let str = '2018-03-02'
let reg = /^(?:\d{4})-(?:\d{2})-(?:\d{2})$/
console.log(str.replace(reg, "$1/$2/$3")) // $1/$2/$3上面的例子就是一个非捕捉性的例子，在子表达式前面加上？：就能够消除小括号的分组形式所以婚配不到
贪欲形式与非贪欲形式
说到贪欲形式和非贪欲形式，起首我要引见一下量词，由于非贪欲形式要用在量词背面
n{X}婚配包括X个n的序列的字符串
n{X,Y}婚配包括X至Y个n的序列的字符串
n{X,}婚配最少包括 X 个 n 的序列的字符串
n*婚配任何包括零个或多个 n 的字符串
n?婚配任何包括零个或一个 n 的字符串
n+婚配任何最少包括一个 n 的字符串
贪欲形式就是尽量多的婚配
let str = 'abcdefghijk123'
let reg = /\w{1,4}/
console.log(str.replace(reg, "*")) // *efghijk123上面的例子则为贪欲形式它会婚配到最大的谁人位数
let str = 'abcdefghijk123'
let reg = /\w{1,4}?/
console.log(str.replace(reg, "*")) // *bcdefghijk123上面的例子则为非贪欲形式，只会去婚配起码的位数
先行断言和先行否认断言（婚配到前面的）
先行断言？=
let str = 'abcdefghijk123asd456'
let reg = /\w+(?=123)/g
console.log(str.match(reg)) // ["abcdefghijk"]上面的例子为先行断言的例子reg划定规矩必需是背面带有123的婚配到
先行否认断言？！
let str = 'bbb123 bbbbb456'
let reg = /b{3,}(?!123)/g
console.log(str.match(reg)) // ["bbbbb"]
后行断言和后行否认断言（婚配到背面的）
后行断言查找婚配表达式婚配到背面的
let str = 'abcdefghijk123asd456'
let reg = /(?<=123)[a-z]/g
console.log(str.match(reg)) // ["a"]
后行否认断言，婚配不属于123的，背面的[a-z]的字符
let str = 'abcdefghijk123asd'
let reg = /(?<!123)[a-z]+/g
console.log(str.match(reg)) // ["abcdefghijk", "sd"]我觉得先行断言像后行否认断言，先行否认断言像后行断言
RegExp 组织函数对象
new RegExp(pattern,modifiers)
pattern 则为表达式
modifiers 则为润饰符
let reg1 = new RegExp('[a-z]','g')
console.log(reg1) // /[a-z]/g上面的例子我们会获得这个效果是由于RegExp对象会将第二个参数润饰符与第一个参数表达式举行兼并
let reg1 = new RegExp(/[a-z]/,'g')
console.log(reg1) // /[a-z]/g上面这个例子我们也会获得我们想要婚配全局的一个表达式，然则在es5中假如如许写就会涌现报错
let reg1 = new RegExp(/[a-z]/,'g')
console.log(reg1.flags) // g
let reg1 = new RegExp(/[a-z]/,'i')
console.log(reg1.flags) // i我们还能够检测表达式是不是应用了润饰符，而且能够晓得应用了什么润饰符
正则表达式的要领
- RegExp 对象要领
| compile | 编译正则表达式 |
|---|
let str = '123.jpg456.png'
let reg = /[123]/g
console.log(str.replace(reg, 'x')) // xxx.jpg456.png
reg.compile(/[456]/g)
console.log(str.replace(reg, 'x')) // 123.jpgxxx.png
let str = '123.jpg456.png'
let reg = /[123]/g
console.log(str.replace(reg, 'xx')) // xxxxxx.jpg456.png上面的第一个例子应用了表达式要领compile它会使表达式从新编译或是修正，所以第一次婚配的是123，第二次则是456，是由于改变了婚配机制，第二个例子应用用到了替代的要领而且会发明你替代的参数多的话会修正字符串的长度
| exec | 依据正则表达试查找对应的字符和位置 |
|---|
let str = '2018-02-13'
let reg = /-\d{1,2}/g
console.log(reg.exec(str)) // ["-02", index: 4, input: "2018-02-13", groups: undefined]上面的例子是查找带有-数字不凌驾2位，返回的是数组，而且把婚配到的第一个在最前面的位置
| test | 依据正则表达试是不是婚配到布尔值 |
|---|
- 正则表达式的 String 对象的要领
| search | 检索与正则表达式相婚配的值 |
|---|
let str = '2018-02-13'
let reg = /-\d{1,2}/g
console.log(str.search(reg)) // 4它会返回你表达式婚配到第一个字符的位置返回，它会对大小写敏感假如查找不到会返回-1，疏忽g
| match | 找到一个或多个正则表达式的婚配 |
|---|
let str = 'this is 1 or 2'
let reg = /\d/g
console.log(str.match(reg)) // [1,2]它会找出一切与你表达式婚配到的字符放入数组中
| replace | 替代 |
|---|
replace替代我们上面已应用过很屡次了，人人能够仔细阅读看
| matchAll | 婚配一切，表达式不必应用全局润饰符 |
|---|
es6的正在提案的一个要领，它能够摒弃全局的润饰符，到达全局的婚配，它会返回一个遍历器，然后能够经由过程构造赋值拿到想要的效果
上面我们进修了那么多，那我们就应用所学写一些表达式
/^1[3|4|5|7|8][0-9]{9}$/ 婚配手机号开首必需有1，34578个中的一个，末端必需9位数而且是0-9的数字
/^0315(-?)[0-9]{7}$/ 推断电话区号和-无足轻重
/^[0-9]{4}(-?)[0-9]{7}$/ 婚配1-9的数字必需是四位，无足轻重-，婚配7位数字都是几个比较简朴的表达式，还需多进修，多演习才写出更普遍更精准的表达式
