Antisèche sur la syntaxe des expressions rationnelles
=====================================================

Cette page fournit une « antisèche » sur l'ensemble des fonctionnalités offertes par la syntaxe des objets `RegExp` en agrégeant le contenu des articles contenus dans le guide sur les expressions rationnelles. Si vous avez besoin de plus d'informations sur un sujet donné, vous pouvez suivre le lien donné en début de chaque section pour accéder à l'article correspondant. Vous pouvez également aller consulter le guide en question.

Classes de caractères
---------------------

Les classes de caractères permettent de distinguer différents types de caractères comme, entre autres, les lettres ou les chiffres.

| Caractères | Signification |
| --- | --- |
| `.` | Peut signifier :* Correspond à n'importe quel caractère *à l'exception* des terminateurs de ligne : `\n`, `\r`, `\u2028` ou `\u2029`. Ainsi, `/.y/` correspondra à "my" et "ay", mais pas à "yes" pour la chaîne de caractères "yes make my day".
* À l'intérieur d'une classe de caractères, le point perd ce sens spécial et correspond, littéralement, à un point.

On notera que le marqueur multiligne `m` ne modifie pas le comportement du point. Aussi, pour qu'un motif corresponde sur plusieurs lignes, la classe de caractères `[^]` pour être utilisée, car elle correspondra à tout caractère, y compris ceux de nouvelle ligne.
ES2018 a ajouté le marqueur `s` "dotAll", qui permet au point de correspondre aux terminateurs de ligne. |
| `\d` | Correspond à tout chiffre (chiffre arabe). Équivalent à la classe `[0-9]`. Ainsi, `/\d/` ou `/[0-9]/` correspondent à "2" dans "B2 est le numéro de suite". |
| `\D` | Correspond à tout caractère qui n'est pas un chiffre (chiffre arabe). Équivalent à la classe `[^0-9]`. Ainsi, `/\D/` ou `/[^0-9]/` correspondent à "B" dans "B2 est le numéro de suite". |
| `\w` | Correspond à tout caractère alphanumérique appartenant à l'alphabet latin ou aux chiffres arabes, incluant également le tiret bas. Équivalent à la classe `[A-Za-z0-9_]`. Ainsi, `/\w/` pourra correspondre à "a" dans "apple", "5" dans "$5.28", et "3" dans "3D". |
| `\W` | Correspond à tout caractère qui n'est pas un caractère de mot de l'alphabet latin ou des chiffres arabes. Équivalent à la classe `[^A-Za-z0-9_]`. Ainsi, `/\W/` ou `/[^A-Za-z0-9_]/` correspondra à "%" dans "50%". |
| `\s` | Correspond à un caractère de blanc, ce qui inclut un espace, une tabulation, une tabulation verticale, un saut de ligne ou les autres caractères d'espacement Unicode. Équivalent à la classe `[\f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]`. Ainsi, `/\s\w*/` correspondra à " truc" dans "toto truc". |
| `\S` | Correspond à un caractère qui n'est pas un blanc. Équivalent `[^\f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]`. Ainsi, `/\S\w*/` correspondra à "toto" dans "toto truc". |
| `\t` | Correspond à une tabulation horizontale. |
| `\r` | Correspond à un retour chariot. |
| `\n` | Correspond à un saut de ligne. |
| `\v` | Correspond à une tabulation verticale. |
| `\f` | Correspond à un saut de page. |
| `[\b]` | Correspond à un retour arrière. Si vous recherchez le caractère de limite de mot, (`\b`), voir Limites. |
| `\0` | Correspond au caractère NUL. Ne doit pas être suivi par un autre chiffre. |
| `\c*X*` | Correspond à un caractère de contrôle représenté par sa notation caret, où "X" est une lettre de A à Z (correspondant respectivement aux points de code `U+0001` *à* `U+001F`). Ainsi, `/\cM/` correspondra à "\r" dans "\r\n". |
| `\x*hh*` | Correspond au caractère dont le code hexadécimal sur deux chiffres vaut `*hh*`. |
| `\u*hhhh*` | Correspond au codet UTF-16 de valeur hexadécimale (représentée sur 4 chiffres) `*hhhh*`. |
| `\u*{hhhh}* or *\u{hhhhh}*` | (Uniquement lorsque le marqueur `u` est activé) Correspond au caractère dont la valeur Unicode représentée en hexadécimale vaut `U+*hhhh*` ou `U+*hhhhh*` . |
| `\` | Indique que le caractère suivant devrait être traité spécialement ou échappé. Il se comporte d'une de ces deux façons.* Pour les caractères usuellement traités littéralement, cela indique que le prochain caractère est spécial et ne devrait pas être interprété littéralement. Ainsi, `/b/` correspond au caractère "b". En ajoutant une barre oblique inversée devant "b", c'est-à-dire en utilisant `/\b/`, le caractère devient spécial et indique une limite de mot.
* Pour les caractères usuellement traités comme spéciaux, cela indique que le prochain caractère n'est pas spécial et devrait être interprété littéralement. Par exemple, "\*" est un caractère spécial qui indique 0 ou plusieurs occurrences du caractère précédent : `/a*/` correspondre à 0 ou plusieurs fois le caractère "a". Pour avoir une correspondance littérale du caractère `*`, il faudra utiliser une barre oblique inversée en préfixe : `/a\*/` correspondra à "a\*".

On notera que certains caractères comme `:`, `-`, `@` n'ont pas de signification spéciale, qu'ils soient échappés ou non. Ainsi, les séquences d'échappement comme `\:`, `\-`, `\@` seront équivalentes à la forme littérale du caractère non échappé. Toutefois, pour les expressions rationnelles avec le marqueur unicode, ces échappements génèreront une erreur *invalid identity escape*. Cela est fait pour s'assurer de la rétro-compatibilité pour le code existant qui utilise des nouvelles séquences d'échappement comme `\p` ou `\k`.

**Note :** Afin de correspondre à ce caractère ("\") littéralement, on l'échappera lui-même en utilisant `/\\/`.
 |

Assertions
----------

Les assertions incluent les limites (décrivant les débuts et fins de ligne ou de mots) et d'autres motifs indiquant certains critères pour qu'une correspondance soit possible (recherche en avant, en arrière, expressions conditionnelles).

### Assertions de limites

| Caractères | Signification |
| --- | --- |
| `^` | Correspond au début de la chaîne. Si le marqueur multiligne est présent, cela correspond également immédiatement après un caractère de rupture de ligne. Ainsi, `/^U/` ne correspond pas au "U" dans "un U", mais correspond au premier "U" dans "Un U".

**Note :** Ce caractère a un sens différent s'il apparaît au début d'un groupe.
 |
| `$` | Correspond à la fin de la chaîne. Si le marqueur multiligne est présent, cela correspond également immédiatement avant un caractère de rupture de ligne. Ainsi, `/t$/` ne correspond pas au "t" dans "élémentaire", mais lui correspond dans "élément". |
| `\b` | Correspond à une limite de mot. Il s'agit de la position où un caractère de mot n'est pas suivi ou précédé d'un autre caractère de mot. Par exemple entre une lettre et un espace. La limite de mot n'est pas incluse dans la correspondance. Autrement dit, la longueur d'une limite de mot vaut zéro.
Exemples :* `/\bm/` correspond au "m" dans "mur".
* `/oo\b/` ne correspond pas à "oo" dans "cool", car "oo"
 est suivi par "l" qui est un caractère de mot.
* `/ool\b/` correspond à "ool" dans "cool", car "ool" est à la fin de la chaîne de caractères et n'est donc pas suivi par un caractère de mot.
* `/\w\b\w/` ne correspondra jamais à rien, car un caractère de mot ne peut pas être suivi à la fois par une limite de mot et par un caractère de mot.

Pour la correspondance du caractère retour arrière (`[\b]`), voir les classes de caractères. |
| `\B` | Correspond à une position qui n'est pas une limite de mot. Il s'agit d'une position où le caractère précédent et le caractère suivant sont du même type : ou tous les deux sont des caractères de mot, ou tous les deux ne sont pas des caractères de mot. On a donc cette correspondance entre deux lettres ou entre deux espaces. De même que pour la limite de mot, cette position n'est pas incluse dans la correspondance. Ainsi, `/\Bol/` correspond à "ol" dans "truc cool", et `/hi\B/` correspond à "hi" dans "c'était hier". |

### Autres assertions

**Note :** Le caractère `?` peut également être utilisé comme quantificateur.


| Caractères | Signification |
| --- | --- |
| `x(?=y)` | **Recherche en avant** Correspond à "x" uniquement si "x" est suivi par "y". Ainsi, /`Jack(?=Sprat)/` ne correspond à "Jack" qui si celui-ci est suivi par "Sprat". `/Jack(?=Sprat|Frost)/` correspond à "Jack" uniquement si celui-ci est suivi par "Sprat" ou "Frost". Toutefois, "Sprat" ou "Frost" ne font pas partie du résultat de la correspondance. |
| `x(?!y)` | **Recherche en avant négative** Correspond à "x" uniquement si "x" n'est pas suivi par "y". Ainsi, `/\d+(?!\.)/` correspond à un nombre, uniquement s'il n'est pas suivi par un point. `/\d+(?!\.)/.exec('3.141')` trouvera une correspondance pour "141" mais pas pour "3". |
| `(?<=y)x` | **Recherche en arrière** Correspond à "x" uniquement si "x" est précédé de "y". Ainsi, `/(?<=Jack)Sprat/` correspond à "Sprat" uniquement s'il est précédé par "Jack". `/(?<=Jack|Tom)Sprat/` correspond à "Sprat" uniquement s'il est précédé par "Jack" ou "Tom". Toutefois, ni "Jack" ni "Tom" ne font partie du résultat de la correspondance. |
| `(?<!y)x` | **Recherche en arrière négative** Correspond à "x" uniquement si "x" n'est pas précédé de "y". Ainsi, `/(?<!-)\d+/` correspond à un nombre, uniquement s'il n'est pas précédé d'un signe moins `/(?<!-)\d+/.exec('3')` trouvera une correspondance avec "3". `/(?<!-)\d+/.exec('-3')` ne trouvera pas de correspondance car le nombre est précédé d'un signe moins. |

Groupes et intervalles
----------------------

Les groupes et intervalles indiquent des groupes ou intervalles pour les caractères.

| Caractères | Signification |
| --- | --- |
| `*x*|*y*` | Correspond à "x" ou "y". Ainsi `/verte|rouge/` correspondra à "verte" dans "pomme verte" et à "rouge" dans "pomme rouge". |
| `[xyz][a-c]` | Une classe de caractères. Correspond à n'importe lequel des caractères entre crochets. Il est possible d'indiquer un intervalle de caractères en utilisant un tiret. Toutefois, si le tiret apparaît comme premier ou dernier caractère entre les crochets, il sera interprété littéralement.
Ainsi, `[abcd]` est équivalent à `[a-d]` et trouve "b" comme correspondance dans "bonnet", et "c" comme correspondance dans "côté".
Par exemple, `[abcd-]` et `[-abcd]` correspondent au "b" dans "bonnet", au "c" dans "côté" et au tiret dans "peut-être".
Par exemple, `[\w-]` est équivalent à `[A-Za-z0-9_-]`. "b" est une correspondance dans "bonnet", "c" est une correspondance dans "côté", et "t" est une correspondance dans "peut-être". |
| `[^xyz][^a-c]` | La négation ou le complément d'une classe de caractère. Correspond à tout ce qui n'est pas indiqué entre les crochets. Il est possible d'indiquer un intervalle de caractères en utilisant un tiret. Si ce dernier est le premier ou le dernier caractère entre les crochets, il est interprété littéralement. Ainsi `[^abc]` est équivalent à `[^a-c]`. En utilisant ce motif, on a une correspondance pour "o" dans "coucou" et pour "h" dans "chouette".

**Note :** Le caractère ^ peut également indiquer le début d'une chaîne de caractères.
 |
| `(*x*)` | **Groupe capturant** Correspond à `*x*` et mémorise la correspondance. Ainsi, `/(toto)/` correspond à "toto" dans "toto truc" et mémorise cette correspondance.
Une expression rationnelle peut avoir plusieurs groupes capturants. Les résultats de ces mémorisations sont stockés dans un tableau dont les éléments suivent le même ordre que les parenthèses ouvrantes des groupes capturants, ce qui correspond généralement à l'ordre des groupes. On peut ainsi accéder aux résultats avec l'index correspondant (`[1], ..., [n]`) ou en utilisant les propriétés de l'objet `RegExp` (`$1, ..., $9`).
Les groupes capturants induisent un coût en performances. Si vous n'avez pas besoin de réutiliser les fragments de chaînes qui correspondent, privilégiez l'utilisation des groupes non capturants (voir ci-après).
`String.match()` ne renverra pas de groupes si le marqueur `/.../g` est utilisé. Toutefois, on peut toujours utiliser `String.matchAll()` pour obtenir toutes les correspondances. |
| `\*n*` | Avec "n" un entier positif. Une référence à la n-ième correspondance fournie par un groupe. Ainsi, `/pomme(,)\sorange\1/` correspond à "pommme, orange," dans "pommme, orange, cerise, pêche". |
| \k<Nom> | Une référence au dernier fragment de chaîne correspondant au **groupe capturant nommé** indiqué par `<Nom>`.
Ainsi, `/(?<titre>\w+), oui \k<titre>/` correspondra à "Messire, oui Messire" dans "Encore du travail ? Messire, oui Messire".

**Note :** `\k` est utilisé ici littéralement pour indiquer le début d'une référence vers un groupe de capture nommé.
 |
| `(?<Nom>x)` | **Groupe de capture nommé** Correspond à "x" et enregistre la correspondance avec le nom indiqué par `<Nom>`. Les chevrons (`<` et `>`) sont nécessaires pour indiquer le nom du groupe.
Ainsi, pour extraire le département d'un code postal, on pourra utiliser `/\((?<dep>\d{2})\d+\)/`. Le résultat sera alors disponible via `matches.groups.dep`. |
| `(?:*x*)` | **Groupe non-capturant** Correspond à "x" mais ne garde pas la correspondance en mémoire. La sous-chaîne correspondante ne peut pas être récupérée depuis les éléments du tableau des correspondances (`[1], ..., [n]`) ou depuis les propriétés prédéfinies de l'objet `RegExp` (`$1, ..., $9`). |

Quantificateurs
---------------

Les quantificateurs indiquent le nombre de caractères ou d'expressions pour la correspondance.

**Note :** Dans ce qui suit, *élément* fait référence à des caractères uniques ou à des classes de caractères, des échappements Unicode, des groupes et des intervalles.


| Caractères | Signification |
| --- | --- |
| `*x**` | Correspond à l'élément précédent "x" 0 ou plusieurs fois. Ainsi, `/bo*/` correspondra à "buuuuu" dans "Il a marqué un buuuuut" et à "b" dans "Un bateau gazouilla", mais à rien dans "Un fromage de chèvre". |
| `*x*+` | Correspond à l'élément précédent "x" 1 ou plusieurs fois. Cette forme est équivalente à `{1,}`. Ainsi, `/a+/` correspond à "a" dans "bateau" et à tous les "a" dans "levioosaaaaa". |
| `*x*?` | Correspond à l'élément précédent "x" 0 ou 1 fois. Ainsi, `/e?le?/` correspond à "el" dans "dégel" et à "le" dans "angle."
S'il est utilisé immédiatement après l'un des quantificateurs `*`, `+`, `?`, ou `{}`, cela rend le quantificateur « non-glouton » et celui correspond alors pour le minimum de la quantité (alors que par défaut, la correspondance s'effectue pour la quantité maximale). |
| `*x*{*n*}` | Avec "n" un entier positif, correspond à "n" occurrences, exactement, de l'élément "x" précédent. Ainsi, `/a{2}/` ne correspond pas à "a" dans "bateau" mais correspond à tous les "a" dans "baateau" et seulement au deux premiers "a" dans "baaaaateau". |
| `*x*{*n*,}` | Avec "n" un entier positif, correspond à au moins "n" occurrences de l'élément "x" précédent. Ainsi, `/a{2,}/` ne correspond pas à "a" dans "bateau", mais correspond à tous les "a" dans "baateau" et dans "baaaaaateau". |
| `*x*{*n*,*m*}` | 
 Avec "n" qui vaut 0 ou un entier positif et "m" un autre entier positif, et
 `*m* > *n*`, correspond au moins à "n" et au plus à "m" occurrences de l'élément "x" précédent. Ainsi, `/a{1,3}/` ne correspond à rien dans "bteau", à "a" dans "bateau", aux deux "a" dans "baateau", et aux trois premiers "a" dans "baaaaateau". On voit ici que la correspondance dans le dernier exemple est "aaa", même si la chaîne originale contient plus de "a".
  |
| `*x**?`
`*x*+?`
`*x*??`
`*x*{n}?`
`*x*{n,}?`
`*x*{n,m}?` | Par défaut, les quantificateurs comme `*` et `+` sont « gloutons », ce qui signifie que la correspondance est la plus grande possible. Ajouter le caractère `?` après le quantificateur le rend « non-glouton », ce qui signifie que la correspondance est alors la plus courte possible. Ainsi, avec une chaîne comme "du <toto> <truc> avec </truc> </toto> bidule":* `/<.*>/` correspondra à "<toto> <truc> avec </truc> </toto>"
* `/<.*?>/` correspondra à "<toto>"
 |

Échappement de propriétés Unicode
---------------------------------

Les séquences d'échappement de propriétés Unicode permettent de cibler des caractères en fonction de leurs propriétés Unicode.


```js
// Valeurs non-binaires
\p{ValeurPropriétéUnicode}
\p{NomPropriétéUnicode=ValeurPropriétéUnicode}

