Apprenez les expressions régulières avec ce cours gratuit

«Certaines personnes, confrontées à un problème, pensent" Je sais, j'utiliserai des expressions régulières ". Maintenant, ils ont deux problèmes." -Jamie Zawinski

Pour certaines personnes, l'utilisation d'expressions régulières peut être un problème. Mais cela ne doit pas être un problème pour vous. Cet article est un cours complet sur les expressions régulières.

1. Introduction

Les expressions régulières, ou simplement RegEx, sont utilisées dans presque tous les langages de programmation pour définir un modèle de recherche qui peut être utilisé pour rechercher des éléments dans une chaîne.

J'ai développé un cours vidéo complet gratuit sur Scrimba.com pour enseigner les bases des expressions régulières.

Cet article contient le cours sous forme écrite. Mais si vous préférez regarder la version vidéo avec des leçons interactives, vous pouvez la consulter sur Scrimba. Les sections de cet article correspondent aux sections du cours Scimba.

Ce cours suit le programme RegEx sur freeCodeCamp.org. Vous pouvez vérifier cela pour les défis de codage et pour gagner un certificat.

Ces leçons se concentrent sur l'utilisation de RegEx en JavaScript, mais les principes s'appliquent dans de nombreux autres langages de programmation que vous pouvez choisir d'utiliser. Si vous ne connaissez pas déjà le JavaScript de base, il pourrait être utile de le couvrir un peu d'abord. J'ai aussi un cours de base sur JavaScript auquel vous pouvez accéder sur Scrimba et sur la chaîne YouTube freeCodeCamp.org.

Alors, commençons! Vous sauverez la situation en un rien de temps. ?

2. Utilisation de la méthode de test

Pour faire correspondre des parties de chaînes à l'aide de RegEx, nous devons créer des modèles qui vous aident à faire cette correspondance. Nous pouvons indiquer que quelque chose est un modèle RegEx en mettant le modèle entre des barres obliques /, comme ça /pattern-we-want-to-match/.

Regardons un exemple:

// We want to check the following sentencelet sentence = "The dog chased the cat."
// and this is the pattern we want to match.let regex = /the/

Remarquez comment nous utilisons /the/pour indiquer que nous recherchons «le» dans notre sentence.

Nous pouvons utiliser la test()méthode RegEx pour dire si un modèle est présent dans une chaîne ou non.

// String we want to testlet myString = "Hello, World!";
// Pattern we want to findlet myRegex = /Hello/;
// result is now truelet result = myRegex.test(myString);

3. Faire correspondre les chaînes littérales

Trouvons maintenant Waldo.

let waldoIsHiding = "Somewhere Waldo is hiding in this text.";let waldoRegex = /Waldo/;
// test() returns true, so result is now also truelet result = waldoRegex.test(waldoIsHiding);

Notez que dans cet exemple waldoRegexest sensible à la casse, donc si nous devions écrire /waldo/avec un 'w' minuscule, alors notre resultserait faux.

4. Faire correspondre une chaîne littérale avec différentes possibilités

RegEx a également un ORopérateur qui est un |caractère.

let petString = "James has a pet cat.";
// We can now try to find if either of the words are in the sentencelet petRegex = /dog|cat|bird|fish/;
let result = petRegex.test(petString);

5. Ignorer la casse lors de la correspondance

Jusqu'à présent, nous avons examiné les modèles lorsque la casse des lettres importait. Comment pouvons-nous rendre nos modèles RegEx insensibles à la casse?

Pour ignorer la casse, nous pouvons le faire en ajoutant le idrapeau à la fin d'un motif, comme ceci /some-pattern/i.

let myString = "freeCodeCamp";
// We ignore case by using 'i' flaglet fccRegex = /freecodecamp/i;
// result is truelet result = fccRegex.test(myString);

6. Extraire les correspondances

Lorsque nous voulons extraire la valeur correspondante, nous pouvons utiliser match()method.

let extractStr = "Extract the word 'coding' from this string.";
let codingRegex = /coding/;
let result = extractStr.match(codingRegex);
console.log(result);
// Terminal will show: // > ["coding"]

7. Trouvez plus que le premier match

Maintenant, quand nous savons comment extraire une valeur et qu'il est également possible d'extraire plusieurs valeurs à l'aide du gdrapeau

let testStr = "Repeat, Repeat, Repeat";
let ourRegex = /Repeat/g;
testStr.match(ourRegex); // returns ["Repeat", "Repeat", "Repeat"]

Nous pouvons également combiner le gdrapeau avec le idrapeau, pour extraire plusieurs correspondances et ignorer la casse.

let twinkleStar = "Twinkle, twinkle, little star";
let starRegex = /twinkle/ig;// writing /twinkle/gi would have the same result.
let result = twinkleStar.match(starRegex);
console.log(result);
// Terminal will show: // > ["Twinkle", "twinkle"]

