正则表达式（Regular Expression）是一组由字母和符号组成的特殊文本，它可以用来从文本中找出满足你想要的格式的句子。

regexp

创建正则表达式的两种方法：字面量、RegExp 构造函数

字面量，以斜杠表示开始和结束：

const regex = /abc/

RegExp 构造函数：

const regex = new RegExp('abc')

RegExp 构造函数还可以接受第二个参数，表示修饰符：

const regex = new RegExp('abc', 'i')

实例方法

test()

test() 方法返回一个布尔值，表示当前模式是否能匹配参数字符串。

/lit/.test('I am a lit') // true

exec()

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

const str = '_x_x'

/x/.exec(str) // ['x', index: 1, input: '_x_x', groups: undefined]
/y/.exec(str) // null

实例属性

• ignoreCase 只读属性。返回一个布尔值，表示是否设置了 i 修饰符。
• multiline 只读属性。返回一个布尔值，表示是否设置了 m 修饰符。
• global 只读属性。返回一个布尔值，表示是否设置了 g 修饰符。

const reg = /abc/igm

reg.ignoreCase // true
reg.global // true
reg.multiline // true

Tips：这些修饰符的作用下文有做解释。

lastIndex 可读可写。返回一个数值，表示下一次开始搜索的位置。

/(hi)?/g.lastIndex // 0

source 只读属性。返回正则表达式的字符串形式（不包括反斜杠）。

/abc/igm.source // "abc"

unicode 只读属性。属性表明正则表达式带有 u 修饰符。

/\u{61}/u.unicode // true

sticky ES6 新增的只读属性。表示是否设置了y修饰符。

/foo/y.sticky // true

flags ES6 新增。该属性返回一个字符串，由当前正则表达式对象的修饰符组成，以字典序排序（从左到右，即 "gimuy"）。

/foo/ig.flags // "gi"
/bar/myu.flags .flags // "muy"

字符串的正则方法

match()

match() 方法检索返回一个字符串匹配正则表达式的结果数组。

'The fat cat sat on the mat.'.match(/a/g) // ["a", "a", "a", "a"]

split()

split() 按照给定规则进行字符串分割，返回一个数组，包含分割后的各个成员。

语法

str.split(separator, [limit])

该方法接受两个参数，第一个参数是正则表达式，表示分隔规则，第二个参数是返回数组的最大成员数。

示例

'The fat cat sat on the mat.'.split(' ', 3) // ["The", "fat", "cat"]

"Hello 1 word. Sentence number 2.".split(/(\d)/) // ["Hello ", "1", " word. Sentence number ", "2", "."]

replace()

replace() 按照给定的正则表达式进行替换，返回替换后的字符串。

语法

str.replace(regexp|substr, newSubStr|function)

示例

const str = 'Twas the night before Xmas...'
const newstr = str.replace(/xmas/i, 'Christmas')

str // "Twas the night before Xmas..."
newstr // "Twas the night before Christmas..."

原字符串不会改变。

search()

search() 按照给定的正则表达式进行搜索，返回一个整数，表示匹配开始的位置。如果没有任何匹配，则返回 -1。

'The fat cat sat on the mat.'.search('at') // 5

'The fat cat sat on the mat.'.search('v') // -1

matchAll()

matchAll() ES2020 新增方法。该方法返回一个包含所有匹配正则表达式的结果及分组捕获组的迭代器（Iterator）。

const str = 'test1test2'
const reg = /t(e)(st(\d?))/g

for (const match of str.matchAll(reg)) {
  console.log(match)
}
// ['test1', 'e', 'st1', '1', index: 0, input: 'test1test2', groups: undefined]
// ['test2', 'e', 'st2', '2', index: 5, input: 'test1test2', groups: undefined]

// 转为数组
const array = [...str.matchAll(reg)]
// const array = Array.from(str.matchAll(reg))

array[0] // ['test1', 'e', 'st1', '1', index: 0, input: 'test1test2', groups: undefined]
array[1] // ['test2', 'e', 'st2', '2', index: 5, input: 'test1test2', groups: undefined]

元字符

管道符

使用或运算符（|）在用 Markdown 表格上显示有问题，贴出图片。（倒数第三个元字符描述缺少 | 同样问题）

分组

(a|b)

量词

锚点

转义字符

上面所提到的有特殊含义的元字符，如果要匹配它们本身，就需要在它们前面要加上反斜杠。比如要匹配 +，就要写成 \+。

/1+1/.test('1+1') // false

(/1\+1/).test('1+1') // true

如果使用 RegExp 方法生成正则对象，转义需要使用两个斜杠，因为字符串内部会先转义一次。

const reg = new RegExp('1\+1')
reg.test('1+1') // false

const reg1 = new RegExp('1\\+1')
reg1.test('1+1') // true

字符集

字符集也叫做字符类。方括号 [] 用来指定一个字符集。 在方括号中使用连字符来指定字符集的范围。 在方括号中的字符集不关心顺序。

