关于上面的多匹配括号示例，我在没有得到我想要的答案后，在这里寻找答案：

var matches = mystring.match(/(?:neededToMatchButNotWantedInResult)(matchWanted)/igm);

在查看了上面while和.push（）的稍微复杂的函数调用之后，我发现这个问题可以用mystring.replace（）非常优雅地解决（替换不是重点，甚至还没有完成，第二个参数的CLEAN内置递归函数调用选项是！）：

var yourstring = 'something format_abc something format_def something format_ghi';

var matches = [];
yourstring.replace(/format_([^\s]+)/igm, function(m, p1){ matches.push(p1); } );

在这之后，我想我再也不会用.match（）做任何事情了。

您的语法可能不是最好保留的。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"]

如果你和我一样，希望正则表达式返回这样的Object：

{
    match: '...',
    matchAtIndex: 0,
    capturedGroups: [ '...', '...' ]
}

然后从下面剪切函数

/***@param｛string | number｝输入*要匹配的输入字符串*@param｛regex | string｝表达式*正则表达式*@param｛string｝标志*可选标志* *@return｛array｝* [{匹配：“…”，matchAtIndex:0，捕获的组：[“…”，“…”]}] */函数regexMatch（输入，表达式，标志=“g”）{让regex=RegExp的表达式实例？表达式：新RegExp（表达式，标志）let matches=input.matchAll（正则表达式）匹配=[…匹配]return matches.map（项=>{返回{匹配：项[0]，matchAtIndex：项索引，捕获组：item.length>1？item.s切片（1）：未定义}})}let input=“key1:value1，key2:value2”让正则表达式=/（\w+）：（\w＋）/glet matches=regexMatch（输入，regex）console.log（匹配项）

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

/\bformat_(.*?)\b/

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

本回答中使用的术语：

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

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

单线解决方案：

const matches = (text,regex) => [...text.matchAll(regex)].map(([match])=>match)

因此您可以使用这种方式（必须使用/g）：

matches("something format_abc", /(?:^|\s)format_(.*?)(?:\s|$)/g)

结果：

[" format_abc"]