RegExp 正则表达式

RegExp 正则表达式

\d 	 	数字
\w		字母或数字
\s		表示空格、tab、空白符等(' '  \t)
\b		代表着单词的开头或结尾
.		除了换行符以外的任意字符
*		指定*前面的内容可以重复任意次以使整个表达式得到匹配
+		匹配至少一个字符
?		匹配0个或1个字符(要么出现，要么不出现)
|		|前后表示两种可用的不同规则，如：0\d{2}-\d{8}|0\d{3}-\d{7}
{n}		表示n个字符
{n,m}	表示n~m个字符
[]		表示可选匹配的内容([0-9a-zA-Z]表示匹配一个数字、字母)
^		表示行的开始
$		表示行的结束(\$ 表示匹配字符$)
元字符：( [ { \ ^ $ | } ] ) ? * + .		必须转义后才能把它们当作字符使用

用构造函数的方法写正则表达式时，如果使用元字符，则需要二次转义才能使用。

反义正则：

代码/语法	说明
\W			匹配任意 不是 字母和数字的字符
\S			匹配任意 不是 空白符的字符
\D			匹配任意 非   数字的字符
\B			匹配不是 单词 开头或结束的位置
[^x]		匹配除了 x    以外的任意字符
[^aeiou]	匹配除了 aeiou 这几个字母以外的任意字符

反向引用：

捕获
(exp)	匹配exp,并捕获文本到自动命名的组里
(?<name>exp)	匹配exp,并捕获文本到名称为name的组里
(?:exp)	匹配exp,不捕获匹配的文本。不会改变正则表达式的处理方式，只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面

