前端系列：正则表达式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 次或多次，等价于 {0,}

let str = '123abwasdsd_123'
let regexp = /123*/g
let res = str.replace(regexp, '*')
console.log(res) //*abwasdsd_*

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

let str = '123abwasdsd_123'
let regexp = /123+/g
let res = str.replace(regexp, '*')
console.log(res) //*abwasdsd_*

x? :匹配前面的模式 x 0 次或 1 次,等价于 {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