Go Academy · Leçon

Recherche et extraction

Utiliser FindString et les sous-correspondances

Recherche et extraction est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Au-delà de la correspondance

La correspondance vous indique si un motif existe. La famille Find vous indique ce qui correspond et où, ce qui vous permet d'extraire des données.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.FindString("order 42 ready"))
}

FindString

FindString(s) renvoie la première correspondance sous forme de chaîne, ou une chaîne vide s'il n'y en a aucune.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[a-z]+")
    fmt.Printf("%q\n", re.FindString("123abc456"))
}

FindAllString

FindAllString(s, n) renvoie toutes les correspondances sous forme de tranche. Passez -1 pour obtenir toutes les correspondances, ou une limite positive.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.FindAllString("a1 b22 c333", -1))
}

Limiter les résultats

Passez une valeur positive à n pour arrêter la recherche après ce nombre de correspondances.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.FindAllString("1 2 3 4", 2))
}

Trouver l'index

FindStringIndex(s) renvoie les positions en octets du début et de la fin de la première correspondance sous forme de tranche à deux éléments.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("cat")
    fmt.Println(re.FindStringIndex("a cat here"))
}

Groupes de capture

Les parenthèses créent des groupes de capture. FindStringSubmatch renvoie d'abord la correspondance entière, puis chaque groupe capturé.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\d+)-(\\d+)")
    m := re.FindStringSubmatch("12-34")
    fmt.Println(m)
}

Utiliser les valeurs des sous-correspondances

Accédez aux éléments de la tranche de sous-correspondances par leur index : l'élément 0 est la correspondance complète, l'élément 1 est le premier groupe, et ainsi de suite.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\d+):(\\d+)")
    m := re.FindStringSubmatch("09:30")
    fmt.Println("hour", m[1], "min", m[2])
}

Groupes nommés

Nommez un groupe avec (?P<name>...), puis lisez-le avec SubexpNames en parallèle de la tranche de sous-correspondances.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(?P<area>\\d{3})-(?P<num>\\d{4})")
    m := re.FindStringSubmatch("555-1234")
    for i, name := range re.SubexpNames() {
        if name != "" {
            fmt.Println(name, m[i])
        }
    }
}

Toutes les sous-correspondances

FindAllStringSubmatch(s, n) renvoie une tranche de tranches de sous-correspondances, une par correspondance. C'est idéal pour analyser de nombreux enregistrements.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\w+)=(\\d+)")
    all := re.FindAllStringSubmatch("x=1 y=2", -1)
    for _, m := range all {
        fmt.Println(m[1], m[2])
    }
}

Comportement en l'absence de correspondance

Lorsqu'aucun élément ne correspond, les méthodes Find renvoient une chaîne vide ou une tranche nil. Vérifiez le résultat avant d'utiliser un index afin d'éviter une panique.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    m := re.FindStringSubmatch("no digits")
    fmt.Println(m == nil)
}

Extraire des données réelles

Combinez les groupes pour extraire des champs structurés d'une ligne de texte.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\d{4})-(\\d{2})-(\\d{2})")
    m := re.FindStringSubmatch("date: 2026-05-30")
    fmt.Println("year", m[1])
}

Vérification rapide

Quel élément d'une tranche de sous-correspondances contient la correspondance entière ?

Récapitulatif : trouver et extraire

Vous pouvez maintenant extraire des données du texte :

FindString et FindAllString renvoient les correspondances.
FindStringSubmatch renvoie la correspondance complète ainsi que les groupes de capture.
Utilisez des groupes nommés et vérifiez la valeur nil lorsqu'aucune correspondance n'est trouvée.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\w+)@(\\w+)")
    m := re.FindStringSubmatch("user@host")
    fmt.Println(m[1], "at", m[2])
}

Questions Fréquemment Posées

La leçon « Recherche et extraction » est-elle gratuite ?

Oui — le texte complet de « Recherche et extraction » 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 « Recherche et extraction » ?

Utiliser FindString et les sous-correspondances 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 2 sur 4.

Combien de temps prend la leçon « Recherche et extraction » ?

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