Objet `RegExp`

Cet article explique l'objet RegExp.

Nous expliquerons l'objet RegExp à l'aide d'exemples pratiques.

YouTube Video

Objet RegExp

Qu'est-ce que RegExp ?

RegExp (Expression régulière) est un objet utilisé pour représenter des motifs de chaînes de caractères. Contrairement aux comparaisons simples de caractères, vous pouvez définir de manière flexible des « chaînes qui répondent à certaines conditions ».

En utilisant un objet RegExp, vous pouvez effectuer des opérations telles que rechercher, valider, extraire et remplacer des chaînes de façon concise et claire. C’est particulièrement efficace pour des tâches quotidiennes comme la validation des saisies de formulaires, l’analyse des journaux et le formatage de texte. Voici quelques exemples simples d'expressions régulières.

1const pattern = /abc/;

• Cette expression régulière vérifie si la séquence 'abc' est incluse.

Comment créer des expressions régulières (deux méthodes)

Il existe deux types de syntaxe RegExp : la notation littérale et la notation par constructeur.

1// Literal notation: pattern and flags are written together
2const literal         = /hello/;
3const literalWithFlag = /hello/i;
4const literalDigits   = /\d+/;
5
6// Constructor notation: pattern and flags are passed separately
7const constructor         = new RegExp("hello");
8const constructorWithFlag = new RegExp("hello", "i");
9const constructorDigits   = new RegExp("\\d+");

• La notation littérale est concise et lisible, ce qui la rend adaptée aux expressions régulières utilisées comme constantes.. En revanche, la notation par constructeur est utilisée lorsque vous souhaitez construire le motif à l'aide de variables ou déterminer son contenu lors de l'exécution.
• Avec la notation littérale, vous pouvez décrire intuitivement l'expression régulière ainsi que ses indicateurs ensemble. En revanche, avec la notation par constructeur, vous devez spécifier le motif et les indicateurs séparément.
• De plus, avec la notation par constructeur, l'expression régulière est transmise comme une chaîne de caractères, donc les barres obliques inverses doivent être échappées deux fois.

test() : La validation la plus basique

L’objet RegExp fournit des méthodes pour effectuer des évaluations et des opérations en utilisant des expressions régulières. test() est une méthode qui retourne un booléen indiquant si un motif correspond.

1const regex = /JavaScript/;
2
3console.log(regex.test("I love JavaScript")); // true
4console.log(regex.test("I love TypeScript")); // false

• C'est la première méthode à apprendre, et elle est idéale pour les branches conditionnelles ou la validation des saisies.

match() : Obtenir les résultats correspondants

match() retourne un tableau contenant la chaîne trouvée et des informations détaillées.

1const text = "Version 1.2.3";
2const result = text.match(/\d+\.\d+\.\d+/);
3
4console.log(result[0]); // "1.2.3"

• match() est plus pratique que test() pour les processus d'extraction et d'analyse.

replace() : Remplacer en utilisant des expressions régulières

replace() convertit la partie correspondante en une autre chaîne.

1const text = "Hello   World";
2const result = text.replace(/\s+/g, " ");
3
4console.log(result); // "Hello World"

• Vous pouvez l’utiliser pour formater des journaux ou normaliser les espaces superflus.

Bases des indicateurs (g, i, m)

Vous pouvez spécifier des « indicateurs » (flags) dans les expressions régulières. Les indicateurs sont des options qui contrôlent la façon dont une expression régulière traite les chaînes selon certaines règles. Même avec le même motif, les résultats peuvent changer en fonction des indicateurs.

1const text = "apple Apple APPLE";
2const regex = /apple/gi;        // or new RegExp("apple", "gi");
3
4console.log(text.match(regex)); // ["apple", "Apple", "APPLE"]

• L’indicateur g (global) recherche dans toute la chaîne.
• L’indicateur i (ignore case) ignore les différences de casse lors de la mise en correspondance.

1const multilineText = `apple
2banana
3apple`;
4
5const regexM = /^apple/gm;
6
7console.log(multilineText.match(regexM)); // ["apple", "apple"]

• L’indicateur m (multilignes) permet de traiter les chaînes multiligne ligne par ligne. Avec cela, ^ et $ fonctionnent en se basant sur le début ou la fin de chaque ligne, plutôt que sur l’ensemble de la chaîne.

Classes de caractères : Combiner plusieurs candidats

En utilisant les crochets [], vous pouvez définir un ensemble de caractères possibles pour une même position.

1const regex = /gr[ae]y/;
2
3console.log(regex.test("gray")); // true
4console.log(regex.test("grey")); // true

• Ceci est utile pour prendre en compte les variations orthographiques et des alternatives simples.

Métacaractères : Raccourcis courants

Les métacaractères sont des symboles qui permettent d'écrire des motifs couramment utilisés sous une forme plus courte.

1const regex = /\d{4}-\d{2}-\d{2}/;  // or new RegExp("\\d{4}-\\d{2}-\\d{2}");
2
3console.log(regex.test("2025-12-29")); // true

• \d signifie un chiffre, et {n} précise le nombre de répétitions.

^ et $ : Valider toute la chaîne

^ et $ représentent le début et la fin d'une chaîne.

1const regex = /^\d+$/;
2
3console.log(regex.test("123"));   // true
4console.log(regex.test("123a"));  // false

• Ils sont importants dans les situations où une correspondance exacte est requise, comme pour les saisies de formulaires.

Regroupement et capture

En utilisant des parenthèses (), vous pouvez extraire des valeurs partielles.

1const text = "2025/12/29";
2const regex = /(\d{4})\/(\d{2})\/(\d{2})/;
3const [, year, month, day] = text.match(regex);
4
5console.log(year, month, day); // 2025 12 29

• C'est fréquemment utilisé pour décomposer des dates et des chaînes structurées.

Erreurs courantes et points à noter

Les expressions régulières sont puissantes, mais elles deviennent difficiles à lire.

1// Hard to read
2const regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+$/;

• Si cela devient trop complexe, vous pouvez envisager d’ajouter des commentaires, de diviser les expressions ou de revoir le processus lui-même.

Résumé

RegExp est une fonctionnalité fondamentale essentielle de JavaScript pour décrire le traitement de texte de façon simple et précise. Il n'est pas nécessaire d'apprendre les expressions régulières complexes dès le début ; il est important d'utiliser des méthodes et une syntaxe de base comme test, match et replace selon vos besoins pratiques. Si vous traitez les expressions régulières non pas comme une 'connaissance spéciale' mais comme des 'outils pour une représentation organisée de motifs', vous améliorerez grandement la qualité et la lisibilité de la validation des saisies et du traitement de texte.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video