RegExp.prototype.exec()
=======================

La méthode **`exec()`** exécute la recherche d'une correspondance sur une chaîne de caractères donnée. Elle renvoie un tableau contenant les résultats ou `null`.

Si on souhaite uniquement savoir s'il y a une correspondance, on utilisera la méthode `RegExp.prototype.test()` ou la méthode `String.prototype.search()`.

Exemple interactif
------------------

Les objets représentant des expressions rationnelles gardent un état en mémoire lorsqu'ils utilisent les marqueurs `global` ou `sticky` et ils gardent notamment en mémoire `lastIndex` à partir de la correspondance précédemment trouvée. Ainsi, `exec()` peut être utilisée afin de parcourir plusieurs correspondances dans un texte (avec des groupes capturants) (contrairement à `String.prototype.match()`).

Syntaxe
-------


```js
regexObj.exec(chaîne);
```

### Paramètres

`chaîne`

La chaîne de caractères dans laquelle on recherche la correspondance décrite par l'expression rationnelle.

### Valeur de retour

S'il y a une correspondance, la méthode `exec()` renvoie un tableau (contenant des éléments et deux propriétés `index` et `values`, cf. ci-après) et met à jour les propriétés de l'objet représentant l'expression rationnelle (notamment `lastIndex`). Le tableau renvoyé contient le texte qui correspond dans le premier élément puis un élément pour chaque groupe capturé dans les parenthèses capturantes.

S'il n'y a aucune correspondance, la méthode `exec()` renvoie `null` et la propriété `lastIndex` reçoit la valeur 0.

Description
-----------

Si on a l'exemple suivant :


```js
// On a une correspondance si on a "quick brown" suivi par "jumps", on ignore les caractères entre
// On garde en mémoire "brown" et "jumps"
// On ignore la casse
var re = /quick\s(brown).+?(jumps)/gi;
var result = re.exec("The Quick Brown Fox Jumps Over The Lazy Dog");
```


Le tableau suivant montre l'état résultant suite à ce script :

|  |  |  |  |
| --- | --- | --- | --- |
| Objet | Propriété/Index | Description | Exemple |
| `result` | `[0]` | La chaîne complète des caractères qui correspondent. | `"Quick Brown Fox Jumps"` |
| `[1], ...[*n* ]` | 
 Les sous-chaînes correspondantes aux groupes capturants s'il y en a. Le
 nombre de groupes de parenthèses capturantes est illimité.
  | `result[1] === "Brown"result[2] === "Jumps"` |
| `index` | L'indice (compté à partir de 0) de la correspondance dans la chaîne. | `4` |
| `input` | La chaîne de caractères utilisée en entrée. | `"The Quick Brown Fox Jumps Over The Lazy Dog"` |
| `re` | `lastIndex` | 
 L'indice à partir duquel chercher la prochaine correspondance. Lorsque
 le drapeau "g" est absent, cette propriété sera 0.
  | `25` |
| `ignoreCase` | 
 Indique si le drapeau "`i`" a été utilisé pour ignorer la
 casse.
  | `true` |
| `global` | 
 Indique si le drapeau "`g`" a été utilisé pour la
 correspondance globale.
  | `true` |
| `multiline` | 
 Indique si le drapeau "`m`" a été utilisé pour chercher une
 correspondance sur plusieurs lignes.
  | `false` |
| `source` | Le texte du motif. | `"quick\s(brown).+?(jumps)"` |

Exemples
--------

### Trouver des correspondances successives

Si on utilise le drapeau "`g`" dans l'expression rationnelle, on peut utiliser la méthode `exec()` plusieurs fois afin de trouver les correspondances successives dans la chaîne. Lorsqu'on procède ainsi, la recherche reprend à la position indiquée par la propriété `lastIndex` (`test()` fera également progresser la propriété `lastIndex`).

On notera que la propriété `lastIndex` ne sera pas réinitialisée lors de la recherche sur une autre chaîne de caractères, c'est la valeur existante de `lastIndex` qui sera utilisée.

Par exemple, si on utilise le fragment de code suivant :


```js
var maRegex = /ab\*/g;
var str = "abbcdefabh";
var monTableau;
while ((monTableau = maRegex.exec(str)) !== null) {
  var msg = "Trouvé " + monTableau[0] + ". ";
  msg += "Prochaine correspondance à partir de " + maRegex.lastIndex;
  console.log(msg);
}
```


Le script affichera alors :
```

Trouvé abb. Prochaine correspondance à partir de 3
Trouvé ab. Prochaine correspondance à partir de 9
```


**Attention :** Il ne faut pas placer un littéral d'expression rationnelle (ou le constructeur `RegExp`) au sein de la condition `while` car cela créerait un boucle infinie s'il y a une correspondance car la propriété `lastIndex` serait redéfinie à chaque itération. Il faut également s'assurer que le drapeau global est défini sinon on aura également une boucle.

### Utiliser `exec()` avec des littéraux

Il est aussi possible d'utiliser `exec()` sans créer d'objet `RegExp` explicite :


```js
var matches = /(coucou \S+)/.exec("Ceci est un coucou monde !");
console.log(matches[1]);
```


Cela affichera 'coucou monde !'.

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.exec |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* Le chapitre sur les expressions rationnelles du Guide JavaScript
* `RegExp`
* `String.prototype.match()`
* `String.prototype.matchAll()`