JavaScript 정규식에서 일치하는 그룹에 어떻게 액세스합니까?


1368

정규 표현식을 사용하여 문자열의 일부를 일치시키고 괄호로 묶은 하위 문자열에 액세스 하고 싶습니다 .

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"가 정의되지 않았다고보고하는 것은 매우 이상한 행동으로 보이지만이 질문과 직접 ​​관련이 없으므로 새로운 질문을 열었습니다. JavaScript에서 일치하는 하위 문자열이 "undefined"를 반환하는 이유는 무엇입니까? .


문제는 명령문 console.log과 같은 매개 변수 를 취하는 것이며 printf, 내가 로깅하는 문자열 ( "%A")에 특별한 값이 있으므로 다음 매개 변수의 값을 찾으려고했습니다.

답변:


1673

다음과 같이 캡처 그룹에 액세스 할 수 있습니다.

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를 제공하고 여러 문제를 해결합니다. Chrome 73+ / Node 12+ 및 Firefox 67+와 같은 주요 브라우저 및 JS 엔진에 착륙하기 시작했습니다 .

이 메소드는 반복자를 리턴하며 다음과 같이 사용됩니다.

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 질문조차도 제안서 토론 에서 참조되었음을 알게되어 기쁩니다 .


114
+1 두 번째 예에서는 "/ myregexp /"뿐만 아니라 RegExp 객체를 사용해야합니다. 객체의 lastIndex 값을 유지하기 때문입니다. Regexp 객체를 사용하지 않으면 무한 반복됩니다
ianaz

7
@ ianaz : 나는 '정말 사실을 믿지 않습니까? 적어도 http://jsfiddle.net/weEg9/ 는 Chrome에서 작동하는 것 같습니다.
스피닝

16
왜 위의 것 대신에 : var match = myString.match(myRegexp); // alert(match[1])?
JohnAllen

29
명시적인 "새 RegExp"필요는 없지만 / g를 지정하지 않으면 무한 루프가 발생합니다.
George C

4
무한 루프에 빠지지 않는 또 다른 방법은 문자열을 명시 적으로 업데이트하는 것입니다.string = string.substring(match.index + match[0].length)
Olga

186

다음 은 각 경기에 대해 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);


12
이것은 하나를 얻는 것이 아니라 모든 일치에 대한 반복을 올바르게 표시하기 때문에 다른 것에 대한 훨씬 우수한 대답입니다.
Rob Evans

13
mnn이 맞습니다. 'g'플래그가 없으면 무한 루프가 생성됩니다. 이 기능에 매우주의하십시오.
Druska

4
파이썬의 re.findall ()과 비슷하게하기 위해 이것을 개선했습니다. 모든 일치 항목을 배열 배열로 그룹화합니다. 또한 전역 수정 자 무한 루프 문제를 해결합니다. jsfiddle.net/ravishi/MbwpV
ravishi

5
@MichaelMikowski는 이제 무한 루프를 숨겼지만 코드는 느리게 실행됩니다. 나는 나쁜 방법으로 코드를 나누는 것이 낫기 때문에 개발에서 코드를 잡는 것이 좋습니다. 일부 bs 최대 반복을 중단하면 부주의합니다. 근본 원인을 해결하는 대신 문제를 숨기는 것이 정답이 아닙니다.
wallacer

4
실행 한계에 도달하지 않을 때 의미있게 느려지는 @MichaelMikowski. 당신이있을 때, 그것은 분명히 훨씬 느립니다. 나는 당신의 코드가 작동하지 않는다고 말하는 것이 아니라 실제로 그것이 좋은 것보다 더 해를 끼칠 것이라고 생각합니다. 개발 환경에서 일하는 사람들은 코드 덩어리를 불필요하게 10,000 번 실행하더라도 코드가로드없이 잘 작동하는 것을 볼 수 있습니다. 그런 다음 프로덕션 환경으로 푸시하고 왜 앱이로드 상태에서 다운되는지 궁금합니다. 내 경험상 상황이 명백하게 깨어지면 개발주기가 더 일찍 나아지는 것이 좋습니다.
wallacer

58

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

\b똑같은 일이 아니다. ( --format_foo/에서는 작동 format_a_b하지만 작동하지 않습니다 ) 그러나 나는 당신의 표현에 대한 대안을 보여주고 싶었습니다. 물론 match전화는 중요한 것입니다.


