Как вы получаете доступ к соответствующим группам в регулярном выражении JavaScript?

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

var myString = "something format_abc"; // I want "abc"

var arr = /(?:^|\s)format_(.*?)(?:\s|$)/.exec(myString);

console.log(arr);     // Prints: [" format_abc", "abc"] .. so far so good.
console.log(arr[1]);  // Prints: undefined  (???)
console.log(arr[0]);  // Prints: format_undefined (!!!)

Что я делаю неправильно?

Я обнаружил, что в коде регулярного выражения не было ничего плохого: фактическая строка, с которой я проверял, была такова:

"date format_%A"

Сообщение о том, что «% A» не определено, кажется очень странным поведением, но оно не имеет прямого отношения к этому вопросу, поэтому я открыл новый вопрос. Почему совпадающая подстрока возвращает «undefined» в JavaScript? ,

Проблема заключалась в том, что console.logего параметры воспринимаются как printfоператор, и поскольку строка, которую я записывал ( "%A"), имела специальное значение, она пыталась найти значение следующего параметра.

Вы можете получить доступ к группам захвата следующим образом:

var myString = "something format_abc";
var myRegexp = /(?:^|\s)format_(.*?)(?:\s|$)/g;
var match = myRegexp.exec(myString);
console.log(match[1]); // abc

И если есть несколько совпадений, вы можете перебрать их:

var myString = "something format_abc";
var myRegexp = /(?:^|\s)format_(.*?)(?:\s|$)/g;
match = myRegexp.exec(myString);
while (match != null) {
  // matched text: match[0]
  // match start: match.index
  // capturing group n: match[n]
  console.log(match[0])
  match = myRegexp.exec(myString);
}

Изменить: 2019-09-10

Как видите, способ итерации по нескольким совпадениям был не очень интуитивным. Это привело к предложению String.prototype.matchAllметода. Ожидается, что этот новый метод будет включен в спецификацию ECMAScript 2020 . Это дает нам чистый API и решает множество проблем. Он был запущен на основных браузерах и движках JS, таких как Chrome 73+ / Node 12+ и Firefox 67+.

Метод возвращает итератор и используется следующим образом:

const string = "something format_abc";
const regexp = /(?:^|\s)format_(.*?)(?:\s|$)/g;
const matches = string.matchAll(regexp);
    
for (const match of matches) {
  console.log(match);
  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]);
}

Пока же это предложение получает более широкую поддержку, вы можете использовать официальный пакет shim .

Кроме того, внутренняя работа метода проста. Эквивалентная реализация с использованием функции генератора будет выглядеть следующим образом:

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

Копия оригинального регулярного выражения создана; это позволяет избежать побочных эффектов из-за мутации lastIndexсвойства при прохождении нескольких совпадений.

Также нам нужно убедиться, что регулярное выражение имеет глобальный флаг, чтобы избежать бесконечного цикла.

Я также рад видеть, что даже этот вопрос StackOverflow упоминался в обсуждениях предложения .

Вот метод, который вы можете использовать, чтобы получить n- ую группу захвата для каждого совпадения:

function getMatches(string, regex, index) {
  index || (index = 1); // default to the first capturing group
  var matches = [];
  var match;
  while (match = regex.exec(string)) {
    matches.push(match[index]);
  }
  return matches;
}


// Example :
var myString = 'something format_abc something format_def something format_ghi';
var myRegEx = /(?:^|\s)format_(.*?)(?:\s|$)/g;

// Get an array containing the first capturing group for every match
var matches = getMatches(myString, myRegEx, 1);

// Log results
document.write(matches.length + ' matches found: ' + JSON.stringify(matches))
console.log(matches);

var myString = "something format_abc";
var arr = myString.match(/\bformat_(.*?)\b/);
console.log(arr[0] + " " + arr[1]);

Это \bне совсем то же самое. (Это работает --format_foo/, но не работает format_a_b) Но я хотел показать альтернативу вашему выражению, что хорошо. Конечно, matchзвонок - важная вещь.

Что касается приведенных выше примеров скобок с несколькими совпадениями, я искал здесь ответ, не получив того, что хотел:

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

Посмотрев на слегка запутанные вызовы функций с помощью while и .push () выше, я понял, что проблема может быть очень элегантно решена с помощью mystring.replace () вместо этого (замена - это НЕ точка, и даже не сделано , ЧИСТАЯ, опция встроенного рекурсивного вызова функции для второго параметра есть!):

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 () для чего-либо.

И последнее, но не менее важное: я нашел одну строку кода, которая отлично сработала для меня (JS ES6):

let reg = /#([\S]+)/igm; // Get hashtags.
let string = 'mi alegría es total! ✌🙌\n#fiestasdefindeaño #PadreHijo #buenosmomentos #france #paris';

let matches = (string.match(reg) || []).map(e => e.replace(reg, '$1'));
console.log(matches);

