前端系列：正则表达式RegExp详解

正则创建
匹配方法
元字符
字符集合
边界
分组
数量词汇
匹配模式
RegExp 方法特性

正则创建

字面量创建

const str = 'asdf123sds3234'

const regexp = /\d+/g

const res = str.match(regexp)

console.log(res) //['123', '3234']

构造函数

const str = 'asdf123asad23121'

const regexp = new RegExp('\\d+', 'g')

const res = str.match(regexp)

console.log(res) // ['123', '23121']

匹配方法

字符串方法
- match:返回一个字符串匹配正则表达式的结果,如果未找到匹配则为null
```
const str = 'asdf123sds3234'

const regexp = /\d+/g

const res = str.match(regexp)

console.log(res) //['123', '3234']
```
- search:返回正则表达式在字符串中首次匹配项的索引;否则，返回 -1
```
const str = 'as12121es121sd'

const regexp = /\d+/

const res = str.search(regexp)

console.log(res) // 2
```
- replace:返回一个由替换值（replacement）替换部分或所有的模式（pattern）匹配项后的新字符串。模式可以是一个字符串或者一[正则表达式]，替换值可以是一个字符串或者一个每次匹配都要调用的回调函数。如果pattern是字符串，则仅替换第一个匹配项
```
const str = 'asahsashhuihui12332467y7'

const regexp = /(hui)|(123)/g

const res = str.replace(regexp, '*')

console.log(res) //asahsash***32467y7

const res2 = str.replace(regexp, (arg) => {

    return '*'.repeat(arg.length)

})

console.log(res2) //asahsash*********32467y7
```
- split:方法使用指定的分隔符字符串将一个String对象分割成子字符串数组，以一个指定的分割字串来决定每个拆分的位置
```
const str = 'cccasdfgd9asasdsa12121'

const regexp = /a/

const res = str.split(regexp)

console.log(res) //['ccc', 'sdfgd9', 's', 'sds', '12121']
```

正则对象方法

test:执行一个检索，用来查看正则表达式与指定的字符串是否匹配。返回 true 或 false

let str = 'asdhadhjkhjk12323879789pjdhjfhj'

let regexp = /\d+/

let res = regexp.test(str)

console.log(res) // true

regexp = /m/

res = regexp.test(str)

console.log(res) // false

exec:方法在一个指定字符串中执行一个搜索匹配。返回一个结果数组或 null

let str = 'sfkdhjk12238jks544jk'

let regexp = new RegExp('\\d+', 'g')

let res = regexp.exec(str)

console.log(res) //['12238', index: 7, input: 'sfkdhjk12238jks544jk', groups: undefined]

res = regexp.exec(str)

console.log(res) //['544', index: 15, input: 'sfkdhjk12238jks544jk', groups: undefined]

元字符

. :匹配默认除(\n,\r,\u2028,\u2029)之外的任何单个字符

const str = 'adad12121dfe234s'

const regexp = /./

const res = str.replace(regexp, '*')

console.log(res) //*dad12121dfe234s

\ :转义符，它有两层含义
- 表示下一个具有特殊含义的字符为字面值
- 表示下一个字符具有特殊含义（转义后的结果是元字符内约定的）
```
const str = 'sdsds/dfdfd12121'

const regexp = /\/d/

const res = regexp.test(str)

console.log(res) //true
```

\d :匹配任意一个阿拉伯数字的字符

const str = 'xsdsd3121xcxx12121cx'

const regexp = /\d+/

const res = regexp.exec(str)

console.log(res) //['3121', index: 5, input: 'xsdsd3121xcxx12121cx', groups: undefined]

\D :匹配任意一个非阿拉伯数字的字符

const str = 'xsdsd3121xcxx12121cx'

const regexp = /\D+/

const res = regexp.exec(str)

console.log(res) //['xsdsd', index: 0, input: 'xsdsd3121xcxx12121cx', groups: undefined]

\w :匹配任意一个（字母、数字、下划线）的字符

const str = '@qwqwq_asas12121df0df0l;ll'

const regexp = /\w+/g

const res = str.match(regexp)

console.log(res) //['qwqwq_asas12121df0df0l', 'll']

\W :匹配任意一个非（字母、数字、下划线）的字符

const str = '@qwqwq_asas12121df0df0l;ll'

const regexp = /\W+/g

const res = str.match(regexp)

console.log(res) //['@', ';']

\s :匹配一个空白符，包括空格、制表符、换页符、换行符和其他的Unicode 空格

const str = 'sdhjk\n\rsdsd\n'

const regexp = /\s+/g

const res = str.replace(regexp, '-')

console.log(res) //sdhjk-sdsd-

\S :匹配一个非空白符

const str = 'sdhjk\n\rsdsd\n'

const regexp = /\S+/g

const res = str.match(regexp)

console.log(res) //['sdhjk', 'sdsd']

\t :匹配一个水平制表符（horizontal tab）

const str = 'sdhjk\tsdsd'