2
정확히 반대입니다. '\ b'는 단어를 구분합니다. word = '\ w'= [a-zA-Z0-9_]입니다. "format_a_b"는 단어입니다.
BF

1
@BF 정직하게, 나는 format_a_b6 년 전에 생각했던대로 " 일을하지 않았다"를 추가했고, 내가 무슨 뜻인지 기억 나지 않는다 ... :-) "그냥 붙잡기 a위해서만 일하지 않았다"고 생각한다 . 즉. 이후의 첫 번째 알파벳 부분 format_.
PhiLho

1
"-"와 "/"는 \ word 문자가 아니기 때문에 \ b (-format_foo /} \ b는 "--format_foo /"를 반환하지 않습니다. 그러나 \ b (format_a_b) \ b는 "format_a_b를 반환합니다. ". 맞습니까? 나는 당신의 텍스트 진술을 둥근 괄호로 묶습니다. (아래로 투표하지 않았습니다!)
BF

31

위의 다중 일치 괄호 예제와 관련하여 원하는 것을 얻지 못한 후 여기에서 답변을 찾고있었습니다.

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 ()를 사용하지 않을 것이라고 생각합니다.


26

마지막으로, 저에게 잘 맞는 한 줄의 코드를 발견했습니다 (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']

1
팔! 그건 여기에 가장 우아한 솔루션입니다. Alexz 의 완전 접근 방식 보다 이것이 더 낫다는 것을 알았습니다. 왜냐하면 이것은 하나의 외관이 적고 여러 결과에 더 우아하기 때문입니다. 이것에 잘, Sebastien H.replace
Cody

이것은 잘 작동하여 확실히 내 utils에 들어갈 수 있습니다 :)
Cody

1
@Cody haha ​​감사합니다!
Sebastien H.

19

이 답변에 사용 된 용어 :

  • Match 는 다음과 같이 문자열에 대해 RegEx 패턴을 실행 한 결과를 나타냅니다 someString.match(regexPattern).
  • 일치 패턴 은 입력 문자열에서 일치하는 모든 부분을 나타내며, 모두 일치 배열 안에 있습니다. 이들은 입력 문자열 내부의 모든 패턴 인스턴스입니다.
  • 일치 그룹 은 RegEx 패턴에 정의 된 모든 그룹을 포착합니다. (괄호 안의 패턴과 같이 : /format_(.*?)/g여기서 (.*?)정합 기일 수있다.) 이러한 내에 상주 유사한 패턴 .

기술

받는 액세스 얻으려면 일치하는 그룹 의 각 일치 패턴 , 당신은 기능 또는 반복하는 비슷한 필요 일치 . 다른 많은 답변에서 볼 수 있듯이 여러 가지 방법으로이 작업을 수행 할 수 있습니다. 대부분의 다른 답변은 while 루프를 사용하여 일치하는 모든 패턴 을 반복 하지만, 우리는 그 접근 방식의 잠재적 위험을 모두 알고 있다고 생각합니다. new RegExp()주석에만 언급 된 패턴 자체 대신에 일치해야합니다 . 이것은 때문이다 .exec()방법은 유사 동작 생성 기능 - 일치하는 항목이있을 때마다 중지 ,하지만 유지 .lastIndex다음에 거기에서 계속 .exec()호출.

코드 예

아래는 모든 일치하는 패턴searchString 을 반환하는 함수의 예입니다. 여기서 각각 은 모든 포함 된 일치하는 그룹 과 함께 있습니다 . while 루프를 사용하는 대신 일반 루프를 사용하여 기능과 성능 을 모두 향상시키는 예제를 제공 했습니다.ArraymatchArrayArray.prototype.map()for

간결한 버전 (더 적은 코드, 더 많은 구문 설탕)

기본적으로 forEach더 빠른 for-loop 대신 -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 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

나는이 대안들을 다른 답변들에서 이전에 언급 한 대안들과 비교하지는 않았지만,이 접근법이 다른 방법들보다 성능이 낮고 고장이 적다는 것은 의심 스럽다.


19

String#matchAll( 단계 3 초안 / 2018 년 12 월 7 일 제안 참조 )은 일치 오브젝트의 모든 그룹에 대한 액세스를 단순화합니다 (그룹 0은 전체 일치이며 추가 그룹은 패턴의 캡처 그룹에 해당함).

