1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
---
title: RegExp.prototype.exec()
slug: Web/JavaScript/Reference/Objets_globaux/RegExp/exec
tags:
- JavaScript
- Méthode
- Prototype
- Reference
- RegExp
translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/exec
---
<div>{{JSRef}}</div>
<p>La méthode <strong><code>exec()</code></strong> 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 {{jsxref("null")}}.</p>
<p>Si on souhaite uniquement savoir s'il y a une correspondance, on utilisera la méthode {{jsxref("RegExp.prototype.test()")}} ou la méthode {{jsxref("String.prototype.search()")}}.</p>
<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-exec.html")}}</div>
<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
<p>Les objets représentant des expressions rationnelles gardent un état en mémoire lorsqu'ils utilisent les marqueurs {{jsxref("RegExp.global", "global")}} ou {{jsxref("RegExp.sticky", "sticky")}} et ils gardent notamment en mémoire {{jsxref("RegExp.lastIndex", "lastIndex")}} à partir de la correspondance précédemment trouvée. Ainsi, <code>exec()</code> peut être utilisée afin de parcourir plusieurs correspondances dans un texte (avec des groupes capturants) (contrairement à {{jsxref("String.prototype.match()")}}).</p>
<h2 id="Syntaxe">Syntaxe</h2>
<pre class="syntaxbox"><var>regexObj</var>.exec(<var>chaîne</var>)</pre>
<h3 id="Paramètres">Paramètres</h3>
<dl>
<dt><code>chaîne</code></dt>
<dd>La chaîne de caractères dans laquelle on recherche la correspondance décrite par l'expression rationnelle.</dd>
</dl>
<h3 id="Valeur_de_retour">Valeur de retour</h3>
<p>S'il y a une correspondance, la méthode <code>exec()</code> renvoie un tableau (contenant des éléments et deux propriétés <code>index</code> et <code>values</code>, cf. ci-après) et met à jour les propriétés de l'objet représentant l'expression rationnelle (notamment {{jsxref("RegExp.lastIndex", "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.</p>
<p>S'il n'y a aucune correspondance, la méthode <code>exec()</code> renvoie {{jsxref("null")}} et la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}} reçoit la valeur 0.</p>
<h2 id="Description">Description</h2>
<p>Si on a l'exemple suivant :</p>
<pre class="brush: 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)/ig;
var result = re.exec('The Quick Brown Fox Jumps Over The Lazy Dog');
</pre>
<p>Le tableau suivant montre l'état résultant suite à ce script :</p>
<table class="fullwidth-table">
<tbody>
<tr>
<td class="header">Objet</td>
<td class="header">Propriété/Index</td>
<td class="header">Description</td>
<td class="header">Exemple</td>
</tr>
<tr>
<td rowspan="4"><code>result</code></td>
<td><code>[0]</code></td>
<td>La chaîne complète des caractères qui correspondent.</td>
<td><code>"Quick Brown Fox Jumps"</code></td>
</tr>
<tr>
<td><code>[1], ...[<em>n</em> ]</code></td>
<td>Les sous-chaînes correspondantes aux groupes capturants s'il y en a. Le nombre de groupes de parenthèses capturantes est illimité.</td>
<td><code>result[1] === "Brown"<br>
result[2] === "Jumps"</code></td>
</tr>
<tr>
<td><code>index</code></td>
<td>L'indice (compté à partir de 0) de la correspondance dans la chaîne.</td>
<td><code>4</code></td>
</tr>
<tr>
<td><code>input</code></td>
<td>La chaîne de caractères utilisée en entrée.</td>
<td><code>"The Quick Brown Fox Jumps Over The Lazy Dog"</code></td>
</tr>
<tr>
<td rowspan="5"><code>re</code></td>
<td><code>lastIndex</code></td>
<td>L'indice à partir duquel chercher la prochaine correspondance. Lorsque le drapeau "g" est absent, cette propriété sera 0.</td>
<td><code>25</code></td>
</tr>
<tr>
<td><code>ignoreCase</code></td>
<td>Indique si le drapeau "<code>i</code>" a été utilisé pour ignorer la casse.</td>
<td><code>true</code></td>
</tr>
<tr>
<td><code>global</code></td>
<td>Indique si le drapeau "<code>g</code>" a été utilisé pour la correspondance globale.</td>
<td><code>true</code></td>
</tr>
<tr>
<td><code>multiline</code></td>
<td>Indique si le drapeau "<code>m</code>" a été utilisé pour chercher une correspondance sur plusieurs lignes.</td>
<td><code>false</code></td>
</tr>
<tr>
<td><code>source</code></td>
<td>Le texte du motif.</td>
<td><code>"quick\s(brown).+?(jumps)"</code></td>
</tr>
</tbody>
</table>
<h2 id="Exemples">Exemples</h2>
<h3 id="Trouver_des_correspondances_successives">Trouver des correspondances successives</h3>
<p>Si on utilise le drapeau "<code>g</code>" dans l'expression rationnelle, on peut utiliser la méthode <code>exec()</code> 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é {{jsxref("RegExp.lastIndex", "lastIndex")}} ({{jsxref("RegExp.prototype.test()", "test()")}} fera également progresser la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}}).</p>
<p>On notera que la propriété {{jsxref("RegExp.lastIndex", "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 {{jsxref("RegExp.lastIndex", "lastIndex")}} qui sera utilisée.</p>
<p>Par exemple, si on utilise le fragment de code suivant :</p>
<pre class="brush: 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);
}
</pre>
<p>Le script affichera alors :</p>
<pre>Trouvé abb. Prochaine correspondance à partir de 3
Trouvé ab. Prochaine correspondance à partir de 9
</pre>
<div class="warning">
<p><strong>Attention</strong> à ne pas placer un littéral d'expression rationnelle (ou le constructeur {{jsxref("RegExp")}}) au sein de la condition <code>while</code> car cela créerait un boucle infinie s'il y a une correspondance car la propriété {{jsxref("RegExp.lastIndex", "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.</p>
</div>
<h3 id="Utiliser_exec()_avec_des_littéraux">Utiliser <code>exec()</code> avec des littéraux</h3>
<p>Il est aussi possible d'utiliser <code>exec()</code> sans créer d'objet {{jsxref("RegExp")}} explicite :</p>
<pre class="brush: js">var matches = /(coucou \S+)/.exec('Ceci est un coucou monde !');
console.log(matches[1]);
</pre>
<p>Cela affichera 'coucou monde !'.</p>
<h2 id="Spécifications">Spécifications</h2>
<table class="standard-table">
<thead>
<tr>
<th scope="col">Spécification</th>
<th scope="col">État</th>
<th scope="col">Commentaires</th>
</tr>
</thead>
<tbody>
<tr>
<td>{{SpecName('ES3')}}</td>
<td>{{Spec2('ES3')}}</td>
<td>Définition initiale. Implémentée avec JavaScript 1.2.</td>
</tr>
<tr>
<td>{{SpecName('ES5.1', '#sec-15.10.6.21', 'RegExp.exec')}}</td>
<td>{{Spec2('ES5.1')}}</td>
<td></td>
</tr>
<tr>
<td>{{SpecName('ES6', '#sec-regexp.prototype.exec', 'RegExp.exec')}}</td>
<td>{{Spec2('ES6')}}</td>
<td></td>
</tr>
<tr>
<td>{{SpecName('ESDraft', '#sec-regexp.prototype.exec', 'RegExp.exec')}}</td>
<td>{{Spec2('ESDraft')}}</td>
<td></td>
</tr>
</tbody>
</table>
<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
<p>{{Compat("javascript.builtins.RegExp.exec")}}</p>
<h2 id="Voir_aussi">Voir aussi</h2>
<ul>
<li>Le chapitre sur <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières">les expressions rationnelles</a> du <a href="/fr/docs/Web/JavaScript/Guide">Guide JavaScript</a></li>
<li>{{jsxref("RegExp")}}</li>
<li>{{jsxref("String.prototype.match()")}}</li>
<li>{{jsxref("String.prototype.matchAll()")}}</li>
</ul>
|
