RegExp의 exec () 함수와 String의 match () 함수의 차이점은 무엇입니까?

RegExp의 exec () 함수와 String의 match () 함수의 차이점은 무엇입니까?

---

내가 이것을 실행하면 :

/([^\/]+)+/g.exec('/a/b/c/d');

나는 이것을 얻는다 :

["a", "a"]

그러나 내가 이것을 실행하면 :

'/a/b/c/d'.match(/([^\/]+)+/g);

그런 다음 예상 결과를 얻습니다.

["a", "b", "c", "d"]

차이점이 뭐야?

---

exec전역 정규 표현식을 사용하면 일치하는 모든 하위 표현식을 계속 검색하므로 루프에서 사용됩니다. 그래서:

var re = /[^\/]+/g;
var match;

while (match = re.exec('/a/b/c/d')) {
    // match is now the next match, in array form.
}

// No more matches.

String.match 이를 위해 캡처 된 그룹을 삭제합니다.

---

한 장의 사진이 더 좋습니다.

re_once = /([a-z])([A-Z])/
re_glob = /([a-z])([A-Z])/g

st = "aAbBcC"

console.log("match once="+ st.match(re_once)+ "  match glob="+ st.match(re_glob))
console.log("exec once="+ re_once.exec(st) + "   exec glob="+ re_glob.exec(st))
console.log("exec once="+ re_once.exec(st) + "   exec glob="+ re_glob.exec(st))
console.log("exec once="+ re_once.exec(st) + "   exec glob="+ re_glob.exec(st))

차이점을 보시겠습니까?

참고 : 강조 표시하려면 캡처 된 그룹 (예 : a, A)이 일치 된 패턴 (예 : aA) 후에 반환됩니다. 일치하는 패턴 만이 아닙니다.

---

/regex/.exec()정규식 "string".match()에서 g플래그 를 사용하면 찾은 첫 번째 일치 만 반환하고 모든 일치를 반환합니다 .

여기를보십시오 : exec , match .

---

정규식이 전역이고 캡처하는 경우 exec를 사용해야합니다. 경기는 모든 캡처를 반환하지 않습니다.

일치는 캡처하지 않고 일치 할 때 효과적입니다. 한 번 실행하면 모든 일치하는 배열이 제공됩니다. (정규 표현식이 전역이 아닌 경우 일치는 일치와 캡처를 표시합니다)

Exec은 캡처 할 때 사용하는 것으로, 실행될 때마다 일치하고 캡처가 수행됩니다. 일치는 정규식이 전역이 아닌 경우에만 전체 일치와 캡처를 제공하는 방식으로 작동합니다.

Exec의 또 다른 용도는 일치하는 인덱스 또는 위치를 얻는 것입니다. 정규식에 변수가 있으면 .lastIndex를 사용하여 일치하는 위치를 얻을 수 있습니다. 정규식 객체에는 .lastIndex가 있으며 정규식 객체는 .exec에서 수행하는 작업입니다. 점 일치는 문자열에서 수행되며 정규식 객체 점 lastIndex를 수행 할 수 없습니다

문자열에는 일치 함수가 있으며 정규식에 전달됩니다. 그리고 정규 표현식에는 exec 함수가 있으며 문자열이 전달됩니다.

exec는 여러 번 실행됩니다. 당신이 한 번 실행 일치

캡처하지 않을 때와 캡처 할 때 일치를 사용하는 것이 좋습니다 캡처를 얻는 데 더 강력한 exec를 사용할 수 있지만 캡처 할 때 일치를 사용하면 정규 표현식이 전역이 아닐 때 캡처를 표시하지만 그렇지 않습니다. 정규식이 전역일 때 캡처를 표시하지 않습니다.

> "azb".match(/a(z)b/);
[ "azb", "z" ]

> "azb".match(/a(z)b/g);
[ "azb" ]
>

또 다른 것은 exec를 사용하면 정규 표현식에서 호출 된 다음 정규 표현식에 변수를 사용하면 더 많은 힘을 얻을 수 있다는 것입니다

정규식에 변수를 사용하지 않으면 일치하지 않으므로 exec를 사용할 때 정규식에 변수를 사용하십시오.

> /./g.exec("abc")
[ "a" ]
> /./g.exec("abc")
[ "a" ]
> /./g.exec("abc")
[ "a" ]
>
> /[a-c]/g.exec("abc")
[ "a" ]
> /[a-c]/g.exec("abc")
[ "a" ]
>

> var r=/[a-c]/g
> r.exec("abc")
[ "a" ]
> r.exec("abc")
[ "b" ]
> r.exec("abc")
[ "c" ]
> r.exec("abc")
null
>

그리고 exec를 사용하면 일치하는 "인덱스"를 얻을 수 있습니다