matchAll사용할 수, 당신은 피할 수 while루프와 exec함께 /g... 대신 사용하여 matchAll, 당신은 당신이 더 편리하게 사용할 수있는 반복자 돌아가 for...of, 배열 확산 , 또는 Array.from()구조를

이 메소드 Regex.Matches는 C #, re.finditerPython, preg_match_allPHP 와 비슷한 결과를 냅니다.

JS 데모 (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" ]

참고 : 브라우저 호환성 정보를 참조하십시오.


키 값 쌍에 대한 완벽한 예입니다. 간결하고 읽기 쉽고 사용하기 매우 간단합니다. 또한 더 나은 오류 처리, 스프레드는 null이 아닌 빈 배열을 반환하므로 더 이상 '오류, 속성 "길이'가 없습니다 '
Jarrod McGuire

17

구문이 가장 잘 유지되지 않을 수 있습니다. FF / Gecko는 RegExp를 Function의 확장으로 정의합니다.
(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"]

16

exec메소드 를 호출 할 필요가 없습니다 ! 문자열에서 "일치"방법을 직접 사용할 수 있습니다. 괄호를 잊지 마십시오.

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의 두 번째 일치는 괄호로 분리됩니다. 중첩 된 괄호는 까다롭기 때문에 조심하십시오!


4
전역 플래그가 없으면 모든 일치 항목을 반환하고 큰 일치 항목 만 가져 오므로 조심하십시오.
Shadymilkman01

8

한 쌍의 괄호가있는 경우에만 실용적인 하나의 라이너 :

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

4
왜 안됩니다while (match = myRegex.exec(myStr)) matches.push(match[1])
willlma

7

코드 사용하기 :

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

편집 : 중요한 경우 Safari 3.


7

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

그리고 당신은 같은 것을 얻을 것입니다

{프로토콜 : "https", 호스트 이름 : "stackoverflow.com", 경로 이름 : "questions / 432493 / how-do-you-access-the-matched-groups-in-a-javascript-regular-expression", querystring : " some = 매개 변수 "}


6

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 = 'Rs.200 is Debited to A/c ...2031 on 02-12-14 20:05:49 (Clear Bal Rs.66248.77) AT ATM. TollFree 1800223344 18001024455 (6am-10pm)';
var myRegEx = /clear bal.+?(\d+\.?\d{2})/gi;

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

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


3

필자가 PhiLo에 동의하더라도 정규식이 다음 과 같아야 한다고 귀하의 코드가 작동합니다 (Mac의 경우 FF3) .

/\bformat_(.*?)\b/

(물론 정규 표현식의 컨텍스트를 모르기 때문에 확실하지 않습니다.)


1
공백으로 구분 된 목록이므로 \ s가 좋을 것이라고 생각했습니다. 그 코드가 나를 위해 작동하지 않는 것이 이상합니다 (FF3 Vista)
nickf

1
예, 정말 이상합니다. Firebug 콘솔에서 자체적으로 사용해 보셨습니까? 그렇지 않으면 빈 페이지에서 의미합니다.
PEZ

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

2

여러 개의 일치 항목을 구문 분석하기 위해 명시적인 루프가 필요하지 않습니다. 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일치하는 그룹이 발견 된 문자열 내에서 시작 색인입니다 (이 경우에는 사용되지 않음).


1

백 슬래시와 일치하는 그룹 번호를 사용하여 정규식에서 일치하는 그룹에 액세스 할 수 있습니다.

/([a-z])\1/

첫 번째 그룹과 일치하는 코드 \ 1 ([az])


1

한 줄 솔루션 :

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

따라서이 방법을 사용할 수 있습니다 (/ g를 사용해야 함).

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

결과:

[" format_abc"]

0

모든 그룹 발생 가져 오기

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

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

console.log(m);


0

나는 너처럼 나와 정규식이 다음과 같은 객체를 반환하기를 바란다.

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


0

정당한 사용 RegExp. $ 1 ... $ n 번째 그룹 예 :

1. 첫 번째 그룹 RegExp와 일치하려면 $ 1

  1. 두 번째 그룹 RegExp와 일치하려면 $ 2

정규 표현식에서 3 그룹을 사용하는 경우 (string.match (regex) 뒤에 사용하십시오)

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

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.