// Valeurs binaires et non-binaires
\p{NomPropriétéUnicodeBinaire}

// Négation : \P correspond à la négation de \p
\P{ValeurPropriétéUnicode}
\P{NomPropriétéUnicodeBinaire}
```


NomPropriétéUnicodeBinaire

Le nom d'une propriété binaire Unicode. Par exemple `ASCII`, `Alpha`, `Math`, `Diacritic`, `Emoji`, `Hex_Digit`, `Math`, `White_space`, etc. Voir la liste des propriétés dans les données Unicode pour plus d'informations.

NomPropriétéUnicode

Le nom d'une propriété non-binaire :

* General\_Category (`gc`)
* Script (`sc`)
* Script\_Extensions (`scx`)

Voir aussi PropertyValueAliases.txt

ValeurPropriétéUnicode

L'une des valeurs indiquées dans la section "Values". De nombreuses valeurs ont des alias ou des noms raccourcis (par exemple, la valeur `Decimal_Number`, de la propriété `General_Category`, peut être écrite `Nd`, `digit`, ou encore `Decimal_Number`). Pour la plupart des valeurs, la partie `NomPropriétéUnicode` et le signe égal peuvent être omis. Si `NomPropriétéUnicode` est indiqué, la valeur doit correspondre au type de propriété indiquée.


**Note :** Il existe de nombreuses propriétés et valeurs disponibles. Il serait laborieux de les lister ici de façon exhaustive.