更新：2019-09-10

旧的迭代多个匹配的方法不是很直观。这导致了String.prototype.matchAll方法的提出。这种新方法在ECMAScript 2020规范中。它为我们提供了一个干净的API并解决了多个问题。自从Chrome 73+/Node 12+和Firefox 67+之后，它就出现在主流浏览器和JS引擎中。

该方法返回迭代器，用法如下：

const string=“something format_abc”；常量regexp=/（？：^|\s）format_（.*？）（？：\s|$）/g；const matches=string.matchAll（正则表达式）；for（匹配的常量匹配）{console.log（匹配）；console.log（match.index）}

当它返回迭代器时，我们可以说它是懒惰的，这在处理大量捕获组或非常大的字符串时非常有用。但如果需要，可以使用扩展语法或Array.from方法将结果轻松转换为数组：

function getFirstGroup(regexp, str) {
  const array = [...str.matchAll(regexp)];
  return array.map(m => m[1]);
}

// or:
function getFirstGroup(regexp, str) {
  return Array.from(str.matchAll(regexp), m => m[1]);
}

与此同时，虽然这一提议得到了更广泛的支持，但您可以使用官方垫片包。

此外，该方法的内部工作也很简单。使用生成器函数的等效实现如下：

function* matchAll(str, regexp) {
  const flags = regexp.global ? regexp.flags : regexp.flags + "g";
  const re = new RegExp(regexp, flags);
  let match;
  while (match = re.exec(str)) {
    yield match;
  }
}

将创建原始regexp的副本；这是为了避免在进行多重匹配时由于lastIndex属性的突变而产生的副作用。

此外，我们需要确保正则表达式具有全局标志，以避免无限循环。

我也很高兴看到，在提案的讨论中甚至提到了这个StackOverflow问题。

原始答案

您可以这样访问捕获组：

var myString=“something format_abc”；var myRegexp=/（？：^|\s）format_（.*？）（？：\s|$）/g；var myRegexp=新RegExp（“（？：^|\s）format_（.*？）（？：\s|$）”，“g”）；var matches=myRegexp.exec（myString）；console.log（匹配[1]）；//abc

如果有多个匹配项，您可以对它们进行迭代：

