Javascript中与正则表达式有关的方法(函数)

2023年10月27日 175点热度 0人点赞 0条评论

在JavaScript中，与正则表达式有关的方法分别存在与RegExp类(构造函数)与String包装类中。

其中RegExp构造函数(类)中定义了exec、test、toString、[Symbol.match]、[Symbol.matchAll]、[Symbol.replace]、[Symbol.search]、[Symbol.split]这几个方法。

而String包装类中定义了match、matchAll、search、replace、replaceAll、split这6个方法。实际这些方法在以正则表达式作为参数传入时，底层会在传入的正则表达式(RegExp的实例)中查找对应的Symbol标识的方法并执行，例如字符串的match方法调用传入的正则表达式的[Symbol.match]方法。

以下开始介绍这些方法。

String包装类中的方法

在String的包装类中与正则表达式有关的方法有：match()、matchAll()、search()、replace()、replaceAll()、split()。

match()

match(regexp: string | RegExp): RegExpMatchArray | null;

字符串match方法使用给定的正则表达式在字符串中执行查找匹配，匹配成功返回一个数组，在未匹配到时会返回 null。

参数

传入一个正则表达式对象或具有 [Symbol.match] 方法的对象。
也可以传入一个字符串，match会尝试使用 new RegExp() 将字符串隐式的转换为正则表达式对象。
未指定参数时，返回值将会是一个包含空字符串的数组。

返回值

match()方法的返回一个数组，数组的实际内容将会根据传入的正则表达式是否存在"g"标志、有无小括号(捕获组)等因素决定。

1. 无任何标志时，它只返回字符串中第一个与之匹配的项。

const regexp = /\d{1,2}.\d{1,2}./;
const text = '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。';

console.log(text.match(regexp));
// [
//   '10月26日',
//   index: 4,
//   input: '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。',
//   groups: undefined
// ]

数组的第一项是匹配的内容，而"11时14分"并没有包括在其中。index属性是与之匹配的内容位于字符中的索引位置，input为调用该方法的字符串，因为该正则表达式中不存在小括号，所以groups为undefined。

2. 存在小括号(捕获组)时，数组第一项是整个表达式匹配的内容，数组第二项开始将是小括号中匹配的内容。

const regexp = /(\d{1,2}).(\d{1,2})./;
const text = '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。';

console.log(text.match(regexp));
// [
//   '10月26日',
//   '10',
//   '26',
//   index: 4,
//   input: '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。',
//   groups: undefined
// ]

当使用具名捕获组时，可以通过指定的捕获组名称在groups中获取匹配的内容。

const regexp = /(?<first>\d{1,2}).(?<last>\d{1,2})./;
const text = '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。';

console.log(text.match(regexp));
// [
//   '10月26日',
//   '10',
//   '26',
//   index: 4,
//   input: '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。',
//   groups: { first: '10', last: '26' }
// ]

3. 存在"g"标志时，它将会返回所有与之匹配的项。

const regexp = /\d{1,2}.\d{1,2}./g;
const text = '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。';

console.log(text.match(regexp));
// [ '10月26日', '11时14分' ]

如果正则表达式中存在"g"标识与小括号(捕获组)，返回的数组中将不会包括捕获组的内容。

match()方法不受 lastIndex 属性的影响，但是会刷新 lastIndex ：

const regexp = /\w+\s\w+/g;
const text = 'Hello Javascript!Hello Python!';
regexp.lastIndex = 5;

console.log(text.match(regexp));
// [ 'Hello Javascript', 'Hello Python' ]
console.log(regexp.lastIndex);
// 0

matchAll()

matchAll()方法在字符串中执行匹配，与之匹配的内容将会作为一个迭代器返回。

参数

matchAll()方法接受参数与match()方法一致，唯一区别就是传入的正则表达式必须设置"g"(全局匹配)标识，否则将会抛出TypeError异常。

返回值

它的返回值是一个迭代器，每项都是匹配结果的数组形式，与match()方法中使用不带"g"标志的正则表达式返回值类似。

const regexp = /(\d{1,2}).(\d{1,2})./g;
const text = '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。';
const matchs = text.matchAll(regexp);

for (const item of matchs) console.log(item);
// console.log(...matchs); // 也可以解构迭代器
// [
//   '10月26日',
//   '10',
//   '26',
//   index: 4,
//   input: '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。',
//   groups: undefined
// ]
// [
//   '11时14分',
//   '11',
//   '14',
//   index: 10,
//   input: '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。',
//   groups: undefined
// ]

