Golang Regex

L'espressione regolare, comunemente nota come regex, è una sequenza di caratteri che definiscono e regolano i modelli di ricerca che corrispondono a una stringa specifica. Le espressioni regolari sono uno strumento molto utile quando si lavora con i dati di testo.

Questo articolo esplorerà come lavorare con l'espressione regolare nel linguaggio di programmazione Go usando il pacchetto build regexp.

Pacchetto Golang Regexp

Il pacchetto Golang Regexp fornisce metodi e strumenti per la ricerca, il filtraggio, la sostituzione, la convalida ed estrarre stringhe usando espressioni regolari.

Per utilizzare questo pacchetto, dobbiamo importarlo come:

importare "regexp"

Per definire i modelli di espressione regolari, possiamo usare alcuni schemi predefiniti come mostrato nella tabella seguente:

Modello	Descrizione
.	Abbina qualsiasi singolo personaggio
[ABC]	Abbinare A, B o C
\S	Abbina un personaggio di spazi bianchi. \ t \ n \ f \ r
[AC]	Qualsiasi personaggio da a a c
[^ABC]	Negare e abbinare tutti i personaggi tranne A, B e C
\ w	Abbina un personaggio di Word
a | b	Operatore alternativo. a o b, preferisci a
[A-Z0-9]	Abbinare qualsiasi personaggio da a a z o 0 a 9
\D	Abbinare qualsiasi cifra tra 0 e 9
^	All'inizio di un testo o di una linea
?	Abbinare il personaggio precedente solo una volta
+	Abbinare il carattere precedente una volta o più volte
*	Abbinare il carattere precedente 0 o più volte
$	Corrispondere alla fine del testo

Metodo findString ()

Il metodo FindString () restituisce la sottostringa più a sinistra corrispondente a uno schema specificato. Se non viene trovata alcuna corrispondenza, la funzione restituisce una stringa vuota.

Un codice di esempio è come mostrato:

packagemain
importazione (
"FMT"
"regexp"
)
funcmain ()
Ri: = regexp.MustCompile ("F ([A-Z]+) T")
fmt.Println (re.FindString ("Fruit")
fmt.Println (re.FindString ("Fit"))
fmt.Println (re.FindString ("false")
fmt.Println (re.FindString ("Faith"))
fmt.Println (re.FindString ("Fix"))

Nell'esempio precedente, utilizziamo il metodo MustComPile per compilare il modello di espressione regolare su una struttura regex ottimizzata.

Quindi, utilizziamo il metodo findString () per restituire le stringhe corrispondenti. Il codice precedente dovrebbe restituire:

frutta
adatto
Fait

Nota: la funzione restituisce stringhe vuote se non c'è corrispondenza.

Metodo findStringIndex ()

Questo metodo restituisce l'indice di partenza e finale della sottostringa più a sinistra abbinata da un'espressione regolare specificata.

Esempio:

packagemain
importazione (
"FMT"
"regexp"
)
funcmain ()
Ri: = regexp.MustCompile ("F ([A-Z]+) T")
fmt.Println (re.FindStringIndex ("Fruit"))

Il codice precedente dovrebbe restituire l'indice della sottostringa corrispondente. Nel nostro esempio, il codice restituisce dall'indice da 0 a 5:

$ go run regex.andare
[0 5]

Metodo sostituita ()

Il metodo ReploaCaLlString () viene utilizzato per sostituire il testo corrispondente a uno schema specifico. Restituisce la copia e sostituisce tutte le stringhe corrispondenti.

Possiamo illustrare questo metodo usando il seguente codice:

packagemain
importazione (
"FMT"
"regexp"
)
funcmain ()
Ri: = regexp.MustCompile ("F ([A-Z]+) T")
fmt.Printf ("%q \ n", re.ReplAceAlString ("frutta", "cibo"))

Il codice precedente dovrebbe sostituire la stringa di corrispondenza con il valore specificato. Poiché l'intera stringa corrisponde al modello specificato, la funzione sostituisce tutti i caratteri.

Metodo diviso ()

Possiamo dividere una stringa usando il metodo split () e il modello specificato. Un codice di esempio è come mostrato:

packagemain
importazione (
"FMT"
"regexp"
)
funcmain ()
Ri: = regexp.MustCompile ("U")
fmt.Printf ("%q \ n", re.Split ("frutto", -1))
fmt.Printf ("%q \ n", re.Split ("giovedì", -2))
fmt.Printf ("%q \ n", re.Split ("funzione", 2))

Il codice precedente definisce un'espressione regolare per abbinare un singolo carattere. Quindi utilizziamo il metodo diviso per dividere la stringa fornita in varie sottostringi in cui il pattern corrisponde.

L'output risultante è come mostrato:

$ go run regex.andare
["fr" "it"]
["th" "rsday"]
["f" "nction"]

Conclusione

Questo tutorial illustra come iniziare con un'espressione regolare nella programmazione GO usando il pacchetto regexp. Inoltre, sono stati discussi diversi metodi per determinare l'opzione giusta per le tue esigenze. Controlla altri articoli di suggerimento Linux e la documentazione per imparare altri suggerimenti.