Cours Regex

Les fondations des expressions régulières : motifs littéraux, classes de caractères de base, le joker `.` et l'échappement des méta-caractères.

1. 1.1Motifs littérauxCaractères normaux, sensibilité à la casse et première exécution : correspondance (match) et index.~8 min
2. 1.2Classes de base : \d \w \sLes classes prédéfinies pour les chiffres, les caractères de mots et les espaces (et leurs versions niées).~10 min
3. 1.3Le joker : le point `.`Le caractère `.` correspond à presque tout : ce qu'il inclut, ce qu'il exclut, et pourquoi le flag `s` est nécessaire.~8 min
4. 1.4Échappement des méta-caractèresLes 12 méta-caractères à échapper avec `\`, quand le double antislash est requis et pourquoi.~10 min

Combien de répétitions : `*`, `+`, `?`, intervalles `{n,m}` et la différence entre greedy et lazy (glouton et paresseux).

1. 2.1`*`, `+`, `?`Zéro ou plus, un ou plus, optionnel : les trois quantificateurs de base.~10 min
2. 2.2Quantités exactes `{n,m}`Exactement `n`, de `n` à `m`, au moins `n` : le quantificateur numérique.~10 min
3. 2.3Greedy vs lazyPar défaut, les quantificateurs sont gloutons (`.*`) ; ajoutez `?` pour la version paresseuse (`.*?`).~10 min
4. 2.4Backtracking : notionsCe que fait le moteur lorsqu'un quantificateur glouton échoue, et pourquoi cela peut coûter cher.~12 min

Position, pas caractère : ancrer au début/fin de la chaîne, aux limites de mots, et au début/fin de chaque ligne avec le flag `m`.

1. 3.1Début et fin : `^` et `$`Ancrer un motif au premier ou au dernier caractère de la chaîne.~8 min
2. 3.2Limites de mots : `\b` `\B`La transition entre un caractère de mot et un caractère de non-mot ; trouver des mots entiers.~10 min
3. 3.3Flag `m` : multiligneAvec le flag `m`, `^` et `$` s'ancrent au début/fin de chaque ligne.~10 min
4. 3.4Lignes vides et trimMotifs utiles : faire correspondre des lignes vides, supprimer les espaces au début/fin d'une ligne.~10 min

Regrouper avec `()`, choisir parmi des alternatives avec `|`, éviter la capture avec `(?:...)`, donner des noms aux groupes avec `(?<nome>...)` et faire référence à une capture précédente avec les backreferences.

1. 4.1Groupes de capture : `(...)`Parenthèses pour regrouper et capturer ; accès aux groupes 1, 2, 3… dans les correspondances.~10 min
2. 4.2Alternatives : `|`La pipe pour choisir entre deux ou plusieurs sous-motifs ; précédence et parenthèses.~10 min
3. 4.3Groupes de non-capture : `(?:...)`Regrouper sans créer de capture : utile pour quantifier ou alterner.~10 min
4. 4.4Groupes nommés et références`(?<nome>...)` pour donner un nom ; `\1` `\k<nome>` pour faire référence à la capture.~12 min

Définir des ensembles personnalisés avec `[...]`, utiliser des plages, nier avec `[^...]` et utiliser les propriétés Unicode avec `\p{...}` et le flag `u`.

1. 5.1Ensembles de caractères : `[abc]`Crochets pour définir un ensemble de caractères autorisés à une position.~8 min
2. 5.2Plages dans les classes : `[a-z0-9]`Intervalles avec le tiret ; combiner les plages et les caractères uniques.~8 min
3. 5.3Négation : `[^...]`Une classe niée correspond à tout sauf aux caractères listés.~8 min
4. 5.4Unicode property escapes`\p{L}`, `\p{N}`, `\p{Script=...}` avec le flag `u` : classes sémantiques Unicode.~12 min

Assertions de largeur nulle : regarder devant ou derrière dans la chaîne sans consommer de caractères. Lookahead `(?=)` `(?!)`, lookbehind `(?<=)` `(?<!)`.

1. 6.1Lookahead positif : `(?=...)`Vérifie que la position courante est suivie d'un certain motif, sans le consommer.~10 min
2. 6.2Lookahead négatif : `(?!...)`Vérifie que la position courante n'est PAS suivie d'un certain motif.~10 min
3. 6.3Lookbehind : `(?<=...)` `(?<!...)`Les versions « regarder derrière » (lookbehind) des lookarounds ; supporté en ES2018+.~12 min
4. 6.4Lookaround en pratiqueExtraer un valor sin incluir el contexto, validar contraseñas, parsear números delimitados.~12 min

Tous les flags (y compris `d`, `v`), `String.prototype.replace`/`replaceAll`/`split` avec expressions régulières, références `$1`/`$<nome>` dans la chaîne de remplacement et callbacks de remplacement.

1. 7.1Tous les flags en détail`g i m s u v y d` : le rôle de chacun et comment ils se combinent.~12 min
2. 7.2Remplacement de base et `$1`Remplacer les correspondances par une chaîne fixe ou par des références `$1` / `$<nome>`.~10 min
3. 7.3Remplacement avec callbackFonction de remplacement : transformer chaque correspondance avec du code JS arbitraire, accès aux groupes.~12 min
4. 7.4Split avec regexDécouper une chaîne sur un motif (CSV permissif, analyseur lexical minimal).~10 min

Mettre en application sur des problèmes réels : valider des e-mails, parser des logs, extraire des URL/IP et concevoir des expressions régulières à l'abri du ReDoS.

1. 8.1Valider un e-mailUn motif « assez bon » pour les e-mails, avec explication des compromis.~12 min
2. 8.2Analyseur de logs ApacheExtraire l'IP, la méthode, le chemin et le code d'état d'une ligne de log à l'aide de groupes nommés.~12 min
3. 8.3Extraire des URL et des IPReconnaître les URL http(s) et les adresses IPv4 au milieu d'un texte libre.~12 min
4. 8.4Écrire des motifs ReDoS-safeIdentifier les motifs catastrophiques (`(a+)+b`), les réécrire, utiliser des équivalents de quantificateurs atomiques.~14 min