recursal/MDN huggingface dataset:
RegExp.prototype.hasIndices
===========================

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.

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

| Attributs de `RegExp.prototype.hasIndices` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Oui |

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

La valeur de `hasIndices` est un `booléen` 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
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.hasIndices |

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

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

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

* `RegExp.lastIndex`
* `RegExp.prototype.exec()`
* `RegExp.prototype.dotAll`
* `RegExp.prototype.global`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
* `RegExp.prototype.unicode`
RegExp.prototype[@@match]()
===========================

La méthode **`[@@match]()`** permet de récupérer les correspondances obtenues lorsqu'on teste une chaîne de caractères par rapport à une expression rationnelle (*regexp*).

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

Syntaxe
-------


```js
regexp[Symbol.match](str);
```

### Paramètres

`str`

La chaîne de caractères (`String`) sur laquelle on veut chercher des correspondances.

### Valeur de retour

Un tableau (`Array`) qui contient les résultats des correspondances et les groupes capturés grâce aux parenthèse. S'il n'y a aucune correspondance, ce sera `null`.

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

Cette méthode est appelée de façon interne lorsqu'on utilise `String.prototype.match()`. Ainsi, les deux exemples qui suivent sont équivalents et le second est la version interne du premier :


```js
"abc".match(/a/);

/a/[Symbol.match]("abc");
```


Cette méthode existe afin de permettre d'adapter le comportement de la recherche des correspondances pour les sous-classes de `RegExp`.

Exemples
--------

### Appel direct

Cette méthode peut être utilisée comme `String.prototype.match()` mais avec un objet `this` différent et un ordre des paramètres également différent.


```js
var re = /[0-9]+/g;
var str = "2016-01-02";
var résultat = re[Symbol.match](str);
console.log(résultat); // ["2016", "01", "02"]
```

### Utilisation de `@@match` avec une sous-classe

Les sous-classes de `RegExp` peuvent surcharger la méthode `[@@match]()` afin de modifier le comportement.


```js
class MaRegExp extends RegExp {
  [Symbol.match](str) {
    var résultat = RegExp.prototype[Symbol.match].call(this, str);
    if (!résultat) return null;
    return {
      group(n) {
        return résultat[n];
      },
    };
  }
}

var re = new MaRegExp("([0-9]+)-([0-9]+)-([0-9]+)");
var str = "2016-01-02";
var résultat = str.match(re); // String.prototype.match appelle re[@@match].
console.log(résultat.group(1)); // 2016
console.log(résultat.group(2)); // 01
console.log(résultat.group(3)); // 02
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype-@@match |

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

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

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

* `String.prototype.match()`
* `RegExp.prototype[@@replace]()`
* `RegExp.prototype[@@search]()`
* `RegExp.prototype[@@split]()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`
RegExp.prototype[@@matchAll]()
==============================

La méthode **`[@@matchAll]`** renvoie l'ensemble des correspondances d'une expression rationnelle sur une chaîne de caractères.

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

Syntaxe
-------


```js
regexp[Symbol.matchAll](str);
```

### Paramètres

`str`

Une chaîne de caractères (`String`) dont on souhaite trouver les correspondances.

### Valeur de retour

Un itérateur.

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

Cette méthode est appelée, en interne, par le moteur JavaScript, pendant l'exécution `String.prototype.matchAll()`. Les deux lignes qui suivent renverront donc le même résultat.


```js
"abc".matchAll(/a/);

/a/[Symbol.matchAll]("abc");
```


Cette méthode existe afin de personnaliser le comportement des correspondances pour les sous-classes de `RegExp`.

Exemples
--------

### Appel direct

Cette méthode peut être utilisée de façon semblable à `String.prototype.matchAll()` mais l'objet `this` et l'ordre des arguments seront différents.


```js
var re = /[0-9]+/g;
var str = "2016-01-02";
var resultat = re[Symbol.matchAll](str);

