Go Academy · Leçon

Les bases de regexp

Compiler et faire correspondre des motifs

Les bases de regexp est une leçon Go 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 Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

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

Une expression régulière (regexp) est un motif qui décrit un ensemble de chaînes. Go les fournit par l'intermédiaire du paquet regexp.

Elles sont idéales pour valider et rechercher du texte.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    matched, _ := regexp.MatchString("go+", "gooo")
    fmt.Println(matched)
}

Faire une correspondance rapide avec MatchString

regexp.MatchString(pattern, s) indique si le motif apparaît quelque part dans s. La fonction renvoie une valeur booléenne et une erreur.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    ok, _ := regexp.MatchString("cat", "the cat sat")
    fmt.Println(ok)
}

Compiler un motif

Pour une utilisation répétée, compilez le motif une seule fois avec regexp.Compile. Cette fonction renvoie un *regexp.Regexp réutilisable et une erreur si le motif n'est pas valide.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re, err := regexp.Compile("[0-9]+")
    fmt.Println(re.MatchString("abc123"), err)
}

MustCompile pour les constantes

regexp.MustCompile déclenche une panique si le motif n'est pas valide. Utilisez-le pour les motifs fixes connus au moment de la compilation, généralement dans des variables au niveau du paquet.

package main

import (
    "fmt"
    "regexp"
)

var digits = regexp.MustCompile("[0-9]+")

func main() {
    fmt.Println(digits.MatchString("order 42"))
}

Classes de caractères

Les crochets définissent un ensemble de caractères autorisés. [aeiou] correspond à n'importe quelle voyelle ; des intervalles comme [a-z] correspondent à une plage.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[a-z]+")
    fmt.Println(re.MatchString("Hello"))
}

Classes prédéfinies

Des raccourcis facilitent la définition des ensembles courants : \d représente un chiffre, \w un caractère alphanumérique, et \s un espace blanc. Dans les chaînes Go, échappez la barre oblique inverse.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("\\d+")
    fmt.Println(re.MatchString("abc 99"))
}

Quantificateurs

Les quantificateurs indiquent combien de fois un élément apparaît :

* : zéro fois ou plus ;
+ : une fois ou plus ;
? : zéro ou une fois ;
{2,4} : un intervalle.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("a{2,3}")
    fmt.Println(re.MatchString("aaa"))
    fmt.Println(re.MatchString("a"))
}

Ancres

Les ancres fixent une correspondance : ^ représente le début du texte et $ la fin. Utilisez-les toutes les deux pour exiger une correspondance avec la chaîne entière.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("^go$")
    fmt.Println(re.MatchString("go"))
    fmt.Println(re.MatchString("going"))
}

Alternance et groupes

La barre verticale | signifie OR, et les parenthèses regroupent des éléments. (cat|dog)s? correspond à cat, cats, dog ou dogs.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(cat|dog)s?")
    fmt.Println(re.MatchString("dogs"))
}

Valider un format

Les motifs ancrés permettent de créer des validateurs. Ici, nous vérifions un code de type ZIP composé uniquement de cinq chiffres exactement.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("^\\d{5}$")
    fmt.Println(re.MatchString("12345"))
    fmt.Println(re.MatchString("123"))
}

Faire une correspondance sur des octets

Les méthodes existent sous forme de chaînes et de tranches d'octets. Match fonctionne sur un []byte, comme MatchString.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.Match([]byte("id7")))
}

Vérification rapide

Quelle fonction déclenche une panique avec un motif non valide et convient le mieux aux motifs fixes ?

Récapitulatif : notions de base sur regexp

Vous avez appris les notions fondamentales :

Effectuez rapidement une correspondance avec MatchString ; compilez avec Compile ou MustCompile.
Construisez des motifs à partir de classes, de quantificateurs, d'ancres et de groupes.
Utilisez ^ et $ comme ancres pour valider une chaîne entière.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("^[a-z]+@[a-z]+$")
    fmt.Println(re.MatchString("hi@host"))
}

Questions Fréquemment Posées

La leçon « Les bases de regexp » est-elle gratuite ?

Oui — le texte complet de « Les bases de regexp » 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 Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Les bases de regexp » ?

Compiler et faire correspondre des motifs Tu pratiques Go 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 Go Academy ?

Aucune expérience préalable n'est requise. Go 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 « Les bases de regexp » ?

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 Go Academy ?

Oui. Chaque leçon Go 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

← Retour à Go Academy