RegEx 使用 RegExp.exec 从字符串中提取所有匹配项

Question

我正在尝试解析以下类型的字符串：

[key:"val" key2:"val2"]

其中有任意 key:"val" 对。我想获取键名和值。 对于那些好奇的人，我正在尝试解析任务战士的数据库格式。

这是我的测试字符串：

[description:"aoeu" uuid:"123sth"]

它旨在强调除了空格之外的键或值中可以包含任何内容，冒号周围没有空格，并且值始终用双引号引起来。

在节点中，这是我的输出：

[deuteronomy][gatlin][~]$ node
> var re = /^\[(?:(.+?):"(.+?)"\s*)+\]$/g
> re.exec('[description:"aoeu" uuid:"123sth"]');
[ '[description:"aoeu" uuid:"123sth"]',
  'uuid',
  '123sth',
  index: 0,
  input: '[description:"aoeu" uuid:"123sth"]' ]

但是 description:"aoeu" 也匹配此模式。我怎样才能取回所有匹配项？

Answer 1

继续循环调用 re.exec(s) 来获取所有匹配项：

var re = /\s*([^[:]+):\"([^"]+)"/g;
var s = '[description:"aoeu" uuid:"123sth"]';
var m;

do {
    m = re.exec(s);
    if (m) {
        console.log(m[1], m[2]);
    }
} while (m);

使用此 JSFiddle 尝试：https://jsfiddle.net/7yS2V/

Answer 2

str.match(pattern)，如果pattern具有全局标志g，将以数组形式返回所有匹配项。

例如：

const str = 'All of us except @Emran, @Raju and @Noman were there';
console.log(
  str.match(/@\w*/g)
);
// Will log ["@Emran", "@Raju", "@Noman"]

Answer 3

要循环遍历所有匹配项，您可以使用 replace 函数：

var re = /\s*([^[:]+):\"([^"]+)"/g;
var s = '[description:"aoeu" uuid:"123sth"]';

s.replace(re, function(match, g1, g2) { console.log(g1, g2); });

Answer 4

这是一个解决方案

var s = '[description:"aoeu" uuid:"123sth"]';

var re = /\s*([^[:]+):\"([^"]+)"/g;
var m;
while (m = re.exec(s)) {
  console.log(m[1], m[2]);
}

这是基于 Lawnsea 的答案，但更短。

请注意，必须设置“g”标志才能在调用之间向前移动内部指针。

Answer 5

str.match(/regex/g)

以数组形式返回所有匹配项。

如果出于某种神秘的原因，您需要 exec 附带的附加信息，作为先前答案的替代方案，您可以使用递归函数而不是循环来实现，如下所示（这看起来也更酷： ）。

function findMatches(regex, str, matches = []) {
   const res = regex.exec(str)
   res && matches.push(res) && findMatches(regex, str, matches)
   return matches
}

// Usage
const matches = findMatches(/regex/g, str)

正如之前的评论中所述，在正则表达式定义末尾添加 g 非常重要，这样可以在每次执行时向前移动指针。

Answer 6

我们终于开始看到内置的 matchAll 函数，请参阅 此处查看说明和兼容性表。截至 2020 年 5 月，似乎支持 Chrome、Edge、Firefox 和 Node.js (12+)，但不支持 IE、Safari 和 Opera。似乎是 起草于 2018 年 12 月，所以给到达所有浏览器还需要一些时间，但我相信它会到达那里。

内置的 matchAll 函数很好，因为它返回一个 可迭代。它还会返回每场比赛的捕获组！所以你可以做类似的事情

// get the letters before and after "o"
let matches = "stackoverflow".matchAll(/(\w)o(\w)/g);

for (match of matches) {
    console.log("letter before:" + match[1]);
    console.log("letter after:" + match[2]);
}

arrayOfAllMatches = [...matches]; // you can also turn the iterable into an array

似乎每个匹配对象都使用与 match()。因此，每个对象都是匹配组和捕获组的数组，以及三个附加属性 index、input 和 groups。所以它看起来像：

[<match>, <group1>, <group2>, ..., index: <match offset>, input: <original string>, groups: <named capture groups>]

有关 matchAll 的更多信息，还有一个 Google 开发者页面。还有 polyfills/shims 可用。

Answer 7

如果您有 ES9

（意味着您的系统：Chrome、Node.js、Deno、Bun、Firefox 等支持 Ecmascript 2019 或更高版本）

yourString.matchAll( /your-regex/g ) // dont forget the "g"

MDN 文档

如果你使用NPM

你可以使用官方的polyfill
npm install string.prototype.matchall