8. Match Anything avec Wildcard Period

Dans RegEx .est un caractère générique qui correspond à n'importe quoi.

let humStr = "I'll hum a song";
let hugStr = "Bear hug";
// Looks for anything with 3 characters beginning with 'hu'let huRegex = /hu./;
humStr.match(huRegex); // Returns ["hum"]
hugStr.match(huRegex); // Returns ["hug"]

9. Associez un seul caractère avec plusieurs possibilités

Faire correspondre n'importe quel caractère est bien, mais que se passe-t-il si nous voulons restreindre la correspondance à un jeu de caractères prédéfini? Nous pouvons le faire en utilisant []dans notre RegEx.

Si c'est le cas /b[aiu]g/, cela signifie que nous pouvons faire correspondre «sac», «gros» et «bug».

Si nous voulons extraire toutes les voyelles d'une phrase, voici comment nous pouvons le faire en utilisant RegEx.

let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
let vowelRegex = /[aeiou]/ig;
let result = quoteSample.match(vowelRegex);

10. Faire correspondre les lettres de l'alphabet

Mais que faire si nous voulons faire correspondre une plage de lettres? Bien sûr, faisons ça.

let quoteSample = "The quick brown fox jumps over the lazy dog.";
// We can match all the letters from 'a' to 'z', ignoring casing. let alphabetRegex = /[a-z]/ig;
let result = quoteSample.match(alphabetRegex);

11. Faire correspondre les nombres et les lettres de l'alphabet

Les lettres sont bonnes, mais que faire si nous voulons aussi des chiffres?

let quoteSample = "Blueberry 3.141592653s are delicious.";
// match numbers between 2 and 6 (both inclusive), // and letters between 'h' and 's'. let myRegex = /[2-6h-s]/ig;
let result = quoteSample.match(myRegex);

12. Faire correspondre des caractères uniques non spécifiés

Parfois, il est plus facile de spécifier des personnages que vous ne souhaitez pas regarder. Ceux-ci sont appelés «caractères niés» et dans RegEx vous pouvez le faire en utilisant ^.

let quoteSample = "3 blind mice.";
// Match everything that is not a number or a vowel. let myRegex = /[^0-9aeiou]/ig;
let result = quoteSample.match(myRegex);// Returns [" ", "b", "l", "n", "d", " ", "m", "c", "."]

13. Faire correspondre les caractères qui apparaissent une ou plusieurs fois

Si vous souhaitez faire correspondre un caractère qui apparaît une ou plusieurs fois, vous pouvez utiliser +.

let difficultSpelling = "Mississippi";
let myRegex = /s+/g;
let result = difficultSpelling.match(myRegex);// Returns ["ss", "ss"]

14. Faire correspondre les caractères qui se produisent zéro fois ou plus

Il existe également un *quantificateur RegEx. Celui-ci correspond même à 0 occurrence d'un caractère. Pourquoi cela pourrait-il être utile? La plupart du temps, il est généralement associé à d'autres personnages. Regardons un exemple.

let soccerWord = "gooooooooal!";
let gPhrase = "gut feeling";
let oPhrase = "over the moon";
// We are trying to match 'g', 'go', 'goo', 'gooo' and so on. let goRegex = /go*/;
soccerWord.match(goRegex); // Returns ["goooooooo"]
gPhrase.match(goRegex); // Returns ["g"]
oPhrase.match(goRegex); // Returns null

15. Rechercher des personnages avec une correspondance paresseuse

Parfois, vos correspondances de modèles peuvent avoir plus d'un résultat. Par exemple, disons que je recherche un modèle dans un mot titanicet que mes valeurs correspondantes doivent commencer par un «t» et se terminer par un «i». Mes résultats possibles sont «titani» et «ti».

C'est pourquoi RegEx a un concept de «Greedy Match» et «Lazy Match».

La correspondance gourmande trouve la plus longue correspondance possible de la chaîne qui correspond au modèle RegEx, il s'agit d'une correspondance RegEx par défaut:

let string = "titanic";
let regex = /t[a-z]*i/;
string.match(regex);// Returns ["titani"]

Lazy match trouve la correspondance la plus courte possible de la chaîne qui correspond au modèle RegEx et pour l'utiliser, nous devons utiliser ?:

let string = "titanic";
let regex = /t[a-z]*?i/;
string.match(regex);// Returns ["ti"]

16. Trouver un ou plusieurs criminels dans une chasse

Jetons maintenant un coup d'œil à un défi RegEx. Nous devons trouver tous les criminels («C») dans une foule. Nous savons qu'ils restent toujours ensemble et que vous devez rédiger un RegEx qui les trouvera.