const regexp = /\t/

const res = regexp.test(str)

console.log(res) //true

\r :匹配一个回车符（carriage return）

const str = 'sdhjk\rsdsd'

const regexp = /\r/

const res = regexp.test(str)

console.log(res) //true

\n :匹配一个换行符（linefeed）

const str = 'sdhjk\nsdsd'

const regexp = /\n/

const res = regexp.test(str)

console.log(res) //true

\v :匹配一个垂直制表符（vertical tab）

const str = 'sdhjk\vsdsd'

const regexp = /\v/

const res = regexp.test(str)

console.log(res) //true

\f :匹配一个换页符（form-feed）

const str = 'sdhjk\fsdsd'

const regexp = /\f/

const res = regexp.test(str)

console.log(res) //true

字符集合

[xyz] :一个字符集合。匹配方括号中的任意字符，包括转义序列。你可以使用破折号（-）来指定一个字符范围。对于点（.）和星号（*）这样的特殊符号在一个字符集中没有特殊的意义。他们不必进行转义，不过转义也是起作用的
```
const str = 'dfgd12312df57676ds'

const regexp = /[1-9]+/g

const res = str.match(regexp)

console.log(res) //['12312', '57676']
```
[^xyz] :一个反向字符集。也就是说，它匹配任何没有包含在方括号中的字符。你可以使用破折号（-）来指定一个字符范围。任何普通字符在这里都是起作用的
```
const str = 'dfgd12312df57676ds'

const regexp = /[^1-9]+/g

const res = str.match(regexp)

console.log(res) //['dfgd', 'df', 'ds']
```

[\b] :匹配一个退格(backspace)。（不要和\b 混淆了。）

const str = `dfgd12312df\b57676ds`

const regexp = /[\b]/g

const res = str.match(regexp)

console.log(res) //['\b']

边界

^ :匹配输入的开始。如果多行标志被设置为 true，那么也匹配换行符后紧跟的位置

const str = `sds234fsd\nsd4345ds\nsqwq`

const regexp = /^sd.*/gm

const res = str.match(regexp)

console.log(res) //['sds234fsd', 'sd4345ds']

$ :匹配输入的结束。如果多行标志被设置为 true，那么也匹配换行符前的位置

const str = `sds234fsd\nsd4345ds\nsqwq`

const regexp = /^sd.*d$/gm

const res = str.match(regexp)

console.log(res) //['sds234fsd']

\b :匹配一个词的边界。一个词的边界就是一个词不被另外一个“字”字符跟随的位置或者前面跟其他“字”字符的位置，例如在字母和空格之间。注意，匹配中不包括匹配的字边界。换句话说，一个匹配的词的边界的内容的长度是 0。（不要和[\b]混淆了）
```
const str = `this is dog`

const regexp = /\bi/

const res = str.match(regexp)

console.log(res) //['i', index: 5, input: 'this is dog', groups: undefined]
```

\B :匹配一个非单词边界

const str = `this is dog`

const regexp = /[a-z]+\Bi[a-z]+/

const res = str.match(regexp)

console.log(res) //['this', index: 0, input: 'this is dog', groups: undefined]

分组

() :对表达式进行分组，类似数学中的分组，也称为子项

索引分组:(x)

const str = 'asabvb\r121ghjsdhj sdsds'

const regexp = /(\w+)\r(\w+)/

const res = str.match(regexp)

console.log(res) //['asabvb\r121ghjsdhj', 'asabvb', '121ghjsdhj', index: 0, input: 'asabvb\r121ghjsdhj sdsds', groups: undefined]

命名分组:(?),groups 属性

const str = 'asabvb\r121ghjsdhj sdsds'

const regexp = /(?<str>\w+)\r(\w+)/

const res = str.match(regexp)

console.log(res) //['asabvb\r121ghjsdhj', 'asabvb', '121ghjsdhj', index: 0, input: 'asabvb\r121ghjsdhj sdsds', groups: {str: 'asabvb'}]

捕获匹配:(x)

const str = 'this is dog'

const regexp = /(this)/

const res = str.match(regexp)

console.log(RegExp.$1) //this

console.log(res) //['this', index: 0, input: 'this is dog', groups: undefined]

非捕获匹配:(?:x)

//简而言之就是不捕获文本 ，也不针对组合计进行计数

const str = 'this is dog'

const regexp = /(?:this)/

const res = str.match(regexp)

console.log(RegExp.$1) //''

console.log(res) //['this', index: 0, input: 'this is dog', groups: undefined]

断言/预查

正向肯定断言:x(?=y)

const str = 'iphone8iphone11iphoneNumber'

const regexp = /iphone(?=\d{1,2})/g

const res = str.replace(regexp, '苹果')

console.log(res) //苹果8苹果11iphoneNumber

正向否定断言:x(?!y)

const str = 'iphone8iphone11iphoneNumber'

const regexp = /iphone(?!\d{1,2})/g

const res = str.replace(regexp, '苹果')

