Jak uzyskać dostęp do dopasowanych grup w wyrażeniu regularnym JavaScript?

Chcę dopasować część ciągu za pomocą wyrażenia regularnego, a następnie uzyskać dostęp do podanego w nawiasie podłańcucha:

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 (!!!)

Co ja robię źle?

Odkryłem, że nie było nic złego w powyższym kodzie wyrażeń regularnych: ciąg, który testowałem, był następujący:

"date format_%A"

Zgłaszanie, że „% A” jest niezdefiniowane, wydaje się bardzo dziwnym zachowaniem, ale nie jest bezpośrednio związane z tym pytaniem, więc otworzyłem nowe, Dlaczego dopasowane JavaScript zwraca „niezdefiniowane” w JavaScript? .

Problem polegał na tym, że console.logjego parametry były traktowane jak printfinstrukcja, a ponieważ ciąg, który logowałem ( "%A") miał specjalną wartość, próbował znaleźć wartość następnego parametru.

Możesz uzyskać dostęp do takich grup przechwytywania:

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

A jeśli jest wiele dopasowań, możesz je powtarzać:

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

Edycja: 10.09.2019

Jak widać sposób powtarzania wielu meczów nie był zbyt intuicyjny. Doprowadziło to do propozycji String.prototype.matchAllmetody. Oczekuje się, że ta nowa metoda będzie dostępna w specyfikacji ECMAScript 2020 . Daje nam czysty interfejs API i rozwiązuje wiele problemów. Rozpoczęło się na głównych przeglądarkach i silnikach JS jako Chrome 73+ / Node 12+ i Firefox 67+.

Metoda zwraca iterator i jest używana w następujący sposób:

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

Gdy zwraca iterator, możemy powiedzieć, że jest leniwy, co jest użyteczne przy obsłudze szczególnie dużej liczby grup przechwytywania lub bardzo dużych ciągów. Ale jeśli potrzebujesz, wynik można łatwo przekształcić w tablicę za pomocą składni rozprzestrzeniania lub Array.frommetody:

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

W międzyczasie, podczas gdy ta propozycja zyskuje szersze poparcie, możesz skorzystać z oficjalnego pakietu shim .

Również wewnętrzne funkcjonowanie metody jest proste. Równoważna implementacja korzystająca z funkcji generatora wyglądałaby następująco:

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

Zostanie utworzona kopia oryginalnego wyrażenia regularnego; ma to na celu uniknięcie skutków ubocznych spowodowanych mutacją lastIndexwłaściwości podczas przechodzenia przez wiele dopasowań.

Musimy również upewnić się, że wyrażenie regularne ma flagę globalną, aby uniknąć nieskończonej pętli.

Cieszę się również, że w dyskusji nad propozycją przywoływano nawet to pytanie StackOverflow .

Oto metoda, za pomocą której można uzyskać n- tą grupę przechwytywania dla każdego dopasowania:

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

To \bnie jest dokładnie to samo. (Działa --format_foo/, ale nie działa format_a_b) Ale chciałem pokazać alternatywę dla twojego wyrażenia, co jest w porządku. Oczywiście matchpołączenie jest ważne.

Jeśli chodzi o powyższe przykłady nawiasów wielokrotnych powyżej, szukałem tutaj odpowiedzi po tym, jak nie otrzymałem tego, czego chciałem:

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

Po spojrzeniu na nieco skomplikowane wywołania funkcji z while i .push () powyżej, przyszło mi do głowy, że problem można rozwiązać bardzo elegancko za pomocą mystring.replace () zamiast tego (zamiana NIE jest celem, a nawet nie jest zrobiona , CZYSTA, wbudowana opcja wywołania funkcji rekurencyjnej dla drugiego parametru to!):

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

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

Po tym nie sądzę, żebym kiedykolwiek używał .match () do prawie niczego więcej.

Wreszcie znalazłem jeden wiersz kodu, który działał dla mnie dobrze (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);

Zwróci to:

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

Terminologia użyta w tej odpowiedzi:

• Mecz wskazuje wynik prowadzenie wzór regex przeciw ciąg tak: someString.match(regexPattern).
• Dopasowane wzorce wskazują wszystkie pasujące części ciągu wejściowego, które wszystkie znajdują się w tablicy dopasowania . Są to wszystkie wystąpienia wzorca w ciągu wejściowym.
• Dopasowane grupy wskazują wszystkie grupy do złapania, zdefiniowane we wzorze RegEx. (Wzory w nawiasach, takie jak:, /format_(.*?)/ggdzie (.*?)byłaby dopasowana grupa.) Znajdują się one w dopasowanych wzorach .

Opis

Aby uzyskać dostęp do dopasowanych grup , w każdym dopasowanym wzorcu potrzebujesz funkcji lub czegoś podobnego do iteracji po dopasowaniu . Istnieje wiele sposobów, aby to zrobić, jak pokazuje wiele innych odpowiedzi. Większość innych odpowiedzi wykorzystuje pętlę while do iteracji wszystkich dopasowanych wzorców , ale myślę, że wszyscy znamy potencjalne niebezpieczeństwa związane z takim podejściem. Konieczne jest dopasowanie do new RegExp()samego wzorca, o którym wspomniano tylko w komentarzu. Wynika to z faktu, że .exec()metoda zachowuje się podobnie do funkcji generatora - zatrzymuje się za każdym razem, gdy występuje dopasowanie , ale .lastIndexkontynuuje ją od następnego .exec()wywołania.

Przykłady kodu