matchAll()方法会受到 lastIndex 属性的影响，但是不会刷新 lastIndex ：

const regexp = /(\d{1,2}).(\d{1,2})./g;
const text = '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。';

regexp.lastIndex = 9;
console.log(...text.matchAll(regexp));
// [
//   '11时14分',
//   '11',
//   '14',
//   index: 10,
//   input: '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。',
//   groups: undefined
// ]
console.log(regexp.lastIndex);
// 9

search()

search()方法会在字符串中执行匹配，如果匹配成功它返回第一个匹配到的位置索引，匹配失败返回 -1。

参数

传入一个正则表达式对象或具有 [Symbol.search] 方法的对象。
也可以传入一个字符串，search会尝试使用 new RegExp() 将字符串隐式的转换为正则表达式对象。

返回值

如果匹配成功，则返回正则表达式在字符串中首次匹配的索引；否则，返回 -1。

正则表达式的"g"标志对 search() 方法的结果没有影响，正则表达式的lastIndex 不会影响到search()方法，因为它总是从字符串起始位置开始匹配。search()在执行之后也不会刷新lastIndex。

const regexp = /(\d{1,2}).(\d{1,2})./g;
const text = '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。';

regexp.lastIndex = 9;
console.log(text.search(regexp));
// 4
console.log(regexp.lastIndex);
// 9

replace()

replace()方法会在字符串中查找匹配的内容，并且使用替换字符串替换掉与之匹配的内容。该方法并不改变调用它的字符串本身，而是返回一个新的字符串。

const regexp = /(\w+)\s(\w+)/;
const text = 'Hello Javascript!';
const newText = text.replace(regexp, '$2 $1');

console.log(newText);
// Javascript Hello!

参数

第一个参数为正则表达式对象或具有 [Symbol.replace] 方法的对象。也可以传入一个字符串，但search不会将该字符串转换为正则表达式对象。如果传入的是一个空字符串，则第二个参数的替换内容将会插入到字符串的开头而不进行任何的替换。如果传入没有 Symbol.replace 方法的值都会被强制转换为字符串。
第二个参数可以是字符串，它将替换用于替换掉正则表达式所匹配的内容。第二个参数也可以是函数，将为每个与之匹配的内容作为参数调用该函数，并将该函数的返回值用于替换与之匹配的内容。

返回值

返回一个新的字符串，但不会修改原字符串。

以字符串作为第一个参数

如果第一个参数为字符串类型，replace将会用该参数进行搜索匹配，如果匹配，它将只会替换第一个与之匹配的内容。

const text = 'Hello Javascript!Hello Python!';
console.log(text.replace('Hello', 'Hi'));
// Hi Javascript!Hello Python!

以正则表达式对象作为第一个参数

如果传入无"g"标志的正则表达式，那么replace将会只替换一个与之匹配的内容。使用"g"标志的正则表达式将会全部进行替换。

const regexp = /hello/i;
const regexp_g = /hello/gi;
const text = 'Hello Javascript!Hello Python!';
console.log(text.replace(regexp, 'Hi'));
// Hi Javascript!Hello Python!
console.log(text.replace(regexp_g, 'Hi'));
// Hi Javascript!Hi Python!

以字符串作为replace()方法的第二个参数

如果第二个参数为字符串时，字符串内部可以使用以下特殊标识的符号，该符号表示正则表达式中所匹配的内容。

$$：表示一个"$"符号，因为"$"具有特殊的意义，使用这个字符本身需要进行转义。
$&：表示与之匹配的内容。
$`：表示与之匹配的内容到字符串起始位置的那段内容。
$'：表示与匹配的内容到字符串末尾位置的那段内容。
$n：表示第n个捕获组的内容，n为正整数(不为0)且小于100。()
$name：表示具名的捕获组，name为这个捕获组的名称。

"$n"与"$name"只有存在对应的捕获组才可用，否则表示为普通字符串。

const regexp = /(javascript)|(python)/gi;
const text = 'Hello Javascript!Hello Python!';
console.log(text.replace(regexp, '$`'));
// Hello Hello !Hello Hello Javascript!Hello !

console.log(text.replace(regexp, '$3'));
// Hello $3!Hello $3!

如果指定的捕获组存在但不匹配将会使用空字符串进行替换。