Это вернет:

['fiestasdefindeaño', 'PadreHijo', 'buenosmomentos', 'france', 'paris']

Терминология, использованная в этом ответе:

• Match показывает результат выполнения вашего шаблона RegEx против вашей строки следующим образом: someString.match(regexPattern).
• Совпадающие шаблоны указывают на все совпадающие части входной строки, которые все находятся в массиве совпадений . Это все экземпляры вашего шаблона внутри входной строки.
• Совпадающие группы указывают на все группы, которые нужно поймать, определенные в шаблоне RegEx. (Шаблоны в круглых скобках, например, так /format_(.*?)/g, где (.*?)будет сопоставленная группа.) Они находятся в согласованных шаблонах .

Описание

Чтобы получить доступ к сопоставленным группам , в каждом из сопоставленных шаблонов вам нужна функция или нечто подобное для итерации по совпадению . Есть много способов сделать это, как показывают многие другие ответы. Большинство других ответов используют цикл while для итерации по всем сопоставленным шаблонам , но я думаю, что мы все знаем о потенциальных опасностях такого подхода. Необходимо сопоставлять new RegExp()вместо самого шаблона, который упоминается только в комментарии. Это связано с тем, что .exec()метод ведет себя аналогично функции генератора - он останавливается каждый раз, когда происходит совпадение , но сохраняет его .lastIndexдля продолжения оттуда при следующем .exec()вызове.

Примеры кода

Ниже приведен пример функции, searchStringкоторая возвращает один Arrayиз всех сопоставленных шаблонов , где каждый matchпредставляет собой Arrayсо всеми содержащимися сопоставленными группами . Вместо использования цикла while, я привел примеры, использующие как Array.prototype.map()функцию, так и более производительный способ - использование обычного for-loop.

Краткие версии (меньше кода, больше синтаксического сахара)

Они менее производительны, так как они в основном реализуют forEach-loop вместо более быстрого for-loop.

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

Мне еще предстоит сравнить эти альтернативы с ранее упомянутыми в других ответах, но я сомневаюсь, что этот подход менее эффективен и менее надежен, чем другие.

String#matchAll(см. черновой вариант 3 / предложение от 7 декабря 2018 г. ) упрощает доступ ко всем группам в объекте сопоставления (помните, что группа 0 - это полное совпадение, в то время как другие группы соответствуют группам захвата в шаблоне):

С matchAllналичии, вы можете избежать whileпетли и execс /g... Вместо этого, с помощью matchAll, вы получите обратно итератор , который можно использовать с более удобными for...of, распространенных массив или Array.from()конструкций

Этот метод дает аналогичный вывод Regex.Matchesв C #, re.finditerв Python, preg_match_allв PHP.

См. Демонстрацию JS (протестировано в Google Chrome 73.0.3683.67 (официальная сборка), бета-версия (64-разрядная версия)):

var myString = "key1:value1, key2-value2!!@key3=value3";
var matches = myString.matchAll(/(\w+)[:=-](\w+)/g);
console.log([...matches]); // All match with capturing group values

В console.log([...matches])шоу

Вы также можете получить значение соответствия или конкретные значения группы, используя

let matchData = "key1:value1, key2-value2!!@key3=value3".matchAll(/(\w+)[:=-](\w+)/g)
var matches = [...matchData]; // Note matchAll result is not re-iterable

console.log(Array.from(matches, m => m[0])); // All match (Group 0) values
// => [ "key1:value1", "key2-value2", "key3=value3" ]
console.log(Array.from(matches, m => m[1])); // All match (Group 1) values
// => [ "key1", "key2", "key3" ]

ПРИМЕЧАНИЕ . См. Сведения о совместимости браузера .

Ваш синтаксис, вероятно, не лучший для сохранения. FF / Gecko определяет RegExp как расширение функции.
(FF2 дошел до typeof(/pattern/) == 'function')

Кажется, что это специфично для 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"]

Нет необходимости вызывать execметод! Вы можете использовать метод "match" прямо в строке. Просто не забывайте скобки.

var str = "This is cool";
var matches = str.match(/(This is)( cool)$/);
console.log( JSON.stringify(matches) ); // will print ["This is cool","This is"," cool"] or something like that...

Позиция 0 содержит строку со всеми результатами. Позиция 1 имеет первое совпадение, представленное круглыми скобками, а позиция 2 имеет второе совпадение, изолированное в ваших круглых скобках. Вложенные скобки сложны, так что будьте осторожны!

Один вкладыш, который практичен, только если у вас есть одна пара круглых скобок:

while ( ( match = myRegex.exec( myStr ) ) && matches.push( match[1] ) ) {};

Используя ваш код:

console.log(arr[1]);  // prints: abc
console.log(arr[0]);  // prints:  format_abc

Изменить: Safari 3, если это имеет значение.