let crowd = 'P1P2P3P4P5P6CCCP7P8P9';
let reCriminals = /./; // Change this line
let matchedCriminals = crowd.match(reCriminals);

Vous pouvez me trouver en train de parcourir la solution dans ce casting de Scrimba.

17. Faire correspondre les modèles de chaîne de début

RegEx vous permet également de faire correspondre des modèles qui ne sont qu'au début d'une chaîne. Nous avons déjà parlé de la ^création d'un ensemble de négation. Nous pouvons utiliser le même symbole pour trouver une correspondance uniquement au début d'une chaîne.

let calAndRicky = "Cal and Ricky both like racing.";
// Match 'Cal' only if it's at the beginning of a string. let calRegex = /^Cal/;
let result = calRegex.test(calAndRicky); // Returns true
let rickyAndCal = "Ricky and Cal both like racing.";
let result = calRegex.test(rickyAndCal); // Returns false

18. Correspondance des modèles de chaîne de fin

Qu'en est-il de la correspondance d'un motif à la fin d'une chaîne? Nous pouvons utiliser $pour cela.

let caboose = "The last car on a train is the caboose";
// Match 'caboose' if it's at the end of a string.let lastRegex = /caboose$/;
let result = lastRegex.test(caboose); // Returns true

19. Faire correspondre toutes les lettres et tous les nombres

Plus tôt dans les parties 10 et 11, je vous ai montré comment nous pouvons faire correspondre des plages de lettres et de chiffres. Si je vous ai demandé d'écrire un RegEx qui correspond à toutes les lettres et chiffres et d'ignorer leurs cas, vous auriez probablement écrit quelque chose comme /[a-z0-9]/giet c'est exactement ça. Mais c'est un peu trop long.

RegEx a quelque chose appelé «Classes de caractères abrégés» , qui est essentiellement un raccourci pour l'expression RegEx commune. Pour faire correspondre toutes les lettres et tous les chiffres que nous pouvons utiliser \wet nous obtenons également un trait de soulignement _en bonus.

let quoteSample = "The five boxing wizards jump quickly.";
// Same as /[a-z0-9_]/gi to match a-z (ignore case), 0-9 and _let alphabetRegexV2 = /\w/g;
// The length of all the characters in a string// excluding spaces and the period. let result = quoteSample.match(alphabetRegexV2).length;
// Returns 31

20. Faites correspondre tout sauf les lettres et les chiffres

Si nous voulons faire le contraire et faire correspondre tout ce qui n'est pas une lettre ou un nombre (exclure également le trait de soulignement _), nous pouvons utiliser\W

let quoteSample = "The five boxing wizards jump quickly.";
// Match spaces and the periodlet nonAlphabetRegex = /\W/g;
let result = quoteSample.match(nonAlphabetRegex).length;
// Returns 6

21. Faire correspondre tous les nombres

Ok, et si vous ne voulez que des chiffres? Existe-t-il une classe de caractères abrégés pour cela? Bien sûr, c'est \d.

let numString = "Your sandwich will be $5.00";
// Match all the numberslet numRegex = /\d/g;
let result = numString.match(numRegex).length; // Returns 3

22. Faire correspondre tous les non-nombres

Aimeriez-vous le contraire et faire correspondre tous les non-nombres? Utilisation\D

let numString = "Your sandwich will be $5.00";
// Match everything that is not a numberlet noNumRegex = /\D/g;
let result = numString.match(noNumRegex).length; // Returns 24

23. Restreindre les noms d'utilisateurs possibles

Jusqu'ici tout va bien! Bravo pour être arrivé aussi loin. RegEx peut être délicat car ce n'est pas le moyen le plus lisible de coder. Regardons maintenant un exemple très réel et créons un validateur de nom d'utilisateur. Dans ce cas, vous avez 3 exigences:

  • S'il y a des nombres, ils doivent être à la fin.
  • Les lettres peuvent être minuscules et majuscules.
  • Au moins deux caractères. Les noms à deux lettres ne peuvent pas avoir de chiffres.

Essayez de résoudre ce problème par vous-même et si vous trouvez cela difficile ou si vous souhaitez simplement vérifier la réponse, consultez ma solution.

24. Faire correspondre les espaces

Pouvons-nous faire correspondre tous les espaces? Bien sûr, nous pouvons également utiliser un raccourci pour cela et c'est\s

let sample = "Whitespace is important in separating words";
// Match all the whitespaceslet countWhiteSpace = /\s/g;
let result = sample.match(countWhiteSpace);
// Returns [" ", " ", " ", " ", " "]

25. Faire correspondre les caractères non blancs

Pouvez-vous deviner comment faire correspondre tous les caractères non blancs? Bravo, c'est \S!

let sample = "Whitespace is important in separating words";
// Match all non-whitespace characterslet countWhiteSpace = /\S/g;
let result = sample.match(countWhiteSpace);

