Продолжайте вызывать 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/

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"]

Чтобы просмотреть все совпадения, вы можете использовать функцию replace:

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

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

Это решение

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 'должен быть установлен для перемещения внутреннего указателя вперед между вызовами.

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 в конце определения регулярного выражения, чтобы перемещать указатель вперед при каждом выполнении.

Наконец-то мы начали видеть встроенную функцию matchAll, см. здесь для описания и таблицы совместимости. Похоже, что с мая 2020 года поддерживаются Chrome, Edge, Firefox и Node.js (12+), но не IE, Safari и Opera. Похоже, он был разработан в декабре 2018 года, так что давайте через какое-то время он будет доступен для всех браузеров, но я надеюсь, что он будет там.

Встроенная функция 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. Также доступны полифиллы / прокладки.

Если у вас ES9

(Имеется в виду, если ваша система: Chrome, Node.js, Firefox и т. Д. Поддерживает Ecmascript 2019 или новее)

Используйте новый yourString.matchAll( /your-regex/ ).

Если у вас нет ES9

Если у вас более старая система, вот функция для простого копирования и вставки

function findAll(regexPattern, sourceString) {
    let output = []
    let match
    // make sure the pattern has the global flag
    let regexPatternWithGlobal = RegExp(regexPattern,[...new Set("g"+regexPattern.flags)].join(""))
    while (match = regexPatternWithGlobal.exec(sourceString)) {
        // get rid of the string copy
        delete match.input
        // store the match data
        output.push(match)
    } 
    return output
}

пример использования:

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

выходы:

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

На основе функции Агуса, но я предпочитаю возвращать только совпадающие значения:

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: [>, <]

Итерируемые объекты лучше:

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) ]

Вот моя функция для получения совпадений:

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]);
});

Начиная с ES9, теперь есть более простой и лучший способ получить все совпадения вместе с информацией о группах захвата и их индексе:

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

// [мыши, индекс: 0, ввод: мыши любят нарезать рис, группы: undefined]

// [игральные кости, индекс: 13, ввод: мыши любят нарезать рис, группы: undefined]

// [рис, индекс: 18, ввод: мыши любят нарезать рис, группы: undefined]

В настоящее время поддерживается в Chrome, Firefox, Opera. В зависимости от того, когда вы это читаете, проверьте эту ссылку, чтобы увидеть его текущую поддержку.

Использовать этот...

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

Он вернет массив всех совпадений ... Это будет работать нормально ... Но помните, что он не будет учитывать группы в учетной записи ... Он просто вернет полные совпадения ...

Я бы определенно рекомендовал использовать функцию String.match () и создать для нее соответствующий RegEx. Мой пример - список строк, который часто бывает необходим при сканировании вводимых пользователем ключевых слов и фраз.

    // 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"]

Надеюсь это поможет!

На самом деле это не поможет с вашей более сложной проблемой, но я все равно публикую это, потому что это простое решение для людей, которые не выполняют глобальный поиск, как вы.

Я упростил регулярное выражение в ответе, чтобы было понятнее (это не решение вашей точной проблемы).

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;
}

Обратите внимание, что любые группы, которые не совпадают, будут перечислены в массиве как значения undefined.

Это решение использует оператор распространения ES6 для очистки массива значений, специфичных для регулярных выражений. Вам нужно будет запустить свой код через Babel, если вам нужна поддержка IE11.

Вот однострочное решение без цикла 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 ] ]

Я предполагаю, что если будут крайние случаи, такие как лишние или отсутствующие пробелы, это выражение с меньшими границами также может быть вариантом:

^\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}`);
    });
}

Цепь RegEx

jex.im визуализирует обычный выражения:

Если вы умеете использовать matchAll, вот трюк:

Array.From имеет параметр 'selector', поэтому вместо того, чтобы получить массив неудобных результатов 'совпадений', вы можете спроецировать его на то, что вам действительно нужно:

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

Если вы назвали группы, например. (/(?<firstname>[a-z][A-Z]+)/g) вы можете сделать это:

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

Вот мой ответ:

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(','));