const regexp = /(javascript)|(python)/gi;
const text = 'Hello Javascript!Hello Python!';

console.log(text.replace(regexp, '$2'));
// Hello !Hello Python!

以函数作为replace()方法的第二个参数

将第二个参数指定为函数的情况下，匹配时将调用该函数，与之匹配的内容将作为参数传入该函数，而该函数的返回值将作为替换内容。

传入的函数形如：

function replacer(match, p1, p2, /* …, */ pN, offset, string, groups) {
  return replacement;
}

其实这些参数与上述中的"$&"、"$n"特殊标识表示相同的内容。

match：表示与正则表达式所匹配的内容。
p1,p2,pN：表示捕获组（包括具名捕获组）的内容。当第一个参数是正则表达式对象时该参数可用
offset：表示匹配与之匹配的内容位于字符串中的索引位置。
string：表示调用该方法的原始字符串。
groups：表示由具名捕获组组成的对象，存在捕获组但没有匹配，值为 undefined。

function replacer(match, p1, p2, p3, offset, string) {
  // p1 是非数字，p2 是数字，且 p3 非字母数字
  return [p1, p2, p3].join(" - ");
}
const newString = "abc12345#$*%".replace(/([^\d]*)(\d*)([^\w]*)/, replacer);
console.log(newString); // abc - 12345 - #$*%

replaceAll()

该函数的参数、返回值与replace()一致，区别在于：

如果第一个参数是正则表达式时，该表达式必须是设置"g"标志(全局匹配)，否则会抛出TypeError错误。
如果第一个参数是字符串时，与之匹配的所有内容全部会被这个参数替换，而不是只替换第一个。

const text = 'Hello Javascript!Hello Python!';
console.log(text.replaceAll('Hello', 'Hi'));
// Hi Javascript!Hi Python!

split()

split()方法使用正则表达式或者字符串将内容分隔，并将分隔后的内容存储到数组中返回。

参数

第一个参数用于指示分隔字符串的位置，类型可以是正则表达式对象或具有 [Symbol.split] 方法的对象，也可以是一个字符串。除了上述类型与undefined之外，传入其他类型的值都将会被强制转换为字符串。
第二个参数可选，它接收一个非负数的整数，用于指定分隔项的数量最大值，超出时将会停止分割，剩余内容会被抛弃不会包含在返回的数组中。换句话说，如果该参数为0，那将会返回一个空数组。

返回值

split()方法的返回值是字符串数组。

如果第一个参数传入的是正则表达式，那么splite()方法会忽略正则表达式的"y"、"g"标志。

const regexp = /!/giy;
const text = 'Hello Javascript!Hello Python!';
console.log(text.split(regexp));
// [ 'Hello Javascript', 'Hello Python', '' ]

分隔的结果中不会包含用于指示分隔位置的内容。

const regexp = /javascript/i;
const text = 'Hello Javascript!Hello Python!';
console.log(text.split(regexp));
// [ 'Hello ', '!Hello Python!' ]

如果要从字符串的开头或结尾处分隔，那将会有一个空字符串出现在返回数组的第一项或最后一项。

const regexp = /!/i;
const text = 'Hello Javascript!Hello Python!';
console.log(text.split(regexp));
// [ 'Hello Javascript', 'Hello Python', '' ]

如果没有可以分隔的内容，那么返回的数组将会是这个完整的字符串。

const regexp = /hi/i;
const text = 'Hello Javascript!Hello Python!';
console.log(text.split(regexp));
// [ 'Hello Javascript!Hello Python!' ]

如果第一个参数是包含捕获括号的正则表达式，则小括号(捕获组)的结果（包括任何 undefined 的结果）将会出现在数组中。

const regexp = /(!)/i;
const text = 'Hello Javascript!Hello Python!';
console.log(text.split(regexp));
// [ 'Hello Javascript', '!', 'Hello Python', '!', '' ]

如果第一个参数是一个空字符串，调用该方法的字符串每个字符都将作为数组中每项进行返回(实际上是以UTF-16编码单元进行分隔，也就是将字符串以两个字节的大小进行分隔)

const regexp = /(!)/i;
const text = 'Hello';
console.log(text.split(''));
// [ 'H', 'e', 'l', 'l', 'o' ]

如果第一个参数是一个匹配空字符串的正则表达式，匹配是由 UTF-16 还是 Unicode 码位分割取决于是否设置了 "u"标志。

