web-dev-qa-db-fra.com

Quelle est la différence entre la fonction RegEx exec () et la fonction String match ()?

Si je lance ceci:

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

J'ai compris:

["a", "a"]

Mais si je lance ceci:

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

Ensuite, j'obtiens le résultat attendu:

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

Quelle est la différence?

javascriptregex
105
Justin Warkentin

exec avec une expression régulière globale est destiné à être utilisé dans une boucle, car il récupère toutes les sous-expressions correspondantes Alors:

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 le fait pour vous et élimine les groupes capturés.

101
Ry-

Une image est meilleure, vous savez ...

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

Regarde la différence?

Remarque: Pour mettre en surbrillance, notez que les groupes capturés (par exemple: a, A) sont renvoyés après le motif correspondant (par exemple: aA).

66
georg

/regex/.exec() renvoie uniquement la première correspondance trouvée, alors que "string".match() les renvoie toutes si vous utilisez l'indicateur g dans l'expression régulière.

Voir ici: exec , match .

26
Alex Ciminian

Si votre expression rationnelle est globale et que vous capturez, vous devez utiliser exec. Le match ne retournera pas toutes vos captures. 

La correspondance fonctionne très bien pour la correspondance (ne pas capturer). Vous l'exécutez une fois et cela donne un tableau de tous les matchs. (Cependant, si l'expression régulière n'est pas globale, alors match affichera le match suivi de captures)

Exec est ce que vous utilisez lorsque vous capturez, et chaque fois qu'il est exécuté, il donne la correspondance, suivie des captures. (match se comportera de manière à donner le match complet suivi des captures, uniquement lorsque la regex n’est pas globale).

Une autre utilisation avec Exec consiste à obtenir l’index ou la position d’une correspondance. Lorsque vous avez une variable pour votre expression rationnelle, vous pouvez utiliser .lastIndex et obtenir la position de la correspondance. Un objet regex a .lastIndex, et l'objet regex est ce que vous faites .exec. La correspondance de points est faite sur une chaîne et vous ne pourrez pas faire l'objet regex dot lastIndex 

Une chaîne de caractères a la fonction match, qui reçoit une expression rationnelle. Et une regex, a la fonction exec, et est passé une chaîne

exec tu cours plusieurs fois. correspond à vous courez une fois

Il est bon d’utiliser correspondance lorsque vous ne capturez pas et lors de la capture, vous pouvez utiliser exec qui est plus puissant car c’est bon pour les captures, mais si vous avez utilisé la correspondance lors de la capture, vérifiez qu’elle affiche les captures lorsque la regex n’est pas ne montre pas les captures lorsque la regex est globale. 

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

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

Une autre chose est que si vous utilisez exec, notez que cela est appelé sur la regex, alors si vous utilisez une variable pour la regex, vous avez plus de pouvoir

Vous n'obtenez pas les correspondances lorsque vous n'utilisez pas la variable pour l'expression régulière, utilisez donc la variable pour l'expression régulière, lorsque vous utilisez 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
>

Et avec exec, vous pouvez obtenir l'index du match 

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

Donc, si vous voulez des index ou des captures, utilisez exec (gardez à l’esprit que comme vous pouvez le voir, avec "index", "l’index" qu’il donne est vraiment une nième occurrence, ça compte à partir de 1. Vous pouvez donc en déduire le bon index en soustrayant 1. Et comme vous pouvez le voir, cela donne 0 - lastIndex of 0 - for not found).

Et si vous voulez étirer une correspondance, vous pouvez l’utiliser lors de la capture, mais pas lorsque la regex est globale, et lorsque vous le faites pour cela, le contenu du tableau ne correspond pas à toutes les correspondances, mais à la totalité. match suivi des captures.

18
barlop

Parfois, regex.exec () prendra beaucoup plus de temps, puis string.match ().

Il convient de mentionner que si les résultats de string.match () et de regex.exec () sont identiques (par exemple, lorsque l’indicateur\g n’est pas utilisé), Regex.exec () prendra entre x2 et x30 puis string.match ():

Par conséquent, dans de tels cas, l’approche de "new RegExp (). Exec ()" ne doit être utilisée que lorsque vous avez besoin d’une expression rationnelle globale (c.-à-d. À exécuter plusieurs fois).

0
dorony