0Pricing
Go Academy · Lezione

Consigli sulle prestazioni

Riutilizzare le regexp compilate

Consigli sulle prestazioni è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

La compilazione ha un costo

Trasformare una stringa che rappresenta un pattern in una regexp utilizzabile richiede lavoro. Farlo a ogni chiamata fa perdere tempo, soprattutto nei cicli o nei percorsi più eseguiti.

package main

import (
    "fmt"
    "regexp"
)

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

Compilare una volta, riutilizzare spesso

La regola d'oro è compilare un pattern una sola volta e riutilizzare la *regexp.Regexp. Una variabile a livello di package è la collocazione abituale.

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"))
}

Evitare la compilazione nei cicli

Non chiami mai MustCompile all'interno di un ciclo. Compili prima del ciclo e utilizzi lo stesso valore a ogni iterazione.

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))
    }
}

Regexp sicura da condividere

Una *regexp.Regexp compilata è sicura per l'uso concorrente da parte di più goroutine. Una singola istanza globale può servire tutte le goroutine.

package main

import (
    "fmt"
    "regexp"
)

var re = regexp.MustCompile("go")

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

A volte strings è più veloce

Per una sottostringa letterale fissa, strings.Contains è più veloce di una regexp. Utilizzi le regexp solo quando ha davvero bisogno della potenza dei pattern.

package main

import (
    "fmt"
    "strings"
)

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

Preferire i pattern ancorati

L'ancoraggio con ^ consente al motore di terminare rapidamente quando l'inizio non corrisponde, invece di analizzare l'intera stringa.

package main

import (
    "fmt"
    "regexp"
)

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

Limitare il numero di corrispondenze

Quando ha bisogno solo di poche corrispondenze, passi un valore n basso ai metodi Find-all invece di -1, così la ricerca si interrompe prima.

package main

import (
    "fmt"
    "regexp"
)

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

Attenzione ai pattern con backtracking

Il motore RE2 di Go evita il backtracking catastrofico, ma pattern troppo generici come .* possono comunque analizzare più testo del necessario. Sia specifico.

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"))
}

Eseguire l'escape degli input dinamici

Se un pattern include testo fornito dall'utente, ne esegua l'escape con regexp.QuoteMeta, così i caratteri speciali vengono trattati letteralmente.

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"))
}

Memorizzare nella cache i pattern compilati

Se i pattern vengono costruiti durante l'esecuzione, memorizzi quelli compilati in una map indicizzata dalla stringa del pattern, così evita di compilare di nuovo lo stesso pattern.

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"))
}

Mettere tutto insieme

Un validatore ben ottimizzato compila una sola volta, ancora il pattern e viene condiviso da tutte le chiamate.

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"))
}

Verifica rapida

Qual è il suggerimento più importante per le prestazioni delle regexp?

Riepilogo: suggerimenti sulle prestazioni

Ha imparato a utilizzare le regexp in modo efficiente:

  • Compili una sola volta con MustCompile e riutilizzi il risultato: è sicuro per l'uso concorrente.
  • Preferisca strings per le sottostringhe fisse; ancori i pattern e limiti il numero di corrispondenze.
  • Esegua l'escape degli input dinamici con QuoteMeta e memorizzi nella cache i pattern creati durante l'esecuzione.
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))
    }
}

Domande Frequenti

La lezione «Consigli sulle prestazioni» è gratuita?

Sì — il testo completo di «Consigli sulle prestazioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Consigli sulle prestazioni»?

Riutilizzare le regexp compilate Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Consigli sulle prestazioni»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Nozioni di base su regexp
  2. Ricerca ed estrazione
  3. Sostituire il testo
  4. Consigli sulle prestazioni
← Torna a Go Academy