"😄😄".split(/(?:)/); // [ "\ud83d", "\ude04", "\ud83d", "\ude04" ]
"😄😄".split(/(?:)/u); // [ "😄", "😄" ]

RegExp类中的方法

RegExp类中存在exec()、test()、toString()、[Symbol.match]()、[Symbol.matchAll]()、[Symbol.replace]()、[Symbol.search]()、[Symbol.split]()这些方法。

exec()

interface RegExpExecArray extends Array<string> {
    index: number;
    input: string;
    0: string;
}
exec(string: string): RegExpExecArray | null;

参数

exec方法接收一个字符串作为参数，它会在这个字符串中执行查找匹配的内容。

返回值

如果匹配成功将返回一个数组，并将RegExp实例的lastIndex设为下一次开始匹配位置的索引。匹配失败则返回 null，并将lastIndex 重置为0，下一次将会从字符串起始位置开始匹配。

匹配成功返回的数组比较特殊：

数组的第一个项为正则表达式匹配成功的内容，从第二项开始为捕获组的内容，前后顺序按捕获组左侧小括号出现的先后位置。

数组的index属性值是匹配到的内容位于字符串的位置的索引值。

数组的input属性值为被匹配的字符串。

数组的groups属性值是一个具名捕获组对象，键名为捕获组的名字，值是捕获组捕获的内容。如果没有定义命名捕获组，则 groups 的值为 undefined。

"d"标志对exec方法的影响

如果在正则中使用了"d"标识(例如：/abc/d)，那么exec方法的返回值还将存在一个名为"indices"的属性。

数组的indices属性是一个数组，只有当正则表达式设置了"d"标志时才存在。它的每项都是包含两个数值的数组，分别表示匹配内容的起始和结束位置。第一项是整个正则表达式所匹配的内容位于字符串中的位置，之后的每项则是小括号捕获组捕获的内容位于字符串中的位置，groups则是具名捕获组捕获的内容位置。它是在ECMAScript 2022标准中加入。

const regexp = /(\d{2}).(\d{2})/dg;
const text = '北京时间今天上午11时14分,中国成功发射了神舟十七号载人航天飞船。';
console.log(regexp.hasIndices);
// true
console.log(regexp.exec(text));
// [
//   '11时14', 第一项为正则表达式匹配成功的内容
//   '11',     第二项为捕获组的内容
//   '14',     第三项为捕获组的内容
//   index: 8, index属为匹配到的内容位于字符串的位置的索引值。
//   input: '北京时间今天上午11时14分,中国成功发射了神舟十七号载人航天飞船。', 被匹配的字符串
//   groups: undefined,
//   indices: [ [ 8, 13 ], [ 8, 10 ], [ 11, 13 ], groups: undefined ]
// ]

无任何标志的exec方法

无任何标志的情况下，exec 方法将只返回第一个匹配项，并停止继续向后查找，下次执行exec将从头重新开始匹配。即使设置lastIndex的值也不会有任何作用，exec执行完毕后也不会更新它的值。

// 未使用任何标志匹配
const regexp = /abc/;
const text = 'abc123abc123abc';

console.log(regexp.exec(text)); // 匹配第一个 "abc"
console.log(regexp.lastIndex); // lastIndex永远为"0"
console.log(regexp.exec(text)); // 匹配还是第一个 "abc"

"g" 标志 (全局匹配)

当正则表达式具有 "g" 标志时，exec 方法将执行全局匹配。它每次被调用时都会从lastIndex 开始向后进行匹配，如果存在就返回该匹配项的信息，并更新lastIndex的值，再次执行exec方法时将会从lastIndex索引值的位置开始向后匹配。也可以手动设定lastIndex的值从指定的位置开始进行匹配。

// 使用 "g" 标志进行全局匹配
const regexp_g = /abc/g;
const text_g = 'abc123abc123abc';

console.log(regexp_g.exec(text_g)); // 匹配第一个 "abc"
console.log(regexp_g.lastIndex); // lastIndex为"3"，exec将会从text_y[3]开始向后匹配
console.log(regexp_g.exec(text_g)); // 匹配第二个 "abc"
console.log(regexp_g.lastIndex); // lastIndex为"9"，exec将会从text_y[3]开始向后匹配
console.log(regexp_g.exec(text_g)); // 匹配第三个 "abc"