> var r=/T/g
> r.exec("qTqqqTqqTq");
[ "T" ]
> r.lastIndex
2
> r.exec("qTqqqTqqTq");
[ "T" ]
> r.lastIndex
6
> r.exec("qTqqqTqqTq");
[ "T" ]
> r.lastIndex
9
> r.exec("qTqqqTqqTq");
null
> r.lastIndex
0
>

따라서 인덱스 또는 캡처를 원할 경우 exec를 사용하십시오 ( "index"에서 "index"로 제공되는 "index"는 실제로 n 번째 발생이며 1부터 계산됨을 명심하십시오) 1을 빼서 색인. 보시다시피 0-lastIndex of 0-찾을 수 없음).

And if you want to stretch match, you can use it when you are capturing, but not when the regex is global, and when you do it for that, then the contents of the array aren't all the matches, but are the full match followed by the captures.

---

The .match() function str.match(regexp) will do the following:

• if there is a match it will return:
  • if the g flag is used in the regexp: it will return all the substrings (ignoring capture groups)
  • if the g flag is not used in the regexp: it will return the same as regexp.exec(str)
• if there is no match it will return:
  • null

Examples of .match() using the g flag:

var str = "qqqABApppabacccaba";
var e1, e2, e3, e4, e5;
e1 = str.match(/nop/g); //null
e2 = str.match(/no(p)/g); //null
e3 = str.match(/aba/g); //["aba", "aba"]
e4 = str.match(/aba/gi); //["ABA", "aba", "aba"]
e5 = str.match(/(ab)a/g); //["aba", "aba"] ignoring capture groups as it is using the g flag

And .match() without the g flag is equivalent to .exec():

e1=JSON.stringify(str.match(/nop/))===JSON.stringify(/nop/.exec(str)); //true
//e2 ... e4 //true
e5=JSON.stringify(str.match(/(ab)a/))===JSON.stringify(/(ab)a/.exec(str)); //true

---

The .exec() function regexp.exec(str) will do the following:

• if there is a match it will return:
  • if the g flag is used in the regexp: it will return (for each time it is called): [N_MatchedStr, N_Captured1, N_Captured2, ...] of the next N match. Important: it will not advance into the next match if the regexp object is not stored in a variable (it needs to be the same object)
  • if the g flag is not used in the regexp: it will return the same as if it had a g flag and was called for the first time and only once.
• if there is no match it will return:
  • null

Example of .exec() (stored regexp + using the g flag = it changes with each call):

var str = "qqqABApppabacccaba";
var myexec, rgxp = /(ab)a/gi;

myexec = rgxp.exec(str);
console.log(myexec); //["ABA", "AB"]
myexec = rgxp.exec(str);
console.log(myexec); //["aba", "ab"]
myexec = rgxp.exec(str);
console.log(myexec); //["aba", "ab"]
myexec = rgxp.exec(str);
console.log(myexec); //null

//But in this case you should use a loop:
var mtch, myRe = /(ab)a/gi;
while(mtch = myRe.exec(str)){ //infinite looping with direct regexps: /(ab)a/gi.exec()
    console.log("elm: "+mtch[0]+" all: "+mtch+" indx: "+myRe.lastIndex);
    //1st iteration = elm: "ABA" all: ["ABA", "AB"] indx: 6
    //2nd iteration = elm: "aba" all: ["aba", "ab"] indx: 12
    //3rd iteration = elm: "aba" all: ["aba", "ab"] indx: 18
}

Examples of .exec() when it is not changing with each call:

var str = "qqqABApppabacccaba", myexec, myexec2;

//doesn't go into the next one because no g flag
var rgxp = /(a)(ba)/;
myexec = rgxp.exec(str);
console.log(myexec); //["aba", "a", "ba"]
myexec = rgxp.exec(str);
console.log(myexec); //["aba", "a", "ba"]
//... ["aba", "a", "ba"]

//doesn't go into the next one because direct regexp
myexec2 = /(ab)a/gi.exec(str);
console.log(myexec2); //["ABA", "AB"]
myexec2 = /(ab)a/gi.exec(str);
console.log(myexec2); //["ABA", "AB"]
//... ["ABA", "AB"]

---

Sometimes regex.exec() will take much more time then string.match().

It is worth to mention that if the outcome of string.match() and regex.exec() are the same (ex: when not using \g flag), regex.exec() will take somewhere between x2 to x30 then string.match():

Therefore in such cases, using the approach of "new RegExp().exec()" should be used only when you need a global regex (i.e. to execute more than once).

참고URL : https://stackoverflow.com/questions/9214754/what-is-the-difference-between-regexp-s-exec-function-and-string-s-match-fun