console.log(res) //iphone8iphone11苹果Number

负向肯定断言

const str = '10px20px30pxxpx'

const regexp = /(?<=\d{2})px/g

const res = str.replace(regexp, '像素')

console.log(res) //10像素20像素30像素xpx

负向否定断言

const str = '10px20px30pxxpx'

const regexp = /(?<!\d{2})px/g

const res = str.replace(regexp, '像素')

console.log(res) //10px20px30pxx像素

数量词汇

x{n} :n 是一个正整数，前面的模式 x 连续出现 n 次时匹配

let str = '123ab_cd123'

let regexp = /[a-z]{3}/g

let res = str.replace(regexp, '*')

console.log(res) //123ab_cd123

regexp = /[a-z]{2}/g

res = str.replace(regexp, '*')

console.log(res) //123*_*123

x{n,m} :n 和 m 为正整数，前面的模式 x 连续出现至少 n 次，至多 m 次时匹配

let str = '123ab_cd123'

let regexp = /[a-z]{1,2}/g

let res = str.replace(regexp, '*')

console.log(res) //123*_*123

regexp = /[a-z]{1,1}/g

res = str.replace(regexp, '*')

console.log(res) //123**_**123

x{n,} :n 是一个正整数，前面的的模式 x 连续出现至少 n 次时匹配

let str = '123abwasdsd_123'

let regexp = /[a-z]{1,}/g

let res = str.replace(regexp, '*')

console.log(res) //123*_123

x* :匹配前面的模式 x 0 次或多次，等价于

let str = '123abwasdsd_123'

let regexp = /123*/g

let res = str.replace(regexp, '*')

console.log(res) //*abwasdsd_*

x+ :匹配前面的模式 x 1 次或多次,等价于

let str = '123abwasdsd_123'

let regexp = /123+/g

let res = str.replace(regexp, '*')

console.log(res) //*abwasdsd_*

x? :匹配前面的模式 x 0 次或 1 次,等价于

let str = '123abwasdsd_123'

let regexp = /d_123?/g

let res = str.replace(regexp, '*')

console.log(res) //123abwasds*

x|y :匹配 x 或 y

let str = '123abwasdsd_123'

let regexp = /[A-Z]|[a-z]+/g

let res = str.replace(regexp, '*')

console.log(res) //123*_123

匹配模式

g:全局搜索

let str = '123abwasdsd_123'

let regexp = /\d+/

let res = str.replace(regexp, '*')

console.log(res) //*abwasdsd_123

regexp = /\d+/g

console.log(regexp.global) // true

res = str.replace(regexp, '*')

console.log(res) //*abwasdsd_*

i:不区分大小写搜

let str = '123abCasdsd_123'

let regexp = /[a-z]+/g

let res = str.replace(regexp, '*')

console.log(res) //123*C*_123

regexp = /[a-z]+/gi

console.log(regexp.ignoreCase) // true

res = str.replace(regexp, '*')

console.log(res) //123*_123

m:多行搜索

let str = `abas

asds`

let regexp = /^\w+/gm

console.log(regexp.multiline) // true

let res = str.replace(regexp, '*')

console.log(res) //* *

s:允许 .匹配换行符

let str = `<div>hello world

            </div>`

let regexp = /<div>.*<\/div>/gs

console.log(regexp.dotAll)

let res = regexp.test(str)

console.log(res) //true

u:使用 unicode 码的模式进行匹配

console.log(/^.$/.test('\uD842\uDFB7')) //false

console.log(/^.$/u.test('\uD842\uDFB7')) //true

console.log(/^.$/u.unicode) // true

y:执行“粘性(sticky)”搜索,匹配从目标字符串的当前位置开始

const str = '121278789s834234dsssdf'

const regexp = /\d+/gy

console.log(regexp.sticky)

console.log(regexp.exec(str)) // ['121278789', index: 0, input: '121278789s834234dsssdf', groups: undefined]

console.log(regexp.exec(str)) // null

RegExp 方法特性

;/a/[Symbol.match]('abc')

;/a/[Symbol.matchAll]('abc')

;/a/[Symbol.replace]('abc', 'A')

;/a/[Symbol.search]('abc')

;/-/[Symbol.split]('a-b-c')

const str = 'asfs1212343sdsds12asa'

let regexp = /\d+/g

regexp.exec(str)

console.log(RegExp.input) //asfs1212343sdsds12asa

console.log(RegExp.$_) //asfs1212343sdsds12asa

console.log(regexp.lastIndex) //11

console.log(RegExp.lastMatch) //1212343

console.log(RegExp['$&']) //1212343

console.log(RegExp.leftContext) //asfs

console.log(RegExp['$`']) //asfs

console.log(RegExp.rightContext) //sdsds12asa

console.log(RegExp["$'"]) //sdsds12asa

regexp = /(\d+)([a-z]+)/g

const res = str.replace(regexp, '$1')

console.log(RegExp.$1) //12

console.log(RegExp.$2) //asa