从上面的示例中可以看出来，只要后面存在可以匹配内容，正则表达式就会尽可能的向后匹配。

"y" 标志 (粘性匹配)

当正则表达式具有 "y" 标志时，exec 方法执行粘附匹配。它要求匹配必须从目标字符串的当前位置（由正则表达式对象的 lastIndex 属性确定）开始，只有当匹配从 lastIndex 指定的位置开始才算匹配成功。匹配成功也会更新lastIndex的值，同样也可以手动设定lastIndex的值从指定的位置开始进行匹配。

// 使用 "y" 标志进行粘性匹配
const regexp_y = /abc/y;
const text_y = 'abc123abc123abc';

console.log(regexp_y.exec(text_y)); // 匹配第一个 "abc"
console.log(regexp_y.lastIndex); // lastIndex为"3"，exec将会从text_y[3]处开始匹配
console.log(regexp_y.exec(text_y)); // 不匹配，返回null.
console.log(regexp_y.lastIndex); // lastIndex为"0"，再次执行exec将会从头开始重新匹配。

与"g"标志的代码进行对比可以看出它们之间的区别，"y"标志的正则表达式执行exec方法时只会从当前位置开始执行匹配，而不会像"g"标志那样尽可能地向后匹配。换句话说，"y" 标志的正则表达，下一次匹配一定在 lastIndex 位置开始；如果正则表达式有全局 "g" 标志，下一次匹配可能在 lastIndex 位置开始，也可能在这个位置的后面开始。

"g"与"y"标志同时启用

当这两个标志同时存在时，exec将会忽略"g"标志进行粘性匹配。

// 使用 "y、g" 标志进行粘性匹配
const regexp_yg = /abc/gy;
const text_yg = 'abc123abc123abc';
console.log(regexp_yg.exec(text_yg)); // 匹配第一个 "abc"
console.log(regexp_yg.lastIndex); // lastIndex为"3"，exec将会从text_y[3]开始向后匹配
console.log(regexp_yg.exec(text_yg)); // 不匹配，返回null.
console.log(regexp_yg.lastIndex); // lastIndex为"0"，再次执行exec将会从头开始重新匹配。

可以看到"g"与"y"同时存在的情况下，上述代码的执行效果与"y"标识一致。

注意，在"y"或"g"标志的正则表达式中，执行了exec方法后，如果期间调用了test方法也会更新 lastIndex 属性。而且还需注意，如果再次查找的字符串不是同一个字符串时，lastIndex 也不会被重置，因为这个属性是RegExp实例对象的上属性，它依旧会使用lastIndex属性值开始匹配。

如果正则表达式可以匹配任意内容，诸如：/.?/y、/.*/g 之类的正则，请注意在某些场景下需要手动递增 lastIndex，以避免其始终卡在相同的位置，因为这类正则匹配可以匹配0次，换句话说没有任何可以与之匹配的内容时也算匹配成功。

const regexp = /[a-c]*/y; // 替换/[a-c]*/g 结果也类似
const text = 'abc123abc123abc';

console.log(regexp.exec(text)); // 匹配"abc",lastIndex为"3"
console.log(regexp.exec(text)); // 不匹配字符"1"，lastIndex为"3"
console.log(regexp.exec(text)); // 不匹配字符"1"，lastIndex为"3"
console.log(regexp.exec(text)); // 不匹配字符"1"，lastIndex为"3"

test()

test方法接受一个字符串，它将会对传入的字符串进行检查，如果正则表达式能够与这个字符串里面的内容匹配，则它返回 true，反之返回false。

与exec方法一样，在"g"或"y"标志的正则表达式执行test方法时也会改变lastIndex，g"或"y"标志也会影响到test方法的执行。

const regexp = /[a-c]*/g;
const text = 'abc123abc123abc';

console.log(regexp.test(text));
console.log(regexp.lastIndex);
// 匹配"abc",lastIndex为"3"

console.log(regexp.test(text));
console.log(regexp.test(text));
console.log(regexp.test(text));
// 永远都为true
console.log(regexp.lastIndex);
// lastIndex永远为3

特殊的方法

在正则表达式中还存在一些特殊的方法：[Symbol.match]()、[Symbol.matchAll]()、[Symbol.replace]()、[Symbol.search]()、[Symbol.split]()，这些方法与字符串上对应的方法一致，区别只是在接受参数不一样。

