Assertions
Les assertions incluent les limites, qui indiquent le début et la fin des lignes et des mots, ainsi que d'autres motifs indiquant d'une manière ou d'une autre qu'une correspondance est possible (y compris les assertions anticipées, les assertions de précédence et les expressions conditionnelles).
Exemple interactif
const text = "Un renard rapide";
const regexpLastWord = /\w+$/;
console.log(text.match(regexpLastWord));
// Résultat attendu : Array ["rapide"]
const regexpWords = /\b\w+\b/g;
console.log(text.match(regexpWords));
// Résultat attendu : Array ["Un", "renard", "rapide"]
const regexpFoxQuality = /\w+(?= renard)/;
console.log(text.match(regexpFoxQuality));
// Résultat attendu : Array ["rapide"]
Types
Assertions de type limite
| Caractères | Signification |
|---|---|
^ |
Assertion de début de limite d'entrée :
Correspond au début de l'entrée. Si le Note : Ce caractère a une signification différente lorsqu'il apparaît au début d'une classe de caractères. |
$ |
Assertion de fin de limite d'entrée :
Correspond à la fin de l'entrée. Si le |
\A |
Assertion de début de limite de tampon : Correspond au début de l'ensemble de la chaîne de caractères, indépendamment de la présence de l'indicateur |
\z |
Assertion de fin de limite de tampon : Correspond à la fin de l'ensemble de la chaîne de caractères, indépendamment de la présence de l'indicateur |
\Z |
Assertion de fin de limite de tampon avec saut de ligne optionnel : Correspond à la fin de l'ensemble de la chaîne de caractères, mais permet une séquence de caractères de saut de ligne facultative (soit un terminateur de ligne ou une séquence |
\b |
Assertion de limite de mot : 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é par un autre caractère de mot, comme entre une lettre et un espace. Notez qu'une limite de mot correspondante n'est pas incluse dans la correspondance. En d'autres termes, la longueur d'une limite de mot correspondante est zéro. Exemples :
Pour correspondre à un caractère de retour arrière ( |
\B |
Assertion de non-limite de mot :
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 : soit les deux doivent être des caractères de mot, soit les deux doivent être des caractères qui ne sont pas des mots, par exemple entre deux lettres ou entre deux espaces. Le début et la fin d'une chaîne de caractères sont considérés comme des caractères qui ne sont pas des mots. Comme pour la limite de mot correspondante, la non-limite de mot correspondante n'est également pas incluse dans la correspondance. Par exemple, |
Autres assertions
Note :
Le caractère ? peut également être utilisé comme quantificateur.
| Caractères | Signification |
|---|---|
x(?=y) |
Assertion anticipée :
Correspond à « x » uniquement si « x » est suivi de « y ». Par exemple, |
x(?!y) |
Assertion anticipée négative :
Correspond à « x » uniquement si « x » n'est pas suivi de « y ». Par exemple, |
(?<=y)x |
Assertion de précédence :
Correspond à « x » uniquement si « x » est précédé de « y ». Par exemple, |
(?<!y)x |
Assertion de précédence négative :
Correspond à « x » uniquement si « x » n'est pas précédé de « y ». Par exemple, |
Exemples
Exemple d'aperçu des types de délimiteurs
// Utiliser des délimiteurs Regex pour corriger une chaîne de caractères erronée.
bogueLignesMultiples = `tey, ihe light-greon apple
tangs on ihe greon traa`;
// 1) Utiliser ^ pour faire correspondre le début de la chaîne de caractères et immédiatement après un saut de ligne.
bogueLignesMultiples = bogueLignesMultiples.replace(/^t/gim, "h");
console.log(1, bogueLignesMultiples); // corrige « tey » => « hey » et « tangs » => « hangs », mais ne modifie pas « traa ».
// 2) Utiliser $ pour corriger la correspondance à la fin du texte.
bogueLignesMultiples = bogueLignesMultiples.replace(/aa$/gim, "ee.");
console.log(2, bogueLignesMultiples); // corrige « traa » en « tree. ».
// 3) Utiliser \b pour faire correspondre les caractères situés exactement à la frontière entre un mot et un espace.
bogueLignesMultiples = bogueLignesMultiples.replace(/\bi/gim, "t");
console.log(3, bogueLignesMultiples); // corrige « ihe » => « the » mais ne modifie pas « light ».
// 4) Utiliser \B pour faire correspondre les caractères à l'intérieur des frontières d'une entité.
fixedMultiline = bogueLignesMultiples.replace(/\Bo/gim, "e");
console.log(4, fixedMultiline); // corrige « greon » => « green » mais ne modifie pas « on ».
Faire correspondre le début de l'entrée en utilisant le caractère de contrôle ^
Utiliser ^ pour faire correspondre le début de l'entrée. Dans cet exemple, nous pouvons obtenir les fruits qui commencent par « A » grâce à une expression rationnelle /^A/. Pour sélectionner les fruits appropriés, nous pouvons utiliser la méthode filter avec une fonction fléchée.
const fruits = ["Pomme", "Pastèque", "Orange", "Avocat", "Fraise"];
// Sélectionne les fruits commençant avec « A » avec la Regex /^A/.
// Ici, le symbole de contrôle « ^ » est utilisé seulement pour faire correspondre le début de l'entrée.
const fruitCommencantParA = fruits.filter((fruit) => /^A/.test(fruit));
console.log(fruitCommencantParA); // [ 'Avocat' ]
Dans le deuxième exemple, ^ sert à la fois à faire correspondre le début de l'entrée et à créer une classe de caractères niée ou complémentée lorsqu'il apparaît dans les classes de caractères.
const fruits = ["Pomme", "Pastèque", "Orange", "Avocat", "Fraise"];
// Sélectionne les fruits qui ne commencent pas par 'A' avec l'expression rationnelle /^[^A]/.
// Cet exemple présente les deux significations du symbole '^' :
// 1) Faire correspondre le début de l'entrée
// 2) Une classe de caractères niée ou complémentée : [^A]
// Autrement dit, cette classe correspond à tout ce qui ne se trouve pas entre crochets.
const fruitNeCommencantPasParA = fruits.filter((fruit) => /^[^A]/.test(fruit));
console.log(fruitNeCommencantPasParA); // [ 'Pomme', 'Pastèque', 'Orange', 'Fraise' ]
Voir plus d'exemples dans la référence sur l'assertion de limite d'entrée.
Faire correspondre une limite de mot
Dans cet exemple, l'expression rationnelle correspond aux noms de fruits contenant un mot qui se termine par « ge » ou « rt ».
const fruitsAvecDescription = ["Pomme rouge", "Orange orange", "Avocat vert"];
// Sélectionne les descriptions contenant des mots qui se terminent par 'ge' ou 'rt' :
const selectionGeRt = fruitsAvecDescription.filter((description) =>
/(?:ge|rt)\b/.test(description),
);
console.log(selectionGeRt); // [ 'Pomme rouge', 'Avocat vert' ]
Voir plus d'exemples dans la référence sur l'assertion de limite de mot.
Assertion anticipée
Dans cet exemple, l'expression rationnelle correspond au mot « premier » uniquement s'il est suivi du verbe « teste », sans inclure « teste » dans le résultat de la correspondance.
const expressionPremierTeste = /premier(?= teste)/gi;
console.log("Le premier teste le fruit.".match(expressionPremierTeste)); // [ 'premier' ]
console.log("Le premier pêche.".match(expressionPremierTeste)); // null
console.log(
"Dans cet exemple, le premier teste le fruit cette année.".match(
expressionPremierTeste,
),
); // [ 'premier' ]
console.log(
"Dans cet exemple, le premier pêche ce mois-ci.".match(
expressionPremierTeste,
),
); // null
Voir plus d'exemples dans la référence sur l'assertion anticipée.
Assertion anticipée négative simple
Par exemple, /\d+(?!\.)/ correspond à un nombre uniquement s'il n'est pas suivi d'un point décimal. /\d+(?!\.)/.exec('3.141') correspond à « 141 » mais pas à « 3 ».
console.log(/\d+(?!\.)/g.exec("3.141")); // [ '141', index: 2, input: '3.141' ]
Voir plus d'exemples dans la référence sur l'assertion anticipée.
Significations différentes de la combinaison « ?! » dans les assertions et les classes de caractères
La combinaison ?! a des significations différentes dans les assertions comme /x(?!y)/ et les classes de caractères comme [^?!].
const orangeSansCitron =
"Voulez-vous manger une orange ? Oui, je ne veux pas manger de citron !";
// Significations différentes de la combinaison '?!' dans les assertions /x(?!y)/ et les plages /[^?!]/
const expressionSansCitron = /[^?!]+manger(?! de citron)[^?!]+[?!]/gi;
console.log(orangeSansCitron.match(expressionSansCitron)); // [ 'Voulez-vous manger une orange ?' ]
const expressionSansOrange = /[^?!]+manger(?! une orange)[^?!]+[?!]/gi;
console.log(orangeSansCitron.match(expressionSansOrange)); // [ ' Oui, je ne veux pas manger de citron !' ]
Assertion de précédence
Dans cet exemple, l'expression rationnelle remplace le mot « orange » par « pomme » uniquement s'il est précédé du mot « mûre ».
const oranges = ["mûre orange A", "verte orange B", "mûre orange C"];
const nouveauxFruits = oranges.map((fruit) =>
fruit.replace(/(?<=mûre )orange/, "pomme"),
);
console.log(nouveauxFruits); // ['mûre pomme A', 'verte orange B', 'mûre pomme C']
Voir plus d'exemples dans la référence sur l'assertion de précédence.
Voir aussi
- Le guide des expressions rationnelles
- Le guide des classes de caractères
- Le guide des quantificateurs
- Le guide des groupes et des références arrière
- L'objet natif
RegExp - La référence des expressions rationnelles
- Assertion de limite d'entrée :
^,$ - Assertion anticipée :
(?=...),(?!...) - Assertion de précédence :
(?<=...),(?<!...) - Assertion de limite de mot :
\b,\B