Análise de ficheiros de registo

O pacote regexp oferece suporte para expressões regulares em Go.

Sintaxe

A sintaxe das expressões regulares aceites é a mesma sintaxe geral usada por Perl, Python e outras linguagens.

Tanto os padrões de pesquisa como os textos de entrada são interpretados como UTF-8.

Quando usas backticks (`) para criar strings, as barras invertidas (\) não têm qualquer significado especial e não marcam o início de carateres especiais como as tabulações \t ou as novas linhas \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'

Por isso, é preferível usar backticks para criar expressões regulares, porque assim não precisamos de escapar as barras invertidas:

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

Compilar padrões - o tipo RegExp

Para usar uma expressão regular, temos primeiro de compilar o padrão, que é uma string. Compilar, aqui, significa pegar no padrão da expressão regular e convertê-lo numa representação interna com que é mais fácil trabalhar. Só precisamos de compilar cada padrão uma vez; a partir daí, podemos usar a versão compilada da expressão regular tantas vezes quantas quisermos. O tipo regexp.Regexp representa uma expressão regular compilada. Podemos compilar um padrão em string para um regexp.Regexp com a função regexp.Compile. Esta função devolve nil e um erro se a compilação falhar:

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)+`

A função MustCompile é uma alternativa prática a Compile:

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

Com esta função, não é preciso tratar o erro.

Métodos das expressões regulares

Há 16 métodos de Regexp que fazem corresponder uma expressão regular e identificam o texto correspondente. Os seus nomes correspondem a esta expressão regular:

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

• Se All estiver presente, o método encontra correspondências sucessivas e sem sobreposição da expressão inteira.
• Se String estiver presente, o argumento é uma string; caso contrário, é uma fatia de bytes; os valores devolvidos são ajustados em conformidade.
• Se Submatch estiver presente, o valor devolvido é uma fatia que identifica as subcorrespondências sucessivas da expressão.
• Se Index estiver presente, as correspondências e as subcorrespondências são identificadas por pares de índices de bytes dentro da string de entrada.

Há também métodos para:

• substituir correspondências de expressões regulares por strings de substituição e
• dividir strings separadas por expressões regulares.

No total, o pacote regexp define mais de 40 funções e métodos. Vamos demonstrar a utilização de alguns métodos a seguir. Consulta a documentação da API para mais detalhes sobre estas e outras funções.

Exemplos de MatchString

O método MatchString indica se uma string contém alguma correspondência da expressão regular.

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

Exemplos de FindString

O método FindString devolve uma string com o texto da correspondência mais à esquerda da expressão regular.

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")     // => ""

Exemplos de FindStringSubmatch

O método FindStringSubmatch devolve uma fatia de strings com o texto da correspondência mais à esquerda da expressão regular e as correspondências, se existirem, das suas subexpressões. Isto pode ser usado para identificar as strings que correspondem a grupos de captura. Um valor devolvido nil indica que não há correspondência.

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>

Exemplos de ReplaceAllString

O método re.ReplaceAllString(src,repl) devolve uma cópia de src, substituindo as correspondências da expressão regular re pela string de substituição 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"

Exemplos de Split

O método re.Split(s,n) divide um texto s em substrings separadas pela expressão e devolve uma fatia com as substrings que ficam entre essas correspondências da expressão. O valor n determina o número máximo de substrings a devolver. Se n<0, o método devolve todas as substrings.

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"}