Symbol.match、Symbol.matchAll、Symbol.replace、Symbol.search、Symbol.split 是一个用于访问RegExp类的方法的内置 JavaScript 符号。这种方式允许你在正则表达式的实例对象上通过这种特殊的符合调用这些方法。

const regexp = /(\d{1,2}).(\d{1,2})/g;
const text = '北京时间10月26日11时14分,中国成功发射了神舟十七号载人航天飞船。';

console.log(regexp[Symbol.match](text));
// [ '10月26', '11时14' ]
console.log(text.match(regexp));
// [ '10月26', '11时14' ]

当你调用 String.prototype.match 方法时，它实际上是在背后使用传入的正则表达式对象的 Symbol.match 方法来执行匹配操作。这也意味着你可以通过继承RegExp类时重写父类的[Symbol.match]方法，当你调用字符串的String.prototype.match方法时会执行自定义操作行为。

例如下面这个重写的[Symbol.match]方法，它会对匹配到的所有数求平均值，并将其添加到返回数组中的average属性上：

class CustomRegExp extends RegExp {
  // 重写父类的方法
  [Symbol.match](str) {
    // 使用正则表达式查找所有数字
    const matches = str.match(new RegExp(this.source, this.flags));
    // const matches = RegExp.prototype[Symbol.match].call(this, str);
    if (!matches) {
      return null;
    }

    // 计算数字的平均值
    const numbers = matches.map(Number);
    const sum = numbers.reduce((acc, num) => acc + num, 0);

    // 返回平均值
    matches['average'] = sum / numbers.length;
    return matches;
  }
}

const customRegExp = new CustomRegExp('(\\d+)', 'g');
// 测试匹配
const text = 'The numbers are 1, 2, 3, and 4.';
const result = text.match(customRegExp);
console.log(result);
// 输出 ['1', '2', '3', '4', average: 2.5]

也可以直接在RegExp实例对象上增加[Symbol.match]方法：

// 创建一个自定义正则表达式对象
const customRegExp = /(\d+)/g;
customRegExp[Symbol.match] = function (string) {
  // 使用正则表达式查找所有数字
  const matches = string.match(new RegExp(this.source, this.flags));
  // const matches = RegExp.prototype[Symbol.match].call(this, str);
  if (!matches) {
    return null;
  }

  // 计算数字的平均值
  const numbers = matches.map(Number);
  const sum = numbers.reduce((acc, num) => acc + num, 0);

  // 返回平均值
  // 返回平均值
  matches['average'] = sum / numbers.length;
  return matches;
};

// 测试匹配
const text = 'The numbers are 1, 2, 3, and 4.';
const result = text.match(customRegExp);

console.log(result); // 输出平均值 2.5

在这个示例中，我们创建了一个自定义正则表达式对象 customRegExp，并使用 Symbol.match 来指定了匹配操作的自定义行为。这个自定义行为在文本中查找所有数字，计算它们的平均值，并将其添加到返回数组中的average属性上。当我们对文本进行匹配时，它返回了数字的平均值。

compile()

参数与RegExp的构造函数一致，传入不包括双斜杠的正则表达式，用于修改调用这个方法的正则表达式的内容。该方法已废弃。

toString()

该方法返回正则表达式字面量形式的字符串。

const regexp = /abc/g;
console.log(regexp.toString());
// /abc/g

总结

如果你想知道一个正则表达式能否与一个字符串匹配时，推荐使用正则表达式的test方法，虽然字符串的search方法也可以，差别在于 test 返回一个布尔值，只会告诉你是否匹配，true为匹配，false为不匹配；而 search 返回数值，告诉你匹配的位置在哪，大于等于0匹配的位置，-1为不匹配。

正则对象的test方法以及字符串的search方法虽然都可以用来判断一个字符串是否被匹配。但需要注意，在条件判断的时候留心这两者的返回值是不一样的。

如果只是为了判断能否匹配，推荐用正则表达式的test方法。

如果只是为了获取所有与之匹配的项但又不需要使用捕获组，使用字符串的match方法更合适些。

如果想对匹配项进行迭代推荐使用字符串的matchAll方法，do while循环可以使用正则表达式的exec方法。

如果只要获取匹配内容在字符串中的位置，使用字符串的search方法。

如果要所有匹配项的详细信息，包括捕获组在内，使用正则表达式的exec方法或字符串的matchAll方法。