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

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 de ceci:

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

Quelle est la différence?

execavec une expression régulière globale est destiné à être utilisé dans une boucle, car il récupérera toujours 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 fait cela pour vous et supprime les groupes capturés.

Une image c'est mieux, tu sais ...

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 évidence, notez que les groupes capturés (par exemple: a, A) sont renvoyés après le modèle correspondant (par exemple: aA), ce n'est pas seulement le modèle correspondant.

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

Voir ici: exec , match .

Si votre expression régulière est globale et que vous effectuez une capture, vous devez utiliser exec. Match ne renverra pas toutes vos captures.

Match fonctionne très bien pour la correspondance (pas la capture). Vous l'exécutez une fois et il donne un tableau de toutes les correspondances. (bien que si l'expression régulière n'est pas globale, la correspondance affichera la correspondance suivie 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. (la correspondance se comportera de manière à donner la correspondance complète suivie de captures, uniquement lorsque l'expression régulière 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 regex, 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 point est effectuée sur une chaîne et vous ne pourrez pas faire l'objet regex dot lastIndex

Une chaîne, a la fonction de correspondance, qui reçoit une expression régulière. Et une expression régulière, a la fonction exec, et reçoit une chaîne

exec vous exécutez plusieurs fois. match vous courez une fois

Il est bon d'utiliser match lorsque vous ne capturez pas et lors de la capture, vous pouvez utiliser exec qui est plus puissant car il est bon pour obtenir des captures, mais si vous avez utilisé match lors de la capture, voyez qu'il affiche les captures lorsque l'expression régulière n'est pas globale, mais ne le fait pas 't show capture lorsque le regex est global.

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

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

Une autre chose est que si vous utilisez exec, notez qu'il est appelé sur l'expression régulière, alors si vous avez utilisé une variable pour l'expression régulière, vous avez plus de puissance

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 capturer, alors utilisez exec (gardez à l'esprit que comme vous pouvez le voir, avec le "index", le "index" qu'il donne est vraiment une nième occurrence, il compte à partir de 1. Donc vous pouvez dériver le bon index en soustrayant 1. Et comme vous pouvez le voir, il donne 0 - lastIndex de 0 - pour non trouvé).

Et si vous voulez étirer la correspondance, vous pouvez l'utiliser lorsque vous capturez, mais pas lorsque l'expression régulière est globale, et lorsque vous le faites pour cela, alors le contenu du tableau ne correspond pas à toutes les correspondances, mais est complet match suivi des captures.

Le .match () fonction str.match(regexp)va effectuer les opérations suivantes:

• s'il est un match , il retourne:
  • si le gdrapeau est utilisé dans l'expression rationnelle: il retournera toutes les sous-chaînes (en ignorant les groupes de capture)
  • si l' gindicateur n'est pas utilisé dans l'expression rationnelle: il retournera le même queregexp.exec(str)
• s'il n'y a pas de correspondance, il retournera:
  • null

Exemples de .match () utilisant l' gindicateur:

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

Et .match () sans l' gindicateur équivaut à .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

Le .exec () fonction regexp.exec(str)va effectuer les opérations suivantes:

• s'il est un match , il retourne:
  • si le gdrapeau est utilisé dans l'expression rationnelle: il retournera (à chaque fois qu'il est appelé) : [N_MatchedStr, N_Captured1, N_Captured2, ...]de la prochaine Ncorrespondance. Important: il ne passera pas à la prochaine correspondance si l'objet regexp n'est pas stocké dans une variable (il doit être le même objet)
  • si le gdrapeau n'est pas utilisé dans l'expression rationnelle: il retournera le même que s'il avait un gdrapeau et a été appelé pour la première fois et une seule fois.
• s'il n'y a pas de correspondance, il retournera:
  • null

Exemple de .exec () (expression rationnelle stockée + en utilisant le gdrapeau = cela change à chaque appel):

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
}

Exemples de .exec () quand il ne change pas à chaque appel:

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

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

Il convient de mentionner que si le résultat de string.match () et regex.exec () est le même (ex: si vous n'utilisez pas le drapeau \ g), regex.exec () prendra quelque part entre x2 et x30 puis string. rencontre():

Par conséquent, dans de tels cas, l'utilisation de l'approche de "new RegExp (). Exec ()" ne doit être utilisée que lorsque vous avez besoin d'une expression régulière globale (c'est-à-dire pour s'exécuter plus d'une fois).