const matchAll = require('string.prototype.matchall')
console.log( [...  matchAll('blah1 blah2',/blah/g)  ] )
//[
//  [ 'blah', index: 0, input: 'blah1 blah2', groups: undefined ],
//  [ 'blah', index: 6, input: 'blah1 blah2', groups: undefined ]
//]

否则，

这是一些功能相似的复制粘贴版本

// returns an array, works on super old javascript (ES3 -- 1999)
function findAll(regexPattern, sourceString) {
    var output = []
    var match
    // auto-add global flag while keeping others as-is
    var regexPatternWithGlobal = regexPattern.global ? regexPattern : RegExp(regexPattern, regexPattern.flags+"g")
    while (match = regexPatternWithGlobal.exec(sourceString)) {
        // store the match data
        output.push(match)
        // zero-length matches will end up in an infinite loop, so increment by one char after a zero-length match is found
        if (match[0].length == 0) {
            regexPatternWithGlobal.lastIndex += 1
        }
    }
    return output
}

// this version returns an iterator, which is good for large results
// note: iterators require ES6 - 2015 standard
function* findAll(regexPattern, sourceString) {
    var match
    // auto-add global flag while keeping others as-is
    const regexPatternWithGlobal = regexPattern.global ? regexPattern : RegExp(regexPattern, regexPattern.flags+"g")
    while (match = regexPatternWithGlobal.exec(sourceString)) {
        // store the match data
        yield match
        // zero-length matches will end up in an infinite loop, so increment by one char after a zero-length match is found
        if (match[0].length == 0) {
            regexPatternWithGlobal.lastIndex += 1
        }
    }
    return output
}

示例用法：

console.log(   findAll(/blah/g,'blah1 blah2')   ) 

输出：

[ [ 'blah', index: 0 ], [ 'blah', index: 6 ] ]

Answer 8

基于 Agus 的函数，但我更喜欢只返回匹配值：

var bob = "> bob <";
function matchAll(str, regex) {
    var res = [];
    var m;
    if (regex.global) {
        while (m = regex.exec(str)) {
            res.push(m[1]);
        }
    } else {
        if (m = regex.exec(str)) {
            res.push(m[1]);
        }
    }
    return res;
}
var Amatch = matchAll(bob, /(&.*?;)/g);
console.log(Amatch);  // yeilds: [>, <]

Answer 9

可迭代更好：

const matches = (text, pattern) => ({
  [Symbol.iterator]: function * () {
    const clone = new RegExp(pattern.source, pattern.flags);
    let match = null;
    do {
      match = clone.exec(text);
      if (match) {
        yield match;
      }
    } while (match);
  }
});

在循环中使用：

for (const match of matches('abcdefabcdef', /ab/g)) {
  console.log(match);
}

或者如果你想要一个数组：

[ ...matches('abcdefabcdef', /ab/g) ]

Answer 10

这是我获取匹配的函数：

function getAllMatches(regex, text) {
    if (regex.constructor !== RegExp) {
        throw new Error('not RegExp');
    }

    var res = [];
    var match = null;

    if (regex.global) {
        while (match = regex.exec(text)) {
            res.push(match);
        }
    }
    else {
        if (match = regex.exec(text)) {
            res.push(match);
        }
    }

    return res;
}

// Example:

var regex = /abc|def|ghi/g;
var res = getAllMatches(regex, 'abcdefghi');

res.forEach(function (item) {
    console.log(item[0]);
});

Answer 11

如果您能够使用 matchAll 这里有一个技巧：

Array.From 有一个“选择器”参数，这样您就不会以一组尴尬的“匹配”结果结束可以将其投影到您真正需要的内容：

Array.from(str.matchAll(regexp), m => m[0]);

如果您有命名组，例如。 (/(?[az][AZ]+)/g) 你可以这样做：

Array.from(str.matchAll(regexp), m => m.groups.firstName);

Answer 12

自 ES9 以来，现在有一种更简单、更好的方法来获取所有匹配项，以及有关捕获组及其索引的信息：

const string = 'Mice like to dice rice';
const regex = /.ice/gu;
for(const match of string.matchAll(regex)) {
    console.log(match);
}

// [“老鼠”，索引：0，输入：“老鼠喜欢切米”，组：
未定义]

// [“骰子”，索引：13，输入：“老鼠喜欢切米”，
组：未定义]

// [“米”，索引：18，输入：“老鼠喜欢骰子
Rice”，组：未定义]

目前在 Chrome、Firefox、Opera 中受支持。根据您阅读本文的时间，请检查 此链接 查看其当前支持。

Answer 13

使用这个...

var all_matches = your_string.match(re);
console.log(all_matches)