26. Spécifiez le nombre de correspondances supérieur et inférieur

Vous pouvez spécifier le nombre inférieur et supérieur de correspondances de modèle avec «Spécificateurs de quantité». Ils peuvent être utilisés avec la {}syntaxe, par exemple {3,6}, où 3est la limite inférieure et 6est la limite supérieure à mettre en correspondance.

let ohStr = "Ohhh no";
// We want to match 'Oh's that have 3-6 'h' characters in it. let ohRegex = /Oh{3,6} no/;
let result = ohRegex.test(ohStr); // Returns true

27. Spécifiez uniquement le nombre inférieur de correspondances

Lorsque nous voulons spécifier uniquement la borne inférieure, nous pouvons le faire en omettant la borne supérieure, par exemple pour faire correspondre au moins trois caractères que nous pouvons écrire {3,}. Notez que nous avons toujours besoin d'une virgule, même si nous ne spécifions pas la limite supérieure.

let haStr = "Hazzzzah";
// Match a pattern that contains at least for 'z' characterslet haRegex = /z{4,}/;
let result = haRegex.test(haStr); // Returns true

28. Spécifiez le nombre exact de correspondances

Dans la section précédente, j'ai mentionné que nous avons besoin d'une virgule {3,}lorsque nous spécifions uniquement la limite inférieure. La raison en est que lorsque vous écrivez {3}sans virgule, cela signifie que vous cherchez à faire correspondre exactement 3 caractères.

let timStr = "Timmmmber";
// let timRegex = /Tim{4}ber/;
let result = timRegex.test(timStr); // Returns true

29. Vérifier tout ou aucun

Il y a des moments où vous voudrez peut-être spécifier une existence possible d'un caractère dans votre modèle. Quand une lettre ou un nombre est facultatif et que nous utiliserions ?pour cela.

// We want to match both British and American English spellings // of the word 'favourite'
let favWord_US = "favorite";let favWord_GB = "favourite";
// We match both 'favorite' and 'favourite' // by specifying that 'u' character is optionallet favRegex = /favou?rite/; // Change this line
let result1 = favRegex.test(favWord_US); // Returns truelet result2 = favRegex.test(favWord_GB); // Returns true

30. Anticipation positive et négative

Les « Lookaheads » sont des modèles qui indiquent à votre JS de regarder en avant pour vérifier les modèles plus loin. Ils sont utiles lorsque vous essayez de rechercher plusieurs modèles dans les mêmes chaînes. Il existe 2 types de lookaheads - positifs et négatifs.

La recherche positive utilise la ?=syntaxe

let quit = "qu";
// We match 'q' only if it has 'u' after it. let quRegex= /q(?=u)/;
quit.match(quRegex); // Returns ["q"]

La recherche négative utilise la ?!syntaxe

let noquit = "qt";
// We match 'q' only if there is no 'u' after it. let qRegex = /q(?!u)/;
noquit.match(qRegex); // Returns ["q"]

31. Réutiliser des modèles à l'aide de groupes de capture

Imaginons que nous devions capturer un motif répétitif.

let repeatStr = "regex regex";
// We want to match letters followed by space and then letterslet repeatRegex = /(\w+)\s(\w+)/;
repeatRegex.test(repeatStr); // Returns true

Au lieu de répéter (\w+)à la fin, nous pouvons dire à RegEx de répéter le modèle en utilisant \1. Donc, la même chose que ci-dessus peut être écrite à nouveau comme:

let repeatStr = "regex regex";
let repeatRegex = /(\w+)\s\1)/;
repeatRegex.test(repeatStr); // Returns true

32. Utiliser des groupes de capture pour rechercher et remplacer

Lorsque nous trouvons une correspondance, il est parfois pratique de la remplacer par autre chose. Nous pouvons utiliser la replace()méthode pour cela.

let wrongText = "The sky is silver.";
let silverRegex = /silver/;
wrongText.replace(silverRegex, "blue");
// Returns "The sky is blue."

33. Supprimer les espaces du début et de la fin

Voici un petit défi pour vous. Écrivez un RegEx qui supprimerait tout espace autour de la chaîne.

let hello = " Hello, World! ";
let wsRegex = /change/; // Change this line
let result = hello; // Change this line

Si vous êtes bloqué ou si vous souhaitez simplement vérifier ma solution, n'hésitez pas à jeter un œil à la distribution Scrimba où je résous ce défi.

34. Conclusion

Toutes nos félicitations! Vous avez terminé ce cours! Si vous souhaitez continuer à en apprendre davantage, n'hésitez pas à consulter cette liste de lecture YouTube, qui contient de nombreux projets JavaScript que vous pouvez créer.

Continuez à apprendre et merci d'avoir lu!

Vous êtes maintenant prêt à jouer au golf regex. ?