位置指定：指标是位置关系
(?=exp)	匹配exp前面的位置。 \b\w+(?=ing\b)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)，一个字符串中的结尾没有ing，也是能匹配的（因为(?=exp)只表示位置关系
(?<=exp)	匹配exp后面的位置。 (?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分)
(?!exp)	匹配后面跟的不是exp的位置
(?<!exp)	匹配前面不是exp的位置
注释
(?#comment)	这种类型的组不对正则表达式的处理产生任何影响，只是为了提供让人阅读注释

懒惰量词：

*?		重复任意次，但尽可能少重复
+?		重复1次或更多次，但尽可能少重复
??		重复0次或1次，但尽可能少重复
{n,m}?	重复n到m次，但尽可能少重复
{n,}?	重复n次以上，但尽可能少重复

其他：

\a	报警字符(打印它的效果是电脑嘀一声)
\b	通常是单词分界位置，但如果在字符类里使用代表退格
\t	制表符，Tab
\r	回车
\v	竖向制表符
\f	换页符
\n	换行符
\e	Escape
\0nn	ASCII代码中八进制代码为nn的字符
\xnn	ASCII代码中十六进制代码为nn的字符
\unnnn	Unicode代码中十六进制代码为nnnn的字符
\cN	ASCII控制字符。比如\cC代表Ctrl+C
\A	字符串开头(类似^，但不受处理多行选项的影响)
\Z	字符串结尾或行尾(不受处理多行选项的影响)
\z	字符串结尾(类似$，但不受处理多行选项的影响)
\G	当前搜索的开头
\p{name}	Unicode中命名为name的字符类，例如\p{IsGreek}
(?>exp)	贪婪子表达式
(?<x>-<y>exp)	平衡组
(?-<y>exp)	平衡组
(?im-nsx:exp)	在子表达式exp中改变处理选项
(?im-nsx)	为表达式后面的部分改变处理选项
(?(exp)yes|no)	把exp当作零宽正向先行断言，如果在这个位置能匹配，使用yes作为此组的表达式；否则使用no
(?(exp)yes)	同上，只是使用空表达式作为no
(?(name)yes|no)	如果命名为name的组捕获到了内容，使用yes作为表达式；否则使用no
(?(name)yes)	同上，只是使用空表达式作为no

匹配模式：

g		全局匹配，此时不能用^和$
i		不区分大小写
m		多行模式
y		粘附模式，以索引对应的开头字符开始匹配，匹配不对就返回false(test) | null(exec)
u
s		

书写形式

var re1 = /abc\-001/; // abc\-001

// new RegExp中如果用到转义字符，则需要用\\来表示一个\
var re2 = new RegExp('abc\\-001'); // abc\-001

实例方法

test()

判断输入数值是否和正则表达式匹配。返回布尔值

(表达式/regexp对象).exec(字符串)

var re = /^\d{3}\-\d{3,8}$/;
re.test('102-22535'); // true
re.test('120 757275'); // false
re.test('142-sd27d'); // false
re.lastIndex;         // 0

exec

在一个指定字符串中执行一个搜索匹配。返回一个结果数组

(表达式/regexp对象).exec(字符串)

var re = /^(\d{3})\-(\d{3,8})$/;
re.exec('122-24654'); // [122-24654,122,24654]
re.exec('122 24654'); // null

compile

运行脚本的期间（重新）编译正则表达式

不推荐

match

返回一个结果数组，它包括整个匹配结果，和通过捕获组匹配到的结果，如果没有匹配到则返回 null

str.match(regExp) 或者 regExp[Symbol.match](str)

开启全局模式(g)后，结果数组才有可能得到多个匹配值，否则只匹配一个

console.log('abc'.match(/a/));   // (1) ['a', index: 0, input: 'abc', groups: undefined]
console.log(/a\w+/g[Symbol.match]('ab-ac'));  // (2) ['ab', 'ac']

matchAll

返回一个包含所有匹配正则表达式的结果及分组捕获组的迭代器。

书写格式和match一样

const regexp = /t(e)(st(\d?))/g;
const str = 'test1test2';
console.log(str.matchAll(regexp));   // Object {  }
const array = [...str.matchAll(regexp)];

console.log(array[0]);
// expected output: Array ["test1", "e", "st1", "1"]

console.log(array[1]);
// expected output: Array ["test2", "e", "st2", "2"]

replace

在一个字符串中用给定的替换器，替换所有符合正则模式的匹配项，并返回替换后的新字符串结果。用来替换的参数可以是一个字符串或是一个针对每次匹配的回调函数。

• 书写格式和match一样

class RegExp1 extends RegExp {
  [Symbol.replace](str) {
    return RegExp.prototype[Symbol.replace].call(this, str, '#!@?');
  }
}

console.log('football'.replace(new RegExp1('foo')));
// expected output: "#!@?tball"

search

执行了一个在给定字符串中的一个搜索以取得匹配正则模式的项

如果查找成功，返回第一个被匹配到的值在字符串中的索引；否则返回-1。

const regex = /[^\w\s]/g; // 不是字母和空格
console.log(paragraph.search(regex));
// expected output: 43
console.log(paragraph[paragraph.search(regex)]);
// expected output: "."

toString

返回一个正则表达式的字符串

• 字面量形式：直接转成字符串
• regExp对象：转成字面量形式，然后再转成字符串形式

var re = /^\d{3}\-\d{3,8}$/;
foo = new RegExp("bar", "g");

console.log(foo.toString())  // /bar/g
console.log(re.toString())  // /^\d{3}\-\d{3,8}$/

lastIndex

当正则表达式的匹配模式为全局匹配模式/粘附模式时，用于标记由方法 RegExp.exec() 和 RegExp.test()找到的结果的下次检索的起始点

• 如果匹配成功
  • lastIndex < 字符串长度 – 返回lastIndex
  • lastIndex >= 字符串长度 – 返回0
• 匹配不成功 – 返回0

var re = /^\d{3}\-\d{3,8}$/;
re.test('102-22535'); // true
re.lastIndex;         // 0
re.test('142-sd27d'); // false
re.lastIndex;         // 0