var myString=“something format_abc”；var myRegexp=新RegExp（“（？：^|\s）format_（.*？）（？：\s|$）”，“g”）；match=myRegexp.exec（myString）；while（匹配！=null）{//匹配的文本：匹配[0]//匹配开始：match.index//捕获组n：匹配[n]console.log（匹配[0]）match=myRegexp.exec（myString）；}

只需使用RegExp$第1…$n组如：

1.匹配第一组RegExp$1.

匹配第二组RegExp$2.

如果在正则表达式中使用3组（请注意在string.match（正则表达式）之后使用）

注册Exp$1 RegExp$2 RegExp$3.

var str=“${印度}的雨很安全”；var res=str.match（/\$｛（.*？）\｝/ig）；//我在上面的例子中只使用了一个组，所以RegExp$1.console.log（RegExp.$1）

//最简单的方法是使用RegExp$1正则表达式中的第一组和第二组//注册Exp$如果存在，则在匹配后使用2var正则表达式=/\$｛（.*？）\｝/ig；var str=“${SPAIN}的雨水主要停留在平原”；var res=str.match（正则表达式）；for（res的常量匹配）{var res=match.match（正则表达式）；console.log（匹配）；console.log（RegExp.$1）}

本回答中使用的术语：

Match表示对字符串运行RegEx模式的结果，例如：someString.Match（regexPattern）。匹配模式表示输入字符串的所有匹配部分，它们都位于匹配数组内。这些是输入字符串中模式的所有实例。匹配的组表示RegEx模式中定义的所有要捕获的组。（括号内的模式，如：/format_（.*？）/g，其中（.*！）将是匹配的组。）它们位于匹配的模式中。

描述

为了访问匹配的组，在每个匹配的模式中，您需要一个函数或类似的东西来迭代匹配。有很多方法可以做到这一点，正如许多其他答案所示。大多数其他答案使用while循环来遍历所有匹配的模式，但我认为我们都知道这种方法的潜在危险。需要匹配新的RegExp（），而不仅仅是模式本身，这只是在注释中提到的。这是因为.exec（）方法的行为类似于生成器函数——它在每次匹配时都会停止，但在下一次.exec）调用时保持.lastIndex继续。

代码示例

下面是一个函数searchString的示例，它返回所有匹配模式的数组，其中每个匹配都是一个包含所有匹配组的数组。我没有使用while循环，而是提供了使用Array.prototype.map（）函数的示例，以及一种更高效的方法——使用普通的for循环。

简洁的版本（更少的代码，更多的语法糖）

因为它们基本上实现了forEach循环，而不是更快的for循环，所以性能较差。

// Concise ES6/ES2015 syntax
const searchString = 
    (string, pattern) => 
        string
        .match(new RegExp(pattern.source, pattern.flags))
        .map(match => 
            new RegExp(pattern.source, pattern.flags)
            .exec(match));

// Or if you will, with ES5 syntax
function searchString(string, pattern) {
    return string
        .match(new RegExp(pattern.source, pattern.flags))
        .map(match =>
            new RegExp(pattern.source, pattern.flags)
            .exec(match));
}

let string = "something format_abc",
    pattern = /(?:^|\s)format_(.*?)(?:\s|$)/;

let result = searchString(string, pattern);
// [[" format_abc", "abc"], null]
// The trailing `null` disappears if you add the `global` flag

Performant版本（更多代码，更少语法糖）

// Performant ES6/ES2015 syntax
const searchString = (string, pattern) => {
    let result = [];

    const matches = string.match(new RegExp(pattern.source, pattern.flags));

    for (let i = 0; i < matches.length; i++) {
        result.push(new RegExp(pattern.source, pattern.flags).exec(matches[i]));
    }

    return result;
};

// Same thing, but with ES5 syntax
function searchString(string, pattern) {
    var result = [];

    var matches = string.match(new RegExp(pattern.source, pattern.flags));

    for (var i = 0; i < matches.length; i++) {
        result.push(new RegExp(pattern.source, pattern.flags).exec(matches[i]));
    }

    return result;
}

let string = "something format_abc",
    pattern = /(?:^|\s)format_(.*?)(?:\s|$)/;

let result = searchString(string, pattern);
// [[" format_abc", "abc"], null]
// The trailing `null` disappears if you add the `global` flag

我还没有将这些替代方案与其他答案中提到的替代方案进行比较，但我怀疑这种方法的性能和故障安全性不如其他方法。

即使我同意PhiLo的正则表达式应该是：

/\bformat_(.*?)\b/

（当然，我不确定，因为我不知道正则表达式的上下文。）

您的语法可能不是最好保留的。FF/Gekko将RegExp定义为Function的扩展。（FF2达到typeof（/patter/）==“函数”）

这似乎是FF特有的——IE、Opera和Chrome都有例外。

相反，使用其他人之前提到的方法：RegExp#exec或String#match。它们提供了相同的结果：

var regex = /(?:^|\s)format_(.*?)(?:\s|$)/;
var input = "something format_abc";

regex(input);        //=> [" format_abc", "abc"]
regex.exec(input);   //=> [" format_abc", "abc"]
input.match(regex);  //=> [" format_abc", "abc"]

您实际上不需要一个显式循环来解析多个匹配项-传递一个替换函数作为第二个参数，如String.protype.replace（regex，func）中所述：

var str=“我们的主要武器是｛1｝、｛0｝和｛2｝！”；var params=[“惊讶”、“恐惧”、“无情的效率”]；var模式=/{（[^}]+）}/g；str=str.replace（patt，函数（m0，m1，位置）｛return params[parseInt（m1）]；｝）；document.write（str）；

m0参数表示完全匹配的子字符串｛0｝、｛1｝等。m1表示第一个匹配组，即正则表达式中括号内的部分，第一个匹配为0。位置是字符串中找到匹配组的起始索引，在本例中未使用。