Espressioni Regolari in Go

Il pacchetto regexp di Go implementa le espressioni regolari con la sintassi RE2, garantendo tempi di esecuzione lineari rispetto alla dimensione dell’input.

Compilare un Pattern

import "regexp"

// Compile restituisce un errore se il pattern non è valido
re, err := regexp.Compile(`\d+`)
if err != nil {
    log.Fatal(err)
}

// MustCompile causa un panic se il pattern non è valido
// Usalo per pattern costanti noti a compile-time
re := regexp.MustCompile(`\d+`)

Verificare una Corrispondenza

re := regexp.MustCompile(`^[a-zA-Z]+$`)

fmt.Println(re.MatchString("Ciao"))    // true
fmt.Println(re.MatchString("Ciao123")) // false
fmt.Println(re.MatchString(""))        // false

Trovare Corrispondenze

re := regexp.MustCompile(`\d+`)

// Trova la prima corrispondenza
fmt.Println(re.FindString("Ho 25 anni e 3 gatti")) // "25"

// Trova tutte le corrispondenze
risultati := re.FindAllString("Ho 25 anni e 3 gatti", -1)
fmt.Println(risultati) // ["25", "3"]

// Limita il numero di risultati
risultati = re.FindAllString("1 2 3 4 5", 3)
fmt.Println(risultati) // ["1", "2", "3"]

Gruppi di Cattura

re := regexp.MustCompile(`(\w+)@(\w+)\.(\w+)`)
match := re.FindStringSubmatch("email: utente@dominio.com")

if match != nil {
    fmt.Println("Intero:", match[0])   // utente@dominio.com
    fmt.Println("Utente:", match[1])   // utente
    fmt.Println("Dominio:", match[2])  // dominio
    fmt.Println("TLD:", match[3])      // com
}

Gruppi di Cattura con Nome

re := regexp.MustCompile(`(?P<anno>\d{4})-(?P<mese>\d{2})-(?P<giorno>\d{2})`)
match := re.FindStringSubmatch("2026-02-06")
nomi := re.SubexpNames()

for i, nome := range nomi {
    if i != 0 && nome != "" {
        fmt.Printf("%s: %s\n", nome, match[i])
    }
}
// anno: 2026
// mese: 02
// giorno: 06

Sostituzione

re := regexp.MustCompile(`\d+`)

// Sostituisci tutte le occorrenze
risultato := re.ReplaceAllString("Ho 25 anni e 3 gatti", "X")
fmt.Println(risultato) // "Ho X anni e X gatti"

// Sostituzione con funzione
risultato = re.ReplaceAllStringFunc("1 più 2 fa 3", func(s string) string {
    n, _ := strconv.Atoi(s)
    return strconv.Itoa(n * 10)
})
fmt.Println(risultato) // "10 più 20 fa 30"

Dividere una Stringa

re := regexp.MustCompile(`[,;\s]+`)
parti := re.Split("uno, due; tre  quattro", -1)
fmt.Println(parti) // ["uno", "due", "tre", "quattro"]

Pattern Comuni

emailRe := regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
telefonoRe := regexp.MustCompile(`^\+?\d{10,13}$`)
urlRe := regexp.MustCompile(`https?://[^\s]+`)

Conclusione

Il pacchetto regexp di Go offre un’implementazione sicura e performante delle espressioni regolari. Usa MustCompile per pattern costanti e Compile quando il pattern viene dall’utente. La sintassi RE2 non supporta lookahead/lookbehind, ma garantisce performance prevedibili anche con input di grandi dimensioni.