console.log(Array.from(resultat, (x) => x[0]));
// ["2016", "01", "02"]
```

### Utiliser `@@matchAll` dans une sous-classe

Les sous-classes de `RegExp` peuvent surcharger la méthode `[@@matchAll]()` afin de modifier le comportement par défaut (par exemple pour renvoyer un tableau (`Array`) plutôt qu'un itérateur).


```js
class MaRegExp extends RegExp {
  [Symbol.matchAll](str) {
    var resultat = RegExp.prototype[Symbol.matchAll].call(this, str);
    if (!resultat) {
      return null;
    } else {
      return Array.from(resultat);
    }
  }
}

var re = new MaRegExp("([0-9]+)-([0-9]+)-([0-9]+)", "g");
var str = "2016-01-02|2019-03-07";
var resultat = str.matchAll(re);
console.log(resultat[0]); // [ "2016-01-02", "2016", "01", "02" ]
console.log(resultat[1]); // [ "2019-03-07", "2019", "03", "07" ]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp-prototype-matchall |

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

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

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

* `String.prototype.matchAll()`
* `Symbol.matchAll`
RegExp.prototype.unicode
========================

La propriété **`unicode`** indique si le drapeau "`u`" a été utilisé avec l'expression rationnelle. `unicode` est une propriété en lecture seule et liée à une instance d'expression rationnelle.

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

| Attributs de `RegExp.prototype.unicode` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Oui |

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

La valeur d'`unicode` est un `Boolean` et vaut `true` si le drapeau "`u`" a été utilisé, sinon `false`. Le drapeau "`u`" permet d'activer les fonctionnalités liées à Unicode. En utilisant le drapeau "u" toute séquence d'échappement représentant un codet Unicode sera interprétée comme telle.

Cette propriété ne peut pas être modifiée directement.

Exemples
--------