简写字符集

标志

标志也叫模式修饰符，用来修改表达式的搜索结果，它们可以任意组合。

忽略大小写 (Case Insensitive)

修饰语 i 用于忽略大小写。

'The fat cat sat on the mat.'.match(/The/gi) // ['The', 'the']

全局搜索 (Global search)

修饰符 g 常用于执行一个全局搜索匹配，即（不仅仅返回第一个匹配的，而是返回全部）。

'The fat cat sat on the mat.'.match(/.(at)/g) // ['fat', 'cat', 'sat', 'mat']

多行修饰符 (Multiline)

多行修饰符 m 常用于执行一个多行匹配。

像之前介绍的 (^,$) 用于检查格式是否是在待检测字符串的开头或结尾。但我们如果想要它在每行的开头和结尾生效，我们需要用到多行修饰符 m。

'The fat cat sat on the mat.'.match(/.at(.)?$/gm) // ['mat.']

零宽度断言（前后预查）

先行断言和后发断言都属于非捕获簇（不捕获文本 ，也不针对组合计进行计数）。 先行断言用于判断所匹配的格式是否在另一个确定的格式之前，匹配结果不包含该确定格式（仅作为约束）。

例如，我们想要获得所有跟在 $ 符号后的数字，我们可以使用正后发断言 (?<=\$)[0-9\.]*。 这个表达式匹配 $ 开头，之后跟着 0,1,2,3,4,5,6,7,8,9,. 这些字符可以出现大于等于 0 次。

'$'.match(/(?<=\$)[0-9\.]*/) // ['', index: 1, input: '$', groups: undefined]
'$1'.match(/(?<=\$)[0-9\.]*/) // ['1', index: 1, input: '$1', groups: undefined]

?= 正先行断言

?= 正先行断言，表示第一部分表达式之后必须跟着 ?=...定义的表达式。

返回结果只包含满足匹配条件的第一部分表达式。 定义一个正先行断言要使用 ()。在括号内部使用一个问号和等号： (?=...)。

正先行断言的内容写在括号中的等号后面。

'The fat cat sat on the mat.'.match(/(T|t)he(?=\sfat)/) // ['The', 'T', index: 0, input: 'The fat cat sat on the mat.', groups: undefined]
'The fat cat sat on the mat.'.match(/(T|t)he(?=\sfat)/) // ['The', 'T', index: 0, input: 'The fat cat sat on the mat.', groups: undefined]

?! 负先行断言

?! 负先行断言，用于筛选所有匹配结果，筛选条件为 其后不跟随着断言中定义的格式。 正先行断言定义和负先行断言一样，区别就是 = 替换成 ! 也就是 (?!...)。

/(T|t)he(?!\sfat)/.exec('The fat cat sat on the mat.') // ['the', 't', index: 19, input: 'The fat cat sat on the mat.', groups: undefined]

?<= 正后发断言

?<= 正后发断言，用于筛选所有匹配结果，筛选条件为 其前跟随着断言中定义的格式。

/(?<=(T|t)he\s)(fat|mat)/.exec('The fat cat sat on the mat.') // ['fat', 'T', 'fat', index: 4, input: 'The fat cat sat on the mat.', groups: undefined]

?<! 负后发断言

?<! 负后发断言，用于筛选所有匹配结果，筛选条件为 其前不跟随着断言中定义的格式。

/(?<!(T|t)he\s)(cat)/.exec('The fat cat sat on the mat.') // ['cat', undefined, 'cat', index: 8, input: 'The fat cat sat on the mat.', groups: undefined]

贪婪匹配与惰性匹配（Greedy vs lazy matching）

正则表达式默认采用贪婪匹配模式，在该模式下意味着会匹配尽可能长的子串。我们可以使用 ? 将贪婪匹配模式转化为惰性匹配模式。

• *?：表示某个模式出现 0 次或多次，匹配时采用非贪婪模式。
• +?：表示某个模式出现 1 次或多次，匹配时采用非贪婪模式。

'The fat cat sat on the mat.'.match(/(.*at)/) // ['The fat cat sat on the mat', 'The fat cat sat on the mat', index: 0, input: 'The fat cat sat on the mat.', groups: undefined]

'The fat cat sat on the mat.'.match(/(.*?at)/) // ['The fat', 'The fat', index: 0, input: 'The fat cat sat on the mat.', groups: undefined]

更多资料

• learn-regex
• regexr RegExr 是基于 HTML/JS 的工具，用于创建，测试和学习正则表达式。
• RegExper 可以将正则表达式转成解释图片。
• RegExLib 收集各种常用的正则表达式，比如搜索 "email"，会返回该站点收集的所有关于📪正则表达式。
• RegexBuddy
• RegexMagic
• Rubular
• OWASP Validation Regex Repository
• CyrilEx Regex Tester
• 一份 PDF 备忘单（英文）