С es2018 вы можете теперь String.match()с именованными группами, делает ваше регулярное выражение более явным из того, что он пытался сделать.

const url =
  '/programming/432493/how-do-you-access-the-matched-groups-in-a-javascript-regular-expression?some=parameter';
const regex = /(?<protocol>https?):\/\/(?<hostname>[\w-\.]*)\/(?<pathname>[\w-\./]+)\??(?<querystring>.*?)?$/;
const { groups: segments } = url.match(regex);
console.log(segments);

и вы получите что-то вроде

{protocol: "https", имя хоста: "stackoverflow.com", имя пути: "questions / 432493 / how-do-you-you-access-the-matched-groups-in-a-javascript-регулярное выражение", строка запроса: " некоторые = параметр "}

Ваш код работает для меня (FF3 на Mac), даже если я согласен с PhiLo, что регулярное выражение должно быть:

/\bformat_(.*?)\b/

(Но, конечно, я не уверен, потому что я не знаю контекст регулярного выражения.)

/*Regex function for extracting object from "window.location.search" string.
 */

var search = "?a=3&b=4&c=7"; // Example search string

var getSearchObj = function (searchString) {

    var match, key, value, obj = {};
    var pattern = /(\w+)=(\w+)/g;
    var search = searchString.substr(1); // Remove '?'

    while (match = pattern.exec(search)) {
        obj[match[0].split('=')[0]] = match[0].split('=')[1];
    }

    return obj;

};

console.log(getSearchObj(search));

Вам на самом деле не нужен явный цикл для анализа нескольких совпадений - передайте функцию замены в качестве второго аргумента, как описано в String.prototype.replace(regex, func):

var str = "Our chief weapon is {1}, {0} and {2}!"; 
var params= ['surprise', 'fear', 'ruthless efficiency'];
var patt = /{([^}]+)}/g;

str=str.replace(patt, function(m0, m1, position){return params[parseInt(m1)];});

document.write(str);

m0Аргумент представляет полную найденную подстроку {0}, {1}и т.д. m1представляет собой первую группу соответствия, то есть та часть , заключенная в скобках в регулярном выражении , который 0для первого матча. И positionявляется начальным индексом в строке, где была найдена соответствующая группа - в этом случае не используется.

Мы можем получить доступ к сопоставленной группе в регулярных выражениях, используя обратную косую черту, за которой следует номер соответствующей группы:

/([a-z])\1/

В коде \ 1 представлено соответствие первой группе ([az])

Одноканальное решение:

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

Таким образом, вы можете использовать этот способ (необходимо использовать / г):

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

результат:

[" format_abc"]

Получить все вхождения группы

let m=[], s = "something format_abc  format_def  format_ghi";

s.replace(/(?:^|\s)format_(.*?)(?:\s|$)/g, (x,y)=> m.push(y));

console.log(m);

Если вы похожи на меня и хотите, чтобы регулярные выражения возвращали объект как этот:

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

затем отрежьте функцию снизу

/**
 * @param {string | number} input
 *          The input string to match
 * @param {regex | string}  expression
 *          Regular expression 
 * @param {string} flags
 *          Optional Flags
 * 
 * @returns {array}
 * [{
    match: '...',
    matchAtIndex: 0,
    capturedGroups: [ '...', '...' ]
  }]     
 */
function regexMatch(input, expression, flags = "g") {
  let regex = expression instanceof RegExp ? expression : new RegExp(expression, flags)
  let matches = input.matchAll(regex)
  matches = [...matches]
  return matches.map(item => {
    return {
      match: item[0],
      matchAtIndex: item.index,
      capturedGroups: item.length > 1 ? item.slice(1) : undefined
    }
  })
}

let input = "key1:value1, key2:value2 "
let regex = /(\w+):(\w+)/g

let matches = regexMatch(input, regex)

console.log(matches)

ПРОСТО ИСПОЛЬЗУЙТЕ RegExp. $ 1 ... $ n-ю группу, например:

1. Для соответствия 1-й группе RegExp. $ 1

2. Для соответствия 2-й группе RegExp. $ 2

если вы используете 3 группы в регулярных выражениях подобно (обратите внимание на использование после string.match (регулярное выражение))

RegExp. $ 1 RegExp. $ 2 RegExp. $ 3

 var str = "The rain in ${india} stays safe"; 
  var res = str.match(/\${(.*?)\}/ig);
  //i used only one group in above example so RegExp.$1
console.log(RegExp.$1)

//easiest way is use RegExp.$1 1st group in regex and 2nd grounp like
 //RegExp.$2 if exist use after match

var regex=/\${(.*?)\}/ig;
var str = "The rain in ${SPAIN} stays ${mainly} in the plain"; 
  var res = str.match(regex);
for (const match of res) {
  var res = match.match(regex);
  console.log(match);
  console.log(RegExp.$1)
 
}