Analisi dei file di log

Il pacchetto regexp offre 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 sia 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 le nuove righe \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. Per compilazione qui si intende prendere il pattern dell'espressione regolare come stringa e convertirlo in una rappresentazione interna con cui è più facile lavorare. 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 in forma di stringa in un regexp.Regexp usando la funzione regexp.Compile. Questa funzione restituisce nil e un errore se la compilazione non è riuscita:

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 serve gestire l'errore.

I metodi delle espressioni regolari

Ci sono 16 metodi di Regexp che cercano le corrispondenze di un'espressione regolare e identificano il testo trovato. 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 è una slice di byte; i valori restituiti vengono adattati di conseguenza.
• Se Submatch è presente, il valore restituito è una 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;
• dividere 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 di MatchString

Il metodo MatchString indica se una stringa contiene almeno una corrispondenza di 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 di 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 di FindStringSubmatch

Il metodo FindStringSubmatch restituisce una slice di stringhe contenente il testo della corrispondenza più a sinistra dell'espressione regolare e le corrispondenze, se presenti, delle sue sottoespressioni. Può essere usato 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 di 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 di Split

Il metodo re.Split(s,n) divide un testo s in sottostringhe separate dall'espressione e restituisce una slice delle sottostringhe comprese tra quelle corrispondenze. 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"}