Poniżej znajduje się przykład funkcję searchString, która zwraca Arrayna wszystkich dopasowanych wzorców , gdzie każdy matchoznacza Arrayze wszystkie zawierającego grupy dopasowane . Zamiast używać pętli while, podałem przykłady, używając zarówno Array.prototype.map()funkcji, jak i bardziej wydajnego sposobu - używając zwykłej forpętli.

Zwięzłe wersje (mniej kodu, więcej cukru syntaktycznego)

Są one mniej wydajne, ponieważ w zasadzie implementują forEachpętlę zamiast szybszej forpętli.

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

Wersje performanckie (więcej kodu, mniej cukru syntaktycznego)

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

Muszę jeszcze porównać te alternatywy z poprzednio wymienionymi w innych odpowiedziach, ale wątpię, aby to podejście było mniej wydajne i mniej bezpieczne w przypadku awarii niż inne.

String#matchAll(patrz propozycja etapu 3/7 grudnia 2018 r. ), upraszcza dostęp do wszystkich grup w obiekcie dopasowania (pamiętaj, że grupa 0 to całe dopasowanie, podczas gdy kolejne grupy odpowiadają grupom przechwytywania we wzorcu):

Z matchAlldostępnych, można uniknąć whilepętli i execz /g... Zamiast tego, za pomocą matchAll, wrócisz iterator, który można wykorzystać w bardziej dogodnych for...of, rozpostartymi tablica lub Array.from()konstruktami

Ta metoda daje wynik podobny do Regex.MatchesC #, re.finditerw Pythonie, preg_match_allw PHP.

Zobacz wersję demonstracyjną JS (przetestowaną w Google Chrome 73.0.3683.67 (oficjalna wersja), beta (64-bit)):

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

te console.log([...matches])pokazy

Możesz również uzyskać wartość dopasowania lub określone wartości grupy za pomocą

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

UWAGA : Zobacz szczegóły zgodności przeglądarki .

Twoja składnia prawdopodobnie nie jest najlepsza do zachowania. FF / Gecko definiuje RegExp jako rozszerzenie funkcji.
(FF2 poszedł tak daleko typeof(/pattern/) == 'function')

Wygląda na to, że jest to specyficzne dla FF - IE, Opery i Chrome - wszystkie zgłaszają wyjątki.

Zamiast tego użyj jednej z metod wcześniej wspomnianych przez innych: RegExp#execlub String#match.
Oferują te same wyniki:

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

Nie ma potrzeby wywoływania execmetody! Możesz użyć metody „dopasuj” bezpośrednio na łańcuchu. Tylko nie zapomnij nawiasów.

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

Pozycja 0 ma ciąg ze wszystkimi wynikami. Pozycja 1 ma pierwsze dopasowanie w nawiasach, a pozycja 2 ma drugie dopasowanie w nawiasach. Zagnieżdżone nawiasy są trudne, więc uważaj!

Jedna wkładka, która jest praktyczna tylko wtedy, gdy masz jedną parę nawiasów:

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

Za pomocą kodu:

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

Edycja: Safari 3, jeśli ma to znaczenie.

Dzięki es2018 możesz teraz używać String.match()nazwanych grup, dzięki czemu wyrażenia regularne są bardziej wyraźne w stosunku do tego, co próbował zrobić.

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

i dostaniesz coś takiego

{protokół: „https”, nazwa hosta: „stackoverflow.com”, nazwa ścieżki: „pytania / 432493 / how-do-you-access-the-dopasowanych grup-w-wyrażeniu regularnym javascript”, kwerenda: „ some = parametr "}

Twój kod działa dla mnie (FF3 na Macu), nawet jeśli zgadzam się z PhiLo, że regex powinien być prawdopodobnie:

/\bformat_(.*?)\b/

(Ale oczywiście nie jestem pewien, ponieważ nie znam kontekstu wyrażenia regularnego.)

/*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));

Tak naprawdę nie potrzebujesz jawnej pętli do analizowania wielu dopasowań - przekaż funkcję zastępczą jako drugi argument, jak opisano w 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);

m0Argumentem reprezentuje pełną dopasowany podciąg {0}, {1}itp m1reprezentuje pierwszą grupę dopasowanie, czyli część w nawiasach w regex, który jest 0w pierwszym meczu. I positionjest indeksem początkowym w ciągu, w którym znaleziono pasującą grupę - w tym przypadku nieużywany.

Możemy uzyskać dostęp do dopasowanej grupy w wyrażeniach regularnych, używając odwrotnego ukośnika, a następnie numeru pasującej grupy:

/([a-z])\1/

W kodzie \ 1 reprezentowanym przez pierwszą grupę ([az])

Rozwiązanie jednoliniowe:

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

Możesz więc użyć tej metody (musisz użyć / g):

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

wynik:

[" format_abc"]

Uzyskaj wszystkie wystąpienia grupy

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

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

console.log(m);

Jestem podobny do mnie i chciałbym, aby wyrażenie regularne zwróciło Obiekt taki:

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

następnie wyciąć funkcję od dołu

/**
 * @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)

PO PROSTU UŻYJ RegExp. 1 $ ... $ n ta grupa np .:

1. Aby dopasować pierwszą grupę RegExp. 1 USD

2. Aby dopasować 2 grupę RegExp. 2 USD

jeśli użyjesz 3 grup w wyrażeniach regularnych (uwaga użyj po string.match (regex))

RegExp. 1 USD RegExp. 2 USD RegExp. 3 USD

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