它将返回所有匹配的数组...那就可以了...
但请记住，它不会考虑组......它只会返回完整的比赛......

Answer 14

我绝对推荐使用 String.match() 函数，并为其创建一个相关的正则表达式。我的示例是一个字符串列表，在扫描用户输入的关键字和短语时，这通常是必需的。

    // 1) Define keywords
    var keywords = ['apple', 'orange', 'banana'];

    // 2) Create regex, pass "i" for case-insensitive and "g" for global search
    regex = new RegExp("(" + keywords.join('|') + ")", "ig");
    => /(apple|orange|banana)/gi

    // 3) Match it against any string to get all matches 
    "Test string for ORANGE's or apples were mentioned".match(regex);
    => ["ORANGE", "apple"]

希望这有帮助！

Answer 15

这并不能真正帮助解决您更复杂的问题，但无论如何我都会发布此内容，因为对于不像您那样进行全局搜索的人来说，这是一个简单的解决方案。

我已经简化了答案中的正则表达式以使其更加清晰（这不是您确切问题的解决方案）。

var re = /^(.+?):"(.+)"$/
var regExResult = re.exec('description:"aoeu"');
var purifiedResult = purify_regex(regExResult);

// We only want the group matches in the array
function purify_regex(reResult){

  // Removes the Regex specific values and clones the array to prevent mutation
  let purifiedArray = [...reResult];

  // Removes the full match value at position 0
  purifiedArray.shift();

  // Returns a pure array without mutating the original regex result
  return purifiedArray;
}

// purifiedResult= ["description", "aoeu"]

由于有注释，这看起来比实际情况更详细，这就是没有注释的情况。

var re = /^(.+?):"(.+)"$/
var regExResult = re.exec('description:"aoeu"');
var purifiedResult = purify_regex(regExResult);

function purify_regex(reResult){
  let purifiedArray = [...reResult];
  purifiedArray.shift();
  return purifiedArray;
}

请注意，任何不匹配的组都将在数组中作为 未定义 值列出。

该解决方案使用 ES6 扩展运算符来净化正则表达式特定值的数组。如果您想要 IE11 支持，您需要通过 Babel 运行代码。

Answer 16

这是一个没有 while 循环的单行解决方案。

该顺序保留在结果列表中。

潜在的缺点是

1. 它会克隆每场比赛的正则表达式。
2. 结果的形式与预期的解决方案不同。您需要再处理一次。

let re = /\s*([^[:]+):\"([^"]+)"/g
let str = '[description:"aoeu" uuid:"123sth"]'

(str.match(re) || []).map(e => RegExp(re.source, re.flags).exec(e))

[ [ 'description:"aoeu"',
    'description',
    'aoeu',
    index: 0,
    input: 'description:"aoeu"',
    groups: undefined ],
  [ ' uuid:"123sth"',
    'uuid',
    '123sth',
    index: 0,
    input: ' uuid:"123sth"',
    groups: undefined ] ]

Answer 17

我的猜测是，如果存在额外或缺失空格等边缘情况，那么边界较少的表达式也可能是一种选择：

^\s*\[\s*([^\s\r\n:]+)\s*:\s*"([^"]*)"\s*([^\s\r\n:]+)\s*:\s*"([^"]*)"\s*\]\s*$

---

如果您想探索/简化/修改表达式，它已经
右上方面板上有解释
regex101.com。如果你愿意的话，你
也可以在这个中观看
链接，它如何匹配
针对一些示例输入。

---

测试

const regex = /^\s*\[\s*([^\s\r\n:]+)\s*:\s*"([^"]*)"\s*([^\s\r\n:]+)\s*:\s*"([^"]*)"\s*\]\s*$/gm;
const str = `[description:"aoeu" uuid:"123sth"]
[description : "aoeu" uuid: "123sth"]
[ description : "aoeu" uuid: "123sth" ]
 [ description : "aoeu"   uuid : "123sth" ]
 [ description : "aoeu"uuid  : "123sth" ] `;
let m;

while ((m = regex.exec(str)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (m.index === regex.lastIndex) {
        regex.lastIndex++;
    }
    
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

正则表达式电路

jex.im 可视化正则表达式：

Answer 18

const re = /^\[(?:(.+?):"(.+?)"\s*)+\]$/g
const matches = [...re.exec('[description:"aoeu" uuid:"123sth"]').entries()]
console.log(matches)

Basically, this is ES6 way to convert Iterator returned by exec to a regular Array

Answer 19

这是我的回答：

var str = '[me nombre es] : My name is. [Yo puedo] is the right word'; 

var reg = /\[(.*?)\]/g;

var a = str.match(reg);

a = a.toString().replace(/[\[\]]/g, "").split(','));