Go Academy · Leçon

Conseils de performance

Réutiliser les expressions régulières compilées

Leçon 4 sur 413 étapes

Conseils de performance est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

La compilation a un coût

Transformer une chaîne de motif en expression régulière utilisable demande du travail. Le faire à chaque appel fait perdre du temps, en particulier dans les boucles ou les chemins critiques.

package main

import (
    "fmt"
    "regexp"
)

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

Compiler une fois, réutiliser souvent

La règle d'or : compilez un motif une seule fois et réutilisez le *regexp.Regexp. Une variable au niveau du package est l'emplacement habituel.

package main

import (
    "fmt"
    "regexp"
)

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

func hasNumber(s string) bool {
    return numRe.MatchString(s)
}

func main() {
    fmt.Println(hasNumber("a1"))
    fmt.Println(hasNumber("abc"))
}

Éviter de compiler dans les boucles

N'appelez jamais MustCompile dans une boucle. Compilez avant la boucle et utilisez la même valeur à chaque itération.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[a-z]+")
    inputs := []string{"go", "123", "rust"}
    for _, s := range inputs {
        fmt.Println(s, re.MatchString(s))
    }
}

Une expression régulière peut être partagée en toute sécurité

Un *regexp.Regexp compilé peut être utilisé en toute sécurité de manière concurrente par plusieurs goroutines. Une seule instance globale peut toutes les servir.

package main

import (
    "fmt"
    "regexp"
)

var re = regexp.MustCompile("go")

func main() {
    fmt.Println(re.MatchString("golang"))
}

Parfois, strings est plus rapide

Pour une sous-chaîne littérale fixe, strings.Contains est plus rapide qu'une expression régulière. N'utilisez les expressions régulières que lorsque vous avez réellement besoin de leurs possibilités de traitement des motifs.

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Contains("hello world", "world"))
}

Privilégier les motifs ancrés

L'ancrage avec ^ permet au moteur d'échouer rapidement lorsque le début ne correspond pas, au lieu de parcourir toute la chaîne.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("^https?://")
    fmt.Println(re.MatchString("http://site"))
    fmt.Println(re.MatchString("see http://x"))
}

Limiter le nombre de correspondances

Lorsque vous n'avez besoin que de quelques correspondances, transmettez une petite valeur n aux méthodes de recherche de toutes les correspondances plutôt que -1, afin de vous arrêter plus tôt.

package main

import (
    "fmt"
    "regexp"
)

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

Attention aux motifs avec retour arrière

Le moteur RE2 de Go évite les retours arrière catastrophiques, mais des motifs trop larges comme .* peuvent tout de même parcourir plus de texte que nécessaire. Soyez précis.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    broad := regexp.MustCompile(".*=.*")
    precise := regexp.MustCompile("[a-z]+=[0-9]+")
    fmt.Println(broad.MatchString("x=1"), precise.MatchString("x=1"))
}

Échapper les données d'entrée dynamiques

Si un motif inclut du texte fourni par l'utilisateur, échappez-le avec regexp.QuoteMeta afin que les caractères spéciaux soient traités littéralement.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    user := "a.b"
    re := regexp.MustCompile(regexp.QuoteMeta(user))
    fmt.Println(re.MatchString("a.b"))
    fmt.Println(re.MatchString("axb"))
}

Mettre en cache les motifs compilés

Si les motifs sont construits à l'exécution, stockez ceux qui sont compilés dans une table associative dont la clé est la chaîne du motif, afin d'éviter de compiler à nouveau le même motif.

package main

import (
    "fmt"
    "regexp"
)

var cache = map[string]*regexp.Regexp{}

func get(p string) *regexp.Regexp {
    if re, ok := cache[p]; ok {
        return re
    }
    re := regexp.MustCompile(p)
    cache[p] = re
    return re
}

func main() {
    fmt.Println(get("[0-9]+").MatchString("7"))
}

Tout assembler

Un validateur bien optimisé compile une seule fois, ancre le motif et est partagé entre tous les appels.

package main

import (
    "fmt"
    "regexp"
)

var emailRe = regexp.MustCompile("^[a-z0-9]+@[a-z]+\\.[a-z]+$")

func main() {
    fmt.Println(emailRe.MatchString("me@site.com"))
}

Vérification rapide

Quel est le conseil de performance le plus important concernant les expressions régulières ?

Réponds-y dans la leçon interactive

Récapitulatif : conseils de performance

Vous avez appris à utiliser efficacement les expressions régulières :

Compilez une seule fois avec MustCompile et réutilisez le résultat ; son utilisation est sûre en contexte concurrent.
Privilégiez strings pour les sous-chaînes fixes, ancrez les motifs et limitez le nombre de correspondances.
Échappez les données d'entrée dynamiques avec QuoteMeta et mettez en cache les motifs construits à l'exécution.

package main

import (
    "fmt"
    "regexp"
)

var re = regexp.MustCompile("^\\d{4}$")

func main() {
    for _, s := range []string{"1234", "12"} {
        fmt.Println(s, re.MatchString(s))
    }
}

Gratuit pour commencer

Apprends Go avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 51
Leçons: 203

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Conseils de performance » est-elle gratuite ?

Oui — le texte complet de « Conseils de performance » 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 « Conseils de performance » ?

Réutiliser les expressions régulières compilées 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 4 sur 4.

Combien de temps prend la leçon « Conseils de performance » ?

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