Go by Example - IT: Espressioni Regolari

Go offre il supporto nativo alle espressioni regolari. Ecco qualche esempio di operazioni comuni con le regexp in Go.

package main
import "bytes"
import "fmt"
import "regexp"
func main() {

Questo controlla che una stringa soddisfi una regexp

    match, _ := regexp.MatchString("p([a-z]+)ch", "peach")
    fmt.Println(match)

Prima abbiamo utilizzato le regexp in modo diretto. In generale si invoca prima il Compile su una regexp, al fine di ottenere una struct Regexp ottimizzata.

    r, _ := regexp.Compile("p([a-z]+)ch")

Su questa struttura abbiamo a disposizione svariati metodi. Ecco un test simile al nostro primo esempio.

    fmt.Println(r.MatchString("peach"))

Questo restituisce il primo match (una stringa) che soddisfa la regexp.

    fmt.Println(r.FindString("peach punch"))

Anche questo metodo restituisce il primo match, ma invece di restituirne la stringa, restituisce l’indice di inizio e di fine della stringa.

    fmt.Println(r.FindStringIndex("peach punch"))

La variante Submatch include informazioni relativi al match del pattern e anche ai match di eventuali sotto-pattern. In questo caso restituirebbe i match per i pattern p([a-z]+)ch e ([a-z]+).

    fmt.Println(r.FindStringSubmatch("peach punch"))

In modo simile questo metodo restituirà gli indici di inizio e di fine del match e dei sotto-match

    fmt.Println(r.FindStringSubmatchIndex("peach punch"))

La variante All, invece di restituire solo la prima occorrenza del match, restituisce tutti i match.

    fmt.Println(r.FindAllString("peach punch pinch", -1))

Questa variante All è disponibile per tutte le funzioni che abbiamo visto prima.

    fmt.Println(r.FindAllStringSubmatchIndex(
        "peach punch pinch", -1))

Se si passa un intero non negativo come secondo parametro di queste funzioni si sta limitando il numero di match da restituire. Ad esempio in questo caso si è interessati solamente ai primi 2 match.

    fmt.Println(r.FindAllString("peach punch pinch", 2))

Il nostro primo esempio mostrava la funzione MatchString che lavorava su stringhe. È possibile passare anche parametro di tipo []byte ed utilizzare la funzione Match.

    fmt.Println(r.Match([]byte("peach")))

Se si vuole creare una costante a partire da una regexp si può utilizzare la funzione MustCompile (invece di Compile). La classica Compile non funzionerà in quanto ha 2 valori restituiti.

    r = regexp.MustCompile("p([a-z]+)ch")
    fmt.Println(r)

Il pacchetto regexp può essere utilizzato anche per effettuare sostituzioni di stringhe/sottostringhe.

    fmt.Println(r.ReplaceAllString("a peach", "<fruit>"))

La variante Func permette di trasformare i match trovati passandogli una funzione che verrà applicata su ogni occorrenza

    in := []byte("a peach")
    out := r.ReplaceAllFunc(in, bytes.ToUpper)
    fmt.Println(string(out))
}
$ go run regular-expressions.go 
true
true
peach
[0 5]
[peach ea]
[0 5 1 3]
[peach punch pinch]
[[0 5 1 3] [6 11 7 9] [12 17 13 15]]
[peach punch]
true
p([a-z]+)ch
a <fruit>
a PEACH

Per avere la documentazione completa delle espressioni regolari in Go, controlla la pagina del pacchetto regexp

Prossimo esempio: JSON.