17 - Glossaire

Tous les termes utilises dans cette serie, classes par ordre alphabetique. Chaque définition est courte et va droit au but, avec un exemple quand ca aide. Si tu cherches un terme que tu as croise dans un article précédent sans bien le comprendre, tu devrais le trouver ici.

A

Alternation

L'opérateur | qui permet de choisir entre plusieurs alternatives. chat|chien matche "chat" ou "chien". Le moteur essaie la première alternative, et si elle echoue, passe a la suivante. L'alternation a la precedence la plus basse de tous les opérateurs regex : abc|def signifie (abc)|(def), pas ab(c|d)ef.

Anchor (ancre)

Un élément qui matche une position dans la chaîne, pas un caractère. Les ancres les plus courantes sont ^ (début de chaîne ou de ligne) et $ (fin de chaîne ou de ligne). Avec le flag m, elles matchent les debuts et fins de chaque ligne.

Assertion

Terme générique pour tout élément qui vérifié une condition sans consommer de caractères. Les ancres (^, $), les word boundaries (\b) et les lookaround (lookahead, lookbehind) sont tous des assertions. On les appelle aussi "zero-width assertions" parce qu'elles n'avancent pas la position du curseur dans la chaîne.

Atomic group (groupe atomique)

Un groupe qui, une fois matche, ne permet pas au moteur de revenir en arriere pour essayer d'autres combinaisons a l'intérieur. Syntaxe : (?>...) en PCRE et Java. JavaScript ne supporte pas les groupes atomiques natifs. Ils servent a éviter le backtracking catastrophique. Voir l'article 14.

B

Backreference (référencé arriere)

Une référencé a un groupe de capture précédent dans le meme pattern. \1 fait référencé au premier groupe, \2 au deuxieme, etc. Avec les groupes nommes : \k<nom>. Exemple : (["']).*?\1 matche du texte entre guillemets simples ou doubles (le meme type de guillemet ouvrant et fermant).

Backtracking (retour en arriere)

Le mecanisme par lequel un moteur NFA revient a un point de décision précédent quand le chemin actuel echoue. C'est ce qui rend les regex puissantes (elles explorent plusieurs possibilités) mais aussi potentiellement lentes (elles peuvent explorer un nombre exponentiel de chemins). Voir backtracking catastrophique.

Boundary (frontiere)

Voir word boundary.

C

Capture group (groupe de capture)

Un groupe défini par des parentheses (...) qui memorise le texte matche. Le texte capture est accessible apres le match via match[1], match[2], etc. En remplacement, on utilise $1, $2. Chaque paire de parentheses (sauf les non-capturing groups) créé un groupe numerote de gauche a droite.

Character class (classe de caractères)

Un ensemble de caractères défini entre crochets [...]. Matche un seul caractère parmi ceux listes. [aeiou] matche une voyelle. [0-9] matche un chiffre. Le ^ en première position inverse la classe : [^0-9] matche tout sauf un chiffre. Voir aussi shorthand class.

D

DFA (Deterministic Finite Automaton)

Un type de moteur regex qui ne fait jamais de backtracking. Il traite chaque caractère une seule fois, donc sa complexité est toujours lineaire. Utilise par grep, awk, et RE2 (le moteur de Go et Rust regex). L'inconvenient : il ne supporte pas les backreferences ni les lookaround. Voir aussi NFA.

Dot (point)

Le metacaractere . qui matche n'importe quel caractère sauf le saut de ligne \n (par défaut). Avec le flag s (dotAll), il matche aussi les sauts de ligne. C'est l'un des metacaracteres les plus utilises et les plus surutilises. Prefere souvent une classe de caractères negee ([^,]) pour etre plus precis.

E

Escape (echappement)

L'utilisation du backslash \ pour donner un sens special a un caractère ordinaire (\d, \w, \s) ou pour retirer le sens special d'un metacaractere (\., \*, \(). En JavaScript, dans une chaîne normale, il faut doubler les backslash : new RegExp("\\d+"). Avec les regex literals (/\d+/), un seul suffit.

F

Flag (drapeau)

Un modificateur qui change le comportement global de la regex. Les flags courants en JavaScript :

Flag	Nom	Effet
`g`	global	Trouve toutes les occurrences, pas juste la première
`i`	ignoreCase	Insensible a la casse
`m`	multiline	`^` et `$` matchent les debuts/fins de ligne
`s`	dotAll	Le `.` matche aussi `\n`
`u`	unicode	Mode Unicode (code points)
`v`	unicodeSets	Mode Unicode avec opérations ensemblistes
`d`	hasIndices	Fournit les positions de début/fin des captures

G

Global (flag g)

Le flag qui permet de trouver toutes les occurrences d'un pattern dans une chaîne, pas seulement la première. Indispensable avec matchAll() et replaceAll(). Attention : avec exec() en boucle, le flag g rend la regex stateful (elle memorise lastIndex), ce qui peut causer des bugs subtils si tu reutilises la meme regex.

Grapheme cluster

Ce qu'un humain percoit comme "un caractère". Un grapheme cluster peut etre compose de plusieurs code points Unicode. Un emoji drapeau, par exemple, est un seul grapheme cluster mais deux code points (ou quatre unités UTF-16). Les regex travaillent au niveau des code points, pas des grapheme clusters. Voir l'article 13.

Greedy (glouton)

Le comportement par défaut des quantificateurs : ils matchent le plus de texte possible. a+ sur "aaab" matche "aaa", pas "a". Voir aussi lazy.

L

Lazy (paresseux)

Le comportement d'un quantificateur suivi de ? : il matche le moins de texte possible. a+? sur "aaab" matche "a" (un seul). Les quantificateurs lazy sont *?, +?, ??, {n,m}?. Utile quand tu veux t'arrêter au premier delimiteur : ".*?" matche la plus courte chaîne entre guillemets.

Lookahead

Une assertion qui vérifié ce qui suit la position actuelle sans le consommer. Lookahead positif : (?=...) matche si le pattern est present devant. Lookahead negatif : (?!...) matche si le pattern est absent. Exemple : \d+(?= euros) matche un nombre suivi de " euros" mais ne capture pas " euros".

Lookbehind

Une assertion qui vérifié ce qui precede la position actuelle sans le consommer. Lookbehind positif : (?<=...). Lookbehind negatif : (?<!...). Exemple : (?<=\$)\d+ matche un nombre precede d'un dollar sans inclure le dollar dans le match. En JavaScript, les lookbehind sont supportes depuis ES2018.

M

Metacaractere

Un caractère qui a une signification speciale dans une regex au lieu d'etre interprète litteralement. Les metacaracteres principaux sont : . ^ $ * + ? { } [ ] ( ) | \. Pour les matcher litteralement, il faut les echapper avec \.

N

Named group (groupe nomme)

Un groupe de capture avec un nom au lieu d'un simple numero. Syntaxe : (?<nom>...). Le texte capture est accessible via match.groups.nom. Beaucoup plus lisible que match[3] quand tu as plusieurs groupes. Référence arriere : \k<nom>.

NFA (Nondeterministic Finite Automaton)

Le type de moteur regex utilise par JavaScript, Python, Java, .NET, et Perl. Il utilise le backtracking pour explorer les différentes possibilités de matching. Plus puissant qu'un DFA (supporte les backreferences et les lookaround) mais potentiellement plus lent (risque de backtracking exponentiel). Voir aussi DFA.

Non-capturing group (groupe non capturant)

Un groupe défini par (?:...) qui sert au groupement (pour appliquer un quantificateur, par exemple) sans memoriser le texte matche. (?:ab)+ matche "ababab" sans créer de capture. Utile pour garder tes numeros de groupes propres et pour de meilleures performances (le moteur n'a pas besoin de stocker le résultat).

P

Possessive quantifier (quantificateur possessif)

Un quantificateur qui ne backtrack jamais. Syntaxe : ++, *+, ?+ en PCRE et Java. JavaScript ne les supporte pas. Équivalent a un groupe atomique autour d'un quantificateur greedy. a++ matche autant de 'a' que possible et ne rend jamais ce qu'il a pris, meme si ca fait échouer le reste du pattern.

Q

Quantifier (quantificateur)

Un opérateur qui specifie combien de fois un élément doit apparaître.

Quantificateur	Signification
`*`	0 ou plus
`+`	1 ou plus
`?`	0 ou 1
`{n}`	Exactement n
`{n,}`	n ou plus
`{n,m}`	Entre n et m

Tous sont greedy par défaut. Ajoute ? pour le mode lazy.

R

Range (plage)

Dans une classe de caractères, un tiret entre deux caractères definit une plage. [a-z] matche les minuscules latines de a a z. [0-9] matche les chiffres. Les plages se basent sur les code points Unicode, donc [A-z] inclut des caractères inattendus entre Z (90) et a (97) comme [, \, ].

ReDoS (Regular Expression Denial of Service)

Une attaque qui exploite le backtracking catastrophique pour rendre un serveur indisponible. L'attaquant envoie une entree specialement crafted qui force le moteur regex a explorer un nombre exponentiel de chemins. Particulierement dangereux sur les serveurs single-threaded comme Node.js. Voir l'article 14.

Regex engine (moteur regex)

Le programme qui exécuté le matching d'une regex contre une chaîne. Les deux grandes familles sont les NFA (backtracking) et les DFA (pas de backtracking). JavaScript utilise un NFA. Chaque moteur a ses spécificités : features supportes, performances, comportement en cas d'ambiguite.

S

Shorthand class (classe abregee)

Un raccourci pour une classe de caractères courante. Les principales :

Shorthand	Équivalent	Signification
`\d`	`[0-9]`	Chiffre
`\D`	`[^0-9]`	Non-chiffre
`\w`	`[a-zA-Z0-9_]`	Caractère de mot
`\W`	`[^a-zA-Z0-9_]`	Non-mot
`\s`	`[ \t\r\n\f\v]`	Espace blanc
`\S`	`[^ \t\r\n\f\v]`	Non-espace

Avec le flag u, \d et \w restent ASCII. Pour matcher les chiffres et lettres Unicode, utilise \p{Number} et \p{Letter}.

U

Unicode property (propriété Unicode)

Un attribut défini par le standard Unicode pour chaque code point. Accessible dans les regex avec \p{Propriete} (flag u ou v requis). Les categories generales (Letter, Number, Symbol) et les scripts (Latin, Greek, Han) sont les plus utiles. Voir l'article 13.

W

Word boundary (frontiere de mot)

L'assertion \b qui matche la position entre un caractère de mot (\w) et un caractère non-mot (\W), ou entre un caractère de mot et le début/fin de chaîne. \bcat\b matche "cat" dans "the cat sat" mais pas le "cat" dans "concatenate". \B est la negation : matche les positions qui ne sont PAS des frontieres de mot.

Z

Zero-width

Se dit d'un élément regex qui matche une position sans consommer de caractère. Les ancres (^, $), les word boundaries (\b), et les lookaround ((?=...), (?<=...), (?!...), (?<!...)) sont tous zero-width. Apres un match zero-width, la position du curseur dans la chaîne ne bouge pas.

Ce glossaire couvre les termes essentiels. Pour les voir en action, reprends les articles de la serie depuis le début ou consulte les exemples pratiques dans l'article 15. Une référencé complémentaire est disponible sur paltemps.fr.

Article précédent : 16 - Quand ne pas utiliser les regex