Assertions avant et arrière

Comprendre les sujets avancés des expressions régulières JavaScript est bénéfique pour tout développeur souhaitant améliorer ses compétences en programmation. Parmi les fonctionnalités les plus avancées et les plus puissantes de ce domaine figurent les assertions avant (lookahead) et arrière (lookbehind). Ces assertions permettent aux développeurs de rechercher des motifs dans un texte sans inclure ces motifs dans le résultat. Ce guide vise à fournir une exploration approfondie des assertions avant et arrière en JavaScript, accompagnée de nombreux exemples pratiques.

Introduction aux assertions avant et arrière

Les assertions avant et arrière sont des assertions de largeur zéro, ce qui signifie qu'elles correspondent à une position dans la chaîne plutôt qu'à des caractères réels. Elles permettent de vérifier si un motif donné existe ou non à un point précis de la chaîne. Remarque : les moteurs JavaScript modernes (ES2018+) prennent en charge les assertions arrière de longueur variable, bien que certains environnements plus anciens puissent nécessiter des motifs de longueur fixe.

Il existe quatre assertions, formées en combinant la direction (avant/arrière) avec la polarité (positive/négative) :

Pourquoi la « largeur zéro » est-elle importante ?

Comme les assertions correspondent à une position et non à des caractères, le texte qu'elles vérifient n'est jamais inclus dans la correspondance et la position de lecture du moteur de regex n'avance pas au-delà. C'est précisément ce qui les rend utiles : vous pouvez exiger un contexte autour d'une correspondance sans que ce contexte fasse partie du résultat. L'extrait ci-dessous montre la différence entre un vrai groupe capturant et une assertion avant — les deux vérifient que pie suit apple, mais seul le groupe consomme le texte :

Si vous débutez avec la syntaxe des groupes (...), consultez les groupes capturants — les assertions de contexte utilisent les mêmes parenthèses mais ajoutent ?=, ?!, ?<= ou ?<! juste après le crochet d'ouverture.

Assertion avant positive

Une assertion avant positive vérifie l'existence d'un certain motif en avant de la position actuelle dans la chaîne. Elle est notée (?=...). L'exemple suivant utilise une assertion avant positive pour trouver le mot « apple » suivi du mot « pie » :

La lookaround JavaScript correspond aux caractères

Assertion avant négative

Une assertion avant négative vérifie l'absence d'un certain motif en avant de la position actuelle. Elle est notée (?!...). L'exemple suivant utilise une assertion avant négative pour trouver le mot « apple » non suivi du mot « pie » :

L'assertion avant négative en JavaScript

Assertion arrière positive

Une assertion arrière positive vérifie l'existence d'un certain motif en arrière de la position actuelle dans la chaîne. Elle est notée (?<=...). Voici un exemple de code pour trouver le mot « pie » précédé du mot « apple » :

L'assertion arrière positive en JavaScript

Assertion arrière négative

Une assertion arrière négative vérifie l'absence d'un certain motif en arrière de la position actuelle. Elle est notée (?<!...). Voici un exemple pour trouver le mot « pie » non précédé du mot « apple » :

Assertions avant et arrière

Applications pratiques des assertions avant et arrière

Valider la robustesse d'un mot de passe

S'assurer que les mots de passe sont robustes est une exigence courante dans les applications web. Les assertions avant peuvent être utilisées pour valider diverses conditions de mot de passe sans consommer de caractères.

Ici, chaque (?=...) est une exigence distincte vérifiée depuis le début de la chaîne. Comme chaque assertion avant est de largeur zéro, les quatre analysent le même texte indépendamment sans interférer les unes avec les autres, et le [A-Za-z\d@$!%*?&]{8,} final est ce qui consomme réellement le mot de passe. Les ancres ^ et $ fixent la vérification à l'ensemble de la chaîne, et {8,} est un quantificateur exigeant au moins huit caractères.

Formater et analyser des données

Les assertions avant et arrière peuvent aider à formater et à analyser des structures de données complexes. Un bon exemple est l'insertion de virgules dans une chaîne de chiffres pour en améliorer la lisibilité :

Cela fonctionne en remplaçant chaque position vide (\B, une non-frontière de mot) suivie d'un groupe de trois chiffres répétés jusqu'à la fin du nombre. Le (?!\d) final garantit que l'on ne fait correspondre que les positions où les chiffres restants se divisent exactement en groupes de trois, de sorte qu'aucune virgule n'est placée tout au début.

Extraire le montant d'un prix

L'assertion arrière est idéale pour saisir une valeur qui se trouve après un marqueur connu sans capturer le marqueur lui-même. Ici, nous extrayons le montant numérique qui suit un signe $ :

L'assertion arrière (?<=\$) exige un $ immédiatement avant le nombre mais l'exclut du résultat, de sorte que chaque correspondance ne contient que le chiffre. Comparez cela avec l'utilisation d'un groupe capturant — un groupe vous obligerait à lire le montant dans match[1], tandis que l'assertion arrière place la valeur directement dans la correspondance.

Agir uniquement quand quelque chose ne suit pas

L'assertion avant négative vous permet d'agir sur une position en fonction de ce qui ne vient pas ensuite. Cet exemple remplace hello par HI uniquement quand il n'est pas suivi de world :

Sujets connexes

• Groupes capturants — les parenthèses sur lesquelles la syntaxe des assertions de contexte repose.
• Ancres : début et fin de chaîne — ^ et $, souvent associés aux assertions avant dans la validation.
• Quantificateurs, +, *, ? et {n} — contrôler la répétition à l'intérieur et à l'extérieur des assertions.
• Quantificateurs gourmands et paresseux — comment la longueur de correspondance interagit avec les assertions de contexte.

Conclusion

Maîtriser les assertions avant et arrière en JavaScript peut considérablement améliorer votre capacité à manipuler et analyser des chaînes de caractères. Ces outils puissants offrent la flexibilité nécessaire pour imposer des motifs sans consommer de caractères, ce qui les rend indispensables pour les tâches complexes de traitement de texte. En tirant parti de ces assertions, les développeurs peuvent créer des expressions régulières plus efficaces, conduisant à un code plus propre et plus maintenable.

Exercice