Espressioni regolari in

Informazioni su Espressioni regolari

Il pacchetto regexp offre il supporto per le espressioni regolari in Go.

Sintassi

La sintassi delle espressioni regolari accettate è la stessa sintassi generale usata da Perl, Python e altri linguaggi.

Sia i pattern di ricerca che i testi di input vengono interpretati come UTF-8.

Quando si usano i backtick (`) per creare le stringhe, le barre rovesciate (\) non hanno alcun significato speciale e non indicano l'inizio di caratteri speciali come le tabulazioni \t o i ritorni a capo \n:

"\t\n" // regular string literal with 2 characters: a tab and a newline
`\t\n`// raw string literal with 4 characters: two backslashes, a 't', and an 'n'

Per questo motivo, conviene usare i backtick per creare le espressioni regolari, perché così non dobbiamo fare l'escape delle barre rovesciate:

"\\" // string with a single backslash
`\\` // string with 2 backslashes

Compilare i pattern: il tipo RegExp

Per usare un'espressione regolare, dobbiamo prima compilare il pattern sotto forma di stringa. Compilare qui significa prendere il pattern di una espressione regolare e convertirlo in una rappresentazione interna più facile da usare. Dobbiamo compilare ogni pattern una sola volta; dopodiché possiamo usare la versione compilata dell'espressione regolare tutte le volte che vogliamo. Il tipo regexp.Regexp rappresenta un'espressione regolare compilata. Possiamo compilare un pattern sotto forma di stringa in un regexp.Regexp usando la funzione regexp.Compile. Questa funzione restituisce nil e un errore se la compilazione è fallita:

re, err := regexp.Compile(`(a|b)+`)
fmt.Println(re, err) // => (a|b)+ <nil>
re, err = regexp.Compile(`a|b)+`)
fmt.Println(re, err) // => <nil> error parsing regexp: unexpected ): `a|b)+`

La funzione MustCompile è un'alternativa comoda a Compile:

re = regexp.MustCompile(`[a-z]+\d*`)

Usando questa funzione, non c'è bisogno di gestire un errore.

I metodi delle espressioni regolari

Ci sono 16 metodi di Regexp che cercano una corrispondenza con un'espressione regolare e individuano il testo corrispondente. I loro nomi corrispondono a questa espressione regolare:

Find(All)?(String)?(Submatch)?(Index)?

• Se All è presente, il metodo trova le corrispondenze successive non sovrapposte dell'intera espressione.
• Se String è presente, l'argomento è una stringa; altrimenti è uno slice di byte; i valori restituiti sono adattati di conseguenza.
• Se Submatch è presente, il valore restituito è uno slice che identifica le sottocorrispondenze successive dell'espressione.
• Se Index è presente, le corrispondenze e le sottocorrispondenze sono identificate da coppie di indici di byte all'interno della stringa di input.

Ci sono anche metodi per:

• sostituire le corrispondenze delle espressioni regolari con stringhe di sostituzione e
• dividere le stringhe separate da espressioni regolari.

Nel complesso, il pacchetto regexp definisce più di 40 funzioni e metodi. Qui di seguito mostreremo l'uso di alcuni metodi. Per i dettagli su queste e altre funzioni, consulta la documentazione dell'API.

Esempi con MatchString

Il metodo MatchString indica se una stringa contiene una corrispondenza con un'espressione regolare.

re = regexp.MustCompile(`[a-z]+\d*`)
b = re.MatchString("[a12]")       // => true
b = re.MatchString("12abc34(ef)") // => true
b = re.MatchString(" abc!")       // => true
b = re.MatchString("123 456")     // => false

Esempi con FindString

Il metodo FindString restituisce una stringa contenente il testo della corrispondenza più a sinistra dell'espressione regolare.

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.FindString("[a12]")       // => "a12"
s = re.FindString("12abc34(ef)") // => "abc34"
s = re.FindString(" abc!")       // => "abc"
s = re.FindString("123 456")     // => ""

Esempi con FindStringSubmatch

Il metodo FindStringSubmatch restituisce uno slice di stringhe contenente il testo della corrispondenza più a sinistra dell'espressione regolare e le corrispondenze, se ci sono, delle sue sottoespressioni. Lo si può usare per identificare le stringhe che corrispondono ai gruppi di cattura. Un valore restituito pari a nil indica che non c'è alcuna corrispondenza.

re = regexp.MustCompile(`[a-z]+(\d*)`)
sl = re.FindStringSubmatch("[a12]")       // => []string{"a12","12"}
sl = re.FindStringSubmatch("12abc34(ef)") // => []string{"abc34","34"}
sl = re.FindStringSubmatch(" abc!")       // => []string{"abc",""}
sl = re.FindStringSubmatch("123 456")     // => <nil>

Esempi con ReplaceAllString

Il metodo re.ReplaceAllString(src,repl) restituisce una copia di src, sostituendo le corrispondenze dell'espressione regolare re con la stringa di sostituzione repl.

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.ReplaceAllString("[a12]", "X")       // => "[X]"
s = re.ReplaceAllString("12abc34(ef)", "X") // => "12X(X)"
s = re.ReplaceAllString(" abc!", "X")       // => " X!"
s = re.ReplaceAllString("123 456", "X")     // => "123 456"

Esempi con Split

Il metodo re.Split(s,n) divide un testo s in sottostringhe separate dall'espressione e restituisce uno slice con le sottostringhe comprese tra quelle corrispondenze dell'espressione. Il conteggio n determina il numero massimo di sottostringhe da restituire. Se n<0, il metodo restituisce tutte le sottostringhe.

re = regexp.MustCompile(`[a-z]+\d*`)
sl = re.Split("[a12]", -1)      // => []string{"[","]"}
sl = re.Split("12abc34(ef)", 2) // => []string{"12","(ef)"}
sl = re.Split(" abc!", -1)      // => []string{" ","!"}
sl = re.Split("123 456", -1)    // => []string{"123 456"}

Prestazioni

L'implementazione delle espressioni regolari fornita da questo pacchetto garantisce un tempo di esecuzione lineare rispetto alla dimensione dell'input.

Avvertenza

Il pacchetto regexp implementa le espressioni regolari RE2 (tranne \C). La sintassi è in gran parte compatibile con PCRE («Perl Compatible Regular Expression»), ma ci sono alcune differenze. Per i dettagli, consulta la "Caveat section" in questo articolo.