Question

如果我这样做：

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

我明白了：

["a", "a"]

但如果我这样做：

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

然后我得到了预期的结果：

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

有什么区别？

Answer 1

具有全局正则表达式的

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为您执行此操作并丢弃已捕获的组。

Answer 2

一张照片更好，你知道......

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

看到区别？

注意：要突出显示，请注意在匹配的模式（例如：aA）之后返回捕获的组（例如：a，A），它不仅仅是匹配的模式。

Answer 3

/regex/.exec()仅返回找到的第一个匹配项，而如果您在正则表达式中使用"string".match()标记，g将返回所有匹配项。

请参阅此处：exec，match。

Answer 4

如果你的正则表达式是全局的，并且你正在捕获，那么你必须使用exec。匹配不会返回所有捕获。

匹配在匹配（不捕获）时效果很好。你运行一次，它给出了所有匹配的数组。（虽然如果正则表达式不是全局的，那么匹配将显示匹配后跟捕获）

Exec是你在捕获时使用的，每次执行时都会给出匹配，然后是捕获。（只有在正则表达式不是全局的时候，匹配才会以完全匹配然后捕获的方式运行。）

与Exec的另一个用途是获取匹配的索引或位置。当你有一个正则表达式的变量时，你可以使用.lastIndex并获得匹配的位置。正则表达式对象有.lastIndex，而正则表达式对象就是你执行的.exec。点匹配是在字符串上完成的，然后你就不能再使用正则表达式对象点lastIndex

一个字符串，有一个匹配函数，它传递一个正则表达式。和一个正则表达式，有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，您可以获得＆＃34;索引＆＃34;比赛

> 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（请记住，正如你所看到的，使用＆＃34;索引＆＃34;，＆＃34;索引＆＃34;它给出的是真正的nth发生，它从1开始计数。所以你可以通过减去1来得到正确的指数。正如你所看到的，它给出了0 - lastIndex为0 - 未找到）。

如果你想拉伸匹配，你可以在捕获时使用它，但是当正则表达式是全局的时候不能使用它，当你为它做的时候，那么数组的内容不是所有的匹配，但完全匹配后跟捕获。

Answer 5

.match()函数str.match(regexp)将执行以下操作：

如果匹配，则会返回：
- 如果正则表达式中使用了g标志：它将返回所有子字符串（忽略捕获组）
- 如果正则表达式中使用的g标志不：它将返回与regexp.exec(str)相同的
如果没有匹配则会返回：
- null

使用g标志的 .match（）示例：

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

没有g标志的 .match（）等同于 .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

.exec()函数regexp.exec(str)将执行以下操作：

如果匹配，则会返回：
- 如果正则表达式中使用了g标志：它将返回（每次调用时）：[N_MatchedStr, N_Captured1, N_Captured2, ...]下一个N匹配。 重要提示：如果regexp对象未存储在变量中（它必须是同一个对象），它将不会进入下一个匹配项。
- 如果正则表达式中使用的g标志不：它将返回与g标志相同的标记并且第一次被调用一次。
如果没有匹配则会返回：
- null

.exec（）示例（使用g标记存储的regexp +随每次调用而变化）：

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
}

.exec（）的示例，当不随每次调用而变化时：

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

Answer 6

有时候regex.exec（）会比string.match（）多花费很多时间。

值得一提的是，如果string.match（）和regex.exec（）的结果相同（例如：不使用\ g标志时）， regex.exec（）将介于x2到x30之间，然后是string.match（）：

因此，在这种情况下，仅在需要全局正则表达式（即执行多次）时才应使用“ new RegExp（）。exec（）”方法。

RegEx exec（）函数和String match（）函数有什么区别？

6 个答案: