Skip to content

regex.md

Latest commit

 

History

History
214 lines (159 loc) · 6.54 KB

regex.md

File metadata and controls

214 lines (159 loc) · 6.54 KB

Les expressions régulières, ou regex, sont des motifs qui permettent de rechercher, de correspondre et de manipuler des chaînes de caractères de manière très puissante. Elles sont utilisées pour valider des entrées, rechercher des modèles spécifiques, et remplacer des parties de texte dans les chaînes. Voici comment fonctionnent les expressions régulières et comment les utiliser en JavaScript.

1. Syntaxe de base d'une regex

a) Délimiteurs :

Les expressions régulières sont généralement placées entre deux barres obliques (/), comme ceci :

const regex = /pattern/;

b) Méthodes associées à une regex en JavaScript :

  • test() : Vérifie si une chaîne correspond à la regex.

    const regex = /\d{4}/;
console.log(regex.test("1234")); // true

  • match() : Extrait les correspondances d'une chaîne.

    const text = "I have 123 apples";
console.log(text.match(/\d+/)); // ["123"]

  • replace() : Remplace les correspondances dans une chaîne.

    const text = "hello world";
console.log(text.replace(/world/, "there")); // "hello there"

2. Les symboles et métacaractères courants

a) Les symboles de base :

  • . : Correspond à n'importe quel caractère sauf le saut de ligne.

    /./   // Correspond à n'importe quel caractère

  • \d : Correspond à un chiffre (0-9).

    /\d/  // Correspond à un chiffre (0-9)

  • \D : Correspond à tout sauf un chiffre.

    /\D/  // Correspond à tout sauf un chiffre

  • \w : Correspond à un caractère alphanumérique (lettres, chiffres, ou _).

    /\w/  // Correspond à un caractère alphanumérique

  • \W : Correspond à tout sauf un caractère alphanumérique.

    /\W/  // Correspond à tout sauf un caractère alphanumérique

  • \s : Correspond à un espace blanc (espace, tabulation, saut de ligne).

    /\s/  // Correspond à un espace blanc

  • \S : Correspond à tout sauf un espace blanc.

    /\S/  // Correspond à tout sauf un espace blanc

b) Les quantificateurs :

  • + : Correspond à une ou plusieurs occurrences du caractère ou motif précédent.

    /\d+/  // Correspond à une ou plusieurs occurrences de chiffres

  • * : Correspond à zéro ou plusieurs occurrences.

    /a*/  // Correspond à zéro ou plusieurs occurrences de "a"

  • ? : Correspond à zéro ou une occurrence.

    /a?/  // Correspond à zéro ou une occurrence de "a"

  • {n} : Correspond exactement à n occurrences du motif précédent.

    /\d{4}/  // Correspond exactement à 4 chiffres

  • {n,} : Correspond à au moins n occurrences.

    /\d{2,}/  // Correspond à au moins 2 chiffres

  • {n,m} : Correspond à entre n et m occurrences.

    /\d{2,5}/  // Correspond à entre 2 et 5 chiffres

c) Les ancres et délimiteurs :

  • ^ : Correspond au début de la chaîne.

    /^a/  // Correspond à "a" au début de la chaîne

  • $ : Correspond à la fin de la chaîne.

    /a$/  // Correspond à "a" à la fin de la chaîne

  • | : Correspond à l'un ou l'autre des motifs (OU logique).

    /a|b/  // Correspond à "a" ou "b"

3. Classes de caractères et groupes

a) Classes de caractères :

Une classe de caractères permet de spécifier un ensemble de caractères parmi lesquels une correspondance peut être trouvée.

  • [abc] : Correspond à l'un des caractères dans la classe.

    /[aeiou]/  // Correspond à une voyelle

  • [^abc] : Correspond à tout sauf les caractères dans la classe.

    /[^0-9]/  // Correspond à tout sauf un chiffre

  • [a-z] : Correspond à une plage de caractères (ici, de "a" à "z").

    /[a-z]/  // Correspond à une lettre minuscule

b) Groupes :

  • (...) : Un groupe capture les correspondances en bloc.

    /(abc)/  // Correspond à "abc"

  • (?:...) : Groupe non capturant (utilisé pour regrouper sans capturer).

    /(?:abc)/  // Correspond à "abc", mais ne capture pas

4. Exemples concrets d'utilisation de regex

a) Vérifier un numéro de téléphone au format "123-456-7890" :

const regex = /^\d{3}-\d{3}-\d{4}$/;
console.log(regex.test("123-456-7890"));  // true
console.log(regex.test("1234567890"));    // false

b) Valider une adresse e-mail simple :

const regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
console.log(regex.test("test@example.com"));  // true
console.log(regex.test("test@example"));      // false

c) Remplacer des espaces multiples par un seul espace :

const text = "Hello   world!   How  are you?";
const result = text.replace(/\s+/g, ' ');
console.log(result);  // "Hello world! How are you?"

5. Conseils pour travailler avec les regex

  1. Commencez simple : Si vous êtes débutant, commencez par de petites expressions régulières, comme la recherche d'un caractère ou d'un nombre.
  2. Utilisez des outils en ligne : Des sites comme regex101.com ou regexr.com sont d'excellents outils pour tester et comprendre les expressions régulières.
  3. Utilisez les métacaractères à bon escient : Les métacaractères comme ^, $, et \b peuvent être puissants pour spécifier les débuts, les fins, ou les limites des mots.
  4. Évitez les regex trop complexes : Parfois, des solutions simples avec split(), slice() ou des boucles sont plus lisibles et efficaces qu'une regex complexe.

6. Exemple complet en JavaScript : valider un code PIN

Reprenons l'exemple du code PIN de votre exercice :

function validatePIN(pin) {
  // La regex vérifie si le pin est composé de 4 ou 6 chiffres
  return /^(\d{4}|\d{6})$/.test(pin);
}

console.log(validatePIN("1234"));    // true
console.log(validatePIN("12345"));   // false
console.log(validatePIN("a234"));    // false

J'espère que cette introduction aux regex vous aide à mieux comprendre leur fonctionnement ! Si vous avez besoin d'approfondir un aspect spécifique ou d'autres exemples, n'hésitez pas à me demander.