```js
var regex = new RegExp("\u{61}", "u");

console.log(regex.unicode); // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.unicode |

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

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

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

* `RegExp.lastIndex`
* `RegExp.prototype.global`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
RegExp.input ($\_)
==================

**Non standard:** Cette fonctionnalité n'est ni standard, ni en voie de standardisation. Ne l'utilisez pas pour des sites accessibles sur le Web : elle ne fonctionnera pas pour tout utilisateur. Il peut également y avoir d'importantes incompatibilités entre les implémentations et son comportement peut être modifié dans le futur.

La propriété non-standard **`input`** est une propriété statique de l'expression rationnelle qui contient la chaîne de caractères sur laquelle est effectuée la recherche de correspondances. `RegExp.$_` est un alias de cette propriété.

Syntaxe
-------


```js
RegExp.input;
RegExp.$_;
```

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

La propriété `input` est statique. Ce n'est pas la propriété d'une instance d'expression rationnelle. Cette propriété doit toujours être utilisée avec la syntaxe `RegExp.input` ou `RegExp.$_.`

La valeur de la propriété **`input`** est modifiée à chaque fois que la chaîne sur laquelle on recherche est modifiée et qu'il y a une correspondance.

Exemples
--------

### Utiliser `input` et `$_`


```js
var re = /coucou/g;
re.test("coucou toi !");
RegExp.input; // "coucou toi !"
re.test("toto"); // nouveau test, pas de correspondance
RegExp.$_; // "coucou toi !"
re.test("coucou monde !"); // nouveau test avec correspondance
RegExp.$_; // "coucou monde !"
```

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

Cette propriété n'est pas standard. Elle ne fait partie d'aucune spécification.

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

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

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

* Non-standard
 `RegExp.lastMatch ($&)`
* Non-standard
 `RegExp.lastParen ($+)`
* Non-standard
 `RegExp.leftContext ($`)`
* Non-standard
 `RegExp.rightContext ($')`
* Non-standard
 `RegExp.$1-$9`
RegExp.lastParen ($+)
=====================

**Non standard:** Cette fonctionnalité n'est ni standard, ni en voie de standardisation. Ne l'utilisez pas pour des sites accessibles sur le Web : elle ne fonctionnera pas pour tout utilisateur. Il peut également y avoir d'importantes incompatibilités entre les implémentations et son comportement peut être modifié dans le futur.

La propriété **`lastParen`** est une propriété statique accessible en lecture seule qui contient la dernière correspondance enregistrée dans un groupe (entre parenthèse) si jamais elle existe. `RegExp.$+` est un alias pour cette propriété.

Syntaxe
-------


```js
RegExp.lastParen;
RegExp["$+"];
```

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

La propriété `lastParen` est une propriété statique, ce n'est pas une propriété liée à chaque objet. Il faut donc toujours utiliser la syntaxe `RegExp.lastParen` ou `RegExp['$+'].`

La valeur de la propriété `lastParen` n'est accessible qu'en lecture seule et est modifiée automatiquement à chaque fois qu'il y a une correspondance.

Cet alias ne peut pas être utilisé avec la notation utilisant le point pour l'accès aux propriétés (`RegExp.$+`). En effet, le parseur attend une expression avec "+", dans ce cas, une exception `SyntaxError` est levée. Pour utiliser cette notation raccourcie, on utilisera la notation avec les crochets.

Exemples
--------

### Utiliser `lastParen` et `$+`


```js
var re = /(coucou)/g;
re.test("coucou toi !");
RegExp.lastParen; // "coucou"
RegExp["$+"]; // "coucou"
```

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

Cette propriété n'est pas standard. Elle ne fait partie d'aucune spécification.

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

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

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

* Non-standard
 `RegExp.input ($_)`
* Non-standard
 `RegExp.lastMatch ($&)`
* Non-standard
 `RegExp.leftContext ($`)`
* Non-standard
 `RegExp.rightContext ($')`
* Non-standard
 `RegExp.$1-$9`
RegExp.$1-$9
============

**Non standard:** Cette fonctionnalité n'est ni standard, ni en voie de standardisation. Ne l'utilisez pas pour des sites accessibles sur le Web : elle ne fonctionnera pas pour tout utilisateur. Il peut également y avoir d'importantes incompatibilités entre les implémentations et son comportement peut être modifié dans le futur.

Les propriétés non-standard **$1, $2, $3, $4, $5, $6, $7, $8, $9** sont des propriétés statiques accessibles en lecture qui contiennent les différents groupes capturés par une expression rationnelle.

Syntaxe
-------


```js
RegExp.$1;
RegExp.$2;
RegExp.$3;
RegExp.$4;
RegExp.$5;
RegExp.$6;
RegExp.$7;
RegExp.$8;
RegExp.$9;
```

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

Les propriétés $1, ..., $9 sont des propriétés statiques. Ce ne sont pas des propriétés rattachées à une expression rationnelle donnée. Pour cette raison, on utilisera toujours la syntaxe `RegExp.$1`, ..., `RegExp.$9`.

Les valeurs de ces propriétés ne sont accessibles qu'en lecture et sont modifiées par le moteur à chaque fois qu'une nouvelle correspondance est trouvée.

Le nombre de groupe d'une expression rationnelle n'est pas limité. Cependant, l'objet `RegExp` ne contient que les neufs premiers groupes. Pour accéder à chacun des groupes liés à une expression rationnelle donnée, on pourra utiliser les indices du tableau relevant les correspondances.

Ces propriétés peuvent être utilisées pour le texte de remplacement de la méthode `String.replace`. Avec cette méthode, on ne préfixera pas les valeurs par `RegExp` (voir l'exemple ci-après), lorsque les parenthèses groupantes ne sont pas utilisées dans l'expression, `$n` sera interprété littérallement (avec `n` un entier positif).

Exemples
--------

Dans le script qui suit, on utilise `replace()` d'une instance de `String` pour inverser le premier mot et le dernier et placer une virgule entre. Le script utilise `$1` et `$2` pour faire référence aux groupes de l'expression rationnelle :


```js
var re = /(\w+)\s(\w+)/;
var str = "Jean Biche";
str.replace(re, "$2, $1"); // "Biche, Jean"
RegExp.$1; // "Jean"
RegExp.$2; // "Biche"
```

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

Ces propriétés ne sont pas standard, elles ne font partie d'aucune spécification.

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

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

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

* Non-standard
 `RegExp.input ($_)`
* Non-standard
 `RegExp.lastMatch ($&)`
* Non-standard
 `RegExp.lastParen ($+)`
* Non-standard
 `RegExp.leftContext ($`)`
* Non-standard
 `RegExp.rightContext ($')`
RegExp.prototype.source
=======================

La propriété **`source`** renvoie une chaîne de caractères qui contient le texte du motif à rechercher (*pattern*), sans les barres obliques (*slashes*). C'est une propriété en lecture seule liée à l'instance. **`source`** ne contient aucun des options ou drapeaux (*flags*) (tels que "g", "i" ou "m") de l'expression rationnelle.

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

| Attributs de `RegExp.prototype.source` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Oui |

Exemples
--------

### Utiliser `source`


```js
var regex = /totoMachin/gi;

console.log(regex.source); // "totoMachin"
```

### Les expressions ratonnelles vides et l'échappement

À partir d'ECMAScript 5, la propriété `source` ne renvoie plus une chaîne vide pour les expressions rationnelles vides. Elle renvoie la chaîne `"(?:)"`. De plus, les fins de lignes (telles que "\n") sont désormais échappées.


```js
new RegExp().source; // "(?:)"

new RegExp("\n").source === "\n"; // true avant ES5
new RegExp("\n").source === "\\n"; // true à partir d'ES5
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.source |

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

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

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

* `RegExp.prototype.flags`
RegExp.prototype.sticky
=======================

La propriété **`sticky`** (adhérante) permet de déterminer si la recherche s'effectue uniquement à partir de l'indice `lastIndex` lié à l'expression rationnelle ou non). `sticky` est une propriété accessible en lecture seule, rattachée à l'instance.

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

| Attributs de `RegExp.prototype.sticky` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Oui |

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

La propriété `sticky` est un booléen qui vaut `true` si le marqueur (*flag*) "`y`" a été utilisé, `false` sinon. Ce marqueur indique que les correspondances ne sont recherchées qu'à partir de l'indice `lastIndex` au niveau de la chaîne de caractères (les correspondances à partir des autres positions ne seront pas trouvées). Lorsqu'une expression rationnelle qui utilise le marqueur `sticky` **et** le marqueur `global` ignorera le marqueur `global`.

La propriété `sticky` ne peut pas être modifiée directement. Elle est uniquement en lecture seule.

Exemples
--------

### Utiliser une expression rationnelle avec le *flag* *sticky*


```js
var str = "#toto#";
var regex = /toto/y;

regex.lastIndex = 1;
regex.test(str); // true
regex.lastIndex = 5;
regex.test(str); // false (lastIndex est pris en compte avec sticky)
regex.lastIndex; // 0 (on rénitialise après un échec)
```

### Marqueur d'adhérence « ancré »

Pendant plusieurs versions, le moteur JavaScript de Firefox, SpiderMonkey, avait un bug qui entraînait des correspondances invalides lorsqu'étaient utilisés le marqueur d'adhérence et le symbole `^` dans l'expression rationnelle. Ce bug est apparu peu après Firefox 3.6. Afin d'éviter ce bug, la spécification ES2015 indique spécifiquement que, lorsque le marqueur `y` est utilisé avec un motif commençant par `^`, ce dernier doit correspondre au début de la chaine (ou, si `multiline` vaut `true`, au début de la ligne). Les exemples qui suivent illustrent le comportement correct :


```js
var regex = /^foo/y;
regex.lastIndex = 2; // désactive la correspondance au début
regex.test("..foo"); // false

var regex2 = /^foo/my;
regex2.lastIndex = 2;
regex2.test("..foo"); // false
regex2.lastIndex = 2;
regex2.test(".\nfoo"); // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.sticky |

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

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

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

* `RegExp.prototype.global`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.lastIndex`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
RegExp.prototype.global
=======================

La propriété **`global`** indique si le marqueur (*flag*) "`g`" est utilisé pour l'expression rationnelle. `global` est une propriété accessible en lecture seule pour une expression rationnelle donnée.

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

| Attributs de `RegExp.prototype.global` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Oui |

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

La valeur de `global` est un booléen. Elle vaut `true` si le flag "`g`" a été utilisé, `false` sinon. Le *flag* "`g`" indique que l'expression rationnelle recherchera toutes les correspondances possibles d'une chaîne de caractères. Lorsqu'une expression rationnelle utilise à la fois les marqueurs `global` et `sticky` (respectivement `"g"` et `"y"`), elle ignorera le marqueur `global`.

Cette propriété ne peut pas être modifiée directement.

Exemples
--------


```js
var regex = new RegExp("toto", "g");

console.log(regex.global); // true

var str = "totoexempletoto";
var str1 = str.replace(regex, "");

console.log(str1); // affichera "exemple" dans la console

var regex1 = new RegExp("toto");
var str2 = str.replace(regex1, "");

console.log(str2); // affichera "exempletoto" dans la console
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.global |

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

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

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

* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.lastIndex`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
get RegExp[@@species]
=====================

La propriété accesseur **`RegExp[@@species]`** renvoie le constructeur `RegExp`.

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

Syntaxe
-------


```js
RegExp[Symbol.species];
```

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

L'accesseur `species` renvoie le constructeur par défaut pour les objets `RegExp`. Les constructeurs des sous-classes peuvent surcharger ce symbole afin de modifier l'affectation du constructeur.

Exemples
--------

La propriété `species` renvoie le constructeur par défaut, dans le cas des objets `RegExp`, c'est le constructeur `RegExp` :


```js
RegExp[Symbol.species]; // function RegExp()
```


Pour les objets dérivés (par exemple, une classe `MaRegExp`), la valeur de `species` sera le constructeur `MaRegExp`. Il est possible de surcharger ce comportement afin de renvoyer le constructeur parent `RegExp` :


```js
class MaRegExp extends RegExp {
  // On surcharge species pour renvoyer
  // le constructeur parent RegExp
  static get [Symbol.species]() {
    return RegExp;
  }
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp-@@species |

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

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

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

* `RegExp`
* `Symbol.species`
RegExp.rightContext ($')
========================

**Non standard:** Cette fonctionnalité n'est ni standard, ni en voie de standardisation. Ne l'utilisez pas pour des sites accessibles sur le Web : elle ne fonctionnera pas pour tout utilisateur. Il peut également y avoir d'importantes incompatibilités entre les implémentations et son comportement peut être modifié dans le futur.

La propriété non-standard **`rightContext`** est une propriété statique, accessible uniquement en lecture, qui contient la sous-chaîne suivant la correspondance la plus récente. `RegExp.$'` est un alias pour cette propriété.

Syntaxe
-------


```js
RegExp.rightContext;
RegExp["$'"];
```

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

La propriété `rightContext` est une propriété statique et n'est pas liée à une instance d'expression rationnelle. Pour cette raison, il faut toujours utiliser la syntaxe `RegExp.rightContext` ou `RegExp["$'"].`

La valeur de la propriété `rightContext` n'est accessible qu'en lecture. Le moteur la modifie à chaque fois qu'une nouvelle correspondance est trouvée.

L'alias ne peut pas être utilisé avec la syntaxe utilisant le point (`RegExp.$'`). En effet, l'analyseur (*parser*) attend un début de chaîne du fait de la simple quote, ce qui provoquerait une exception `SyntaxError`. Il faut donc utiliser la notation à base de crochets.

Exemples
--------


```js
var re = /coucou/g;
re.test("coucou monde !");
RegExp.rightContext; // " monde !"
RegExp["$'"]; // " monde !"
```

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

Cette propriété n'est pas standard, elle ne fait partie d'aucune spécification.

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

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

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

* Non-standard
 `RegExp.input ($_)`
* Non-standard
 `RegExp.lastMatch ($&)`
* Non-standard
 `RegExp.lastParen ($+)`
* Non-standard
 `RegExp.leftContext ($`)`
* Non-standard
 `RegExp.$1-$9`