0Pricing
Ruby Academy · Leçon

Littéraux d’expressions régulières

Bases des motifs

Littéraux d’expressions régulières est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Ruby Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Ruby Academy comprend 4 leçons au total.

Qu’est-ce qu’une expression régulière ?

Une expression régulière est un motif utilisé pour rechercher du texte. En Ruby, une expression régulière est un objet de première classe de la classe Regexp.

Vous utilisez les expressions régulières pour rechercher, valider et extraire des parties de chaînes.

  • Rechercher un mot, un chiffre ou un symbole
  • Valider des adresses e-mail et des numéros de téléphone
  • Extraire des éléments d’un texte désordonné
pattern = /hello/
puts pattern.class
puts(pattern.match?('hello world'))

Littéraux d’expressions régulières avec des barres obliques

La manière la plus courante d’écrire une expression régulière en Ruby consiste à la placer entre deux barres obliques : /pattern/.

On appelle cela un littéral d’expression régulière. Tout ce qui se trouve entre les barres obliques constitue le motif.

ruby = /ruby/
puts ruby.class
puts(ruby.match?('I love ruby'))
puts(ruby.match?('I love python'))

L’opérateur de correspondance =~

L’opérateur =~ vérifie une chaîne par rapport à une expression régulière. Il renvoie l’indice de la première correspondance, ou nil si aucune correspondance n’est trouvée.

puts('hello world' =~ /world/)
puts(('hello world' =~ /xyz/).inspect)

match? pour obtenir une réponse booléenne

Lorsque vous avez seulement besoin d’une réponse oui/non, utilisez match?. Il renvoie true ou false et est plus rapide, car il ne crée pas d’objet MatchData.

puts(/\d/.match?('abc123'))
puts(/\d/.match?('abcdef'))

Classes de caractères

Une classe de caractères entre crochets correspond à un caractère quelconque parmi un ensemble donné.

  • [abc] correspond à a, b ou c
  • [a-z] correspond à n’importe quelle lettre minuscule
  • [0-9] correspond à n’importe quel chiffre
puts(/[aeiou]/.match?('sky'))
puts(/[aeiou]/.match?('tree'))
puts(/[0-9]/.match?('room 7'))

Classes abrégées

Ruby fournit des séquences d’échappement abrégées pour les classes de caractères courantes :

  • \d un chiffre, \D un caractère qui n’est pas un chiffre
  • \w un caractère de mot (lettre, chiffre ou caractère de soulignement)
  • \s un espace blanc, \S un caractère qui n’est pas un espace blanc
puts(/\d\d/.match?('age 42'))
puts(/\w+/.match?('hello_99'))
puts(/\s/.match?('no_space'))

Le point et les quantificateurs

Le point . correspond à un seul caractère quelconque (sauf un saut de ligne). Les quantificateurs contrôlent la répétition :

  • * zéro fois ou plus
  • + une fois ou plus
  • ? zéro ou une fois
  • {2,4} entre 2 et 4 fois
puts(/ab+c/.match?('abbbc'))
puts(/colou?r/.match?('color'))
puts(/\d{3}/.match?('id 451'))

Alternance avec la barre verticale

La barre verticale | signifie OR. Le motif cat|dog correspond à l’un ou l’autre mot.

Utilisez des parenthèses pour regrouper une alternance au sein d’un motif plus vaste.

pet = /cat|dog/
puts(pet.match?('I have a dog'))
puts(pet.match?('I have a fish'))
puts(/^(yes|no)$/.match?('yes'))

Indicateur insensible à la casse

Ajoutez l’indicateur i après la barre oblique fermante pour rendre la correspondance insensible à la casse.

D’autres indicateurs utiles sont notamment m (le point correspond à un saut de ligne) et x (mode étendu, qui ignore les espaces).

puts(/ruby/i.match?('I love RUBY'))
puts(/ruby/.match?('I love RUBY'))

Construire une expression régulière à partir de chaînes

Vous pouvez construire une expression régulière à l’exécution avec Regexp.new. Utilisez Regexp.escape pour inclure sans risque une entrée utilisateur susceptible de contenir des caractères spéciaux.

word = 'price'
pattern = Regexp.new(word)
puts(pattern.match?('the price is high'))
puts(Regexp.escape('a.b*c'))

Aperçu des ancres

Les ancres correspondent à des positions, et non à des caractères :

  • ^ début d’une ligne
  • $ fin d’une ligne
  • \A début de la chaîne
  • \z fin de la chaîne

Vous étudierez ces éléments plus en détail ultérieurement.

puts(/^Hello/.match?('Hello there'))
puts(/world$/.match?('hello world'))

Vérification rapide

Que renvoie l’opérateur =~ lorsqu’une expression régulière correspond à une chaîne ?

Récapitulatif : littéraux d’expressions régulières

Vous avez appris les bases des expressions régulières en Ruby :

  • Les littéraux d’expressions régulières s’écrivent entre /slashes/
  • =~ renvoie un indice, tandis que match? renvoie true/false
  • Les classes de caractères [ ] et les formes abrégées \d \w \s
  • Les quantificateurs * + ? {n,m} et l’alternance |
  • L’indicateur i rend la correspondance insensible à la casse

Vous allez maintenant capturer les éléments correspondants.

puts(/\w+@\w+\.\w+/i.match?('USER@Mail.com'))

Questions Fréquemment Posées

La leçon « Littéraux d’expressions régulières » est-elle gratuite ?

Oui — le texte complet de « Littéraux d’expressions régulières » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Ruby Academy, passe à CoddyKit PRO. Le cours Ruby Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Littéraux d’expressions régulières » ?

Bases des motifs Tu pratiques Ruby Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Ruby Academy ?

Aucune expérience préalable n'est requise. Ruby Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Littéraux d’expressions régulières » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Ruby Academy ?

Oui. Chaque leçon Ruby Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Littéraux d’expressions régulières
  2. Correspondance et capture
  3. Substitution
  4. Groupes nommés et ancres
← Retour à Ruby Academy