Translate missing RegExp pages (#3198)

2 files changed, 159 insertions, 0 deletions

diff --git a/files/fr/web/javascript/reference/global_objects/regexp/hasindices/index.md b/files/fr/web/javascript/reference/global_objects/regexp/hasindices/index.md
new file mode 100644
index 0000000000..5fc456f36e
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/regexp/hasindices/index.md
@@ -0,0 +1,62 @@
+---
+title: RegExp.prototype.hasIndices
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/hasIndices
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/hasIndices
+browser-compat: javascript.builtins.RegExp.hasIndices
+---
+{{JSRef}}
+
+La propriété **`hasIndices`** indique si le marqueur "`d`" a été utilisé ou non avec l'expression rationnelle. `hasIndices` est une propriété en lecture seule, rattachée à une instance d'expression rationnelle.
+
+{{EmbedInteractiveExample("pages/js/regexp-prototype-hasindices.html")}}
+
+{{JS_Property_Attributes(0, 0, 1)}}
+
+## Description
+
+La valeur de `hasIndices` est un [`booléen`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean) qui vaut `true` si le marqueur "`d`" a été utilisé et `false` sinon. Le marqueur "`d`" indique que le résultat des correspondances d'une expression rationnelle devrait contenir les indices de début et fin des fragments de chaîne pour chaque groupe capturant.
+
+Cette propriété ne peut être modifiée directement.
+
+## Exemples
+
+### Utiliser `hasIndices`
+
+```js
+const str1 = 'toto truc toto';
+
+const regex1 = new RegExp('toto', 'gd');
+
+console.log(regex1.hasIndices); // Affiche : true
+
+console.log(regex1.exec(str1).indices[0]); // Affiche : Array [0, 3]
+console.log(regex1.exec(str1).indices[0]); // Affiche : Array [8, 11]
+
+const str2 = 'toto truc toto';
+
+const regex2 = new RegExp('toto');
+
+console.log(regex2.hasIndices); // Affiche : false
+
+console.log(regex2.exec(str2).indices); // Affiche : undefined
+```
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- [`RegExp.lastIndex`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/lastIndex)
+- [`RegExp.prototype.exec()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec)
+- [`RegExp.prototype.dotAll`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/dotAll)
+- [`RegExp.prototype.global`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/global)
+- [`RegExp.prototype.ignoreCase`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase)
+- [`RegExp.prototype.multiline`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/multiline)
+- [`RegExp.prototype.source`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/source)
+- [`RegExp.prototype.sticky`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/sticky)
+- [`RegExp.prototype.unicode`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/unicode)
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/regexp/index.md b/files/fr/web/javascript/reference/global_objects/regexp/regexp/index.md
new file mode 100644
index 0000000000..9d1232b76b
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/regexp/regexp/index.md
@@ -0,0 +1,97 @@
+---
+title: Constructeur RegExp()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/RegExp
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/RegExp
+browser-compat: javascript.builtins.RegExp.RegExp
+---
+{{JSRef}}
+
+Le constructeur **`RegExp`** crée une expression rationnelle pour manipuler les correspondances trouvées dans un texte par rapport à un motif.
+
+Pour une introduction au sujet des expressions rationnelles, nous vous conseillons de lire [le chapitre sur les expressions rationnelles](/fr/docs/Web/JavaScript/Guide/Regular_Expressions) du [Guide JavaScript](/fr/docs/Web/JavaScript/Guide).
+
+{{EmbedInteractiveExample("pages/js/regexp-constructor.html")}}
+
+## Syntaxe
+
+Il est possible d'utiliser des syntaxes littérales, d'utiliser un constructeur ou la fonction directement :
+
+```js
+/motif/marqueurs
+new RegExp(motif[, marqueurs])
+RegExp(motif[, marqueurs])
+```
+
+### Paramètres
+
+- `motif`
+
+  - : Le texte de l'expression rationnelle.
+
+    Avec ES5, ce peut être un autre objet `RegExp` ou une valeur littérale (uniquement lorsqu'on utilise la notation avec la fonction / le constructeur). Un motif peut contenir [des caractères spéciaux](/fr/docs/Web/JavaScript/Guide/Regular_Expressions) pour cibler un ensemble plus large de valeurs que ce que permet une chaîne de caractère littérale.
+
+- `marqueurs`
+
+  - : Si cet argument est utilisé, c'est une chaîne de caractères qui contient les marqueurs à ajouter à l'expression rationnelle.
+
+    Si c'est un objet qui est fourni pour le motif, les marqueurs fournis par ce deuxième paramètre remplaceront les marqueurs provenant de l'objet (et `lastIndex` sera réinitialisé à `0`) (ES2015).
+
+    Si `marqueurs` n'est pas indiqué comme argument et que le premier paramètre est un objet représentant une expression rationnelle, les marqueurs de ce dernier (y compris `lastIndex`) seront recopiés sur la nouvelle instance.
+
+    `marqueurs` peut contenir toute combinaison avec les caractères suivants :
+
+    - `d` (indices)
+      - : Génère les indices des positions pour les sous-chaînes correspondantes.
+    - `g` (recherche globale)
+      - : Trouve l'ensemble des correspondances plutôt que de s'arrêter à la première.
+    - `i` (sensibilité à la casse)
+      - : Si le marqueur `u` est également activé, active le repliage de casse Unicode (<i lang="en">case folding</i>).
+    - `m` (multiligne)
+      - :  Les caractères (`^` et `$`) fonctionnent sur plusieurs lignes. Autrement dit, ils correspondent aux débuts et aux fins de chaque ligne (délimitées par `\n` ou `\r`) et pas uniquement au début ou à la fin de la chaîne de caractère étudiée.
+    - `s` ("dotAll")
+      - : Permet à `.` de correspondre à des nouvelles lignes.
+    - `u` (unicode)
+      - : Traite `motif` comme une séquence de codets Unicode (voir aussi [les chaînes de caractères binaires](/fr/docs/Web/API/DOMString/Binary)).
+    - `y` (adhérence)
+      - : Ne cherche les correspondances dans la chaîne cible qu'à partir de l'indice porté par la propriété `lastIndex` de l'expression rationnelle. N'effectue pas de recherche sur des indices antérieurs.
+
+### Exceptions
+
+- Si `motif` ne peut être interprété comme une expression rationnelle valide, une exception [`SyntaxError`](/fr/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) sera levée.
+- Si `marqueurs` contient des caractères répétés ou en dehors de ceux autorisés, une exception [`SyntaxError`](/fr/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) sera levée.
+
+## Exemples
+
+### Notation littérale et constructeur
+
+Il existe deux façons de créer un objet `RegExp`&nbsp;: en utilisant _une notation littérale_ ou _un constructeur_.
+
+- **Pour la notation littérale**, les paramètres sont encadrés de barres obliques et on n'utilise pas de guillemets ou de quotes.
+- **Pour le constructeur**, les paramètres sont délimités entre guillemets/quotes et pas avec des barres obliques.
+
+Les trois expressions suivantes permettent de créer la même expression rationnelle&nbsp;:
+
+```js
+/ab+c/i
+new RegExp(/ab+c/, 'i') // Notation littérale
+new RegExp('ab+c', 'i') // Constructeur
+```
+
+La notation littérale provoque la compilation de l'expression rationnelle lorsque l'expression est évaluée. On utilisera la notation littérale lorsque l'expression rationnelle demeure constante. Ainsi, si on utilise une notation littérale pour construire une expression rationnelle utilisée dans une boucle, l'expression rationnelle ne sera pas recompilée à chaque itération.
+
+L'utilisation du constructeur (`new RegExp('ab+c')`) causera une compilation à l'exécution pour l'expression rationnelle. On utilisera le constructeur lorsqu'on sait que le motif changera ou qu'on ne connait pas, par avance le motif (par exemple s'il provient d'autre source).
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- [Le chapitre sur les expressions rationnelles](/fr/docs/Web/JavaScript/Guide/Regular_Expressions) dans [le guide JavaScript](/fr/docs/Web/JavaScript/Guide)
+- [`String.prototype.match()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/match)
+- [`String.prototype.replace()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/replace)
+- [Une prothèse d'émulation pour certaines fonctionnalités `RegExp` (`dotAll`, marqueur d'adhérence, groupes de capture nommés, etc.) sur `core-js`](https://github.com/zloirock/core-js#ecmascript-string-and-regexp)