Expressões regulares em

Sobre Expressões regulares

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

Sintaxe

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

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

Ao usar crases (`) para criar strings, as barras invertidas (\) não têm nenhum significado especial e não marcam o início de caracteres especiais como tabulações \t ou quebras de linha \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, vale a pena usar crases para criar expressões regulares, pois assim não precisamos escapar as barras invertidas:

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

Compilar padrões - tipo RegExp

Para usar uma expressão regular, primeiro precisamos compilar o padrão escrito como uma string. Compilar aqui significa pegar o padrão da expressão regular em forma de string e convertê-lo em uma representação interna mais fácil de manipular. Só precisamos compilar cada padrão uma vez; depois disso, podemos usar a versão compilada da expressão regular quantas vezes quisermos. O tipo regexp.Regexp representa uma expressão regular compilada. Podemos compilar um padrão em string para um regexp.Regexp usando a função regexp.Compile. Essa função retorna 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 essa função, não é preciso tratar um erro.

Métodos de expressões regulares

Existem 16 métodos de Regexp que encontram correspondências de uma expressão regular e identificam o texto correspondente. Os nomes deles correspondem a esta expressão regular:

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

• Se All estiver presente, a rotina encontra correspondências sucessivas e não sobrepostas da expressão inteira.
• Se String estiver presente, o argumento é uma string; caso contrário, é um slice de bytes; os valores de retorno são ajustados conforme o caso.
• Se Submatch estiver presente, o valor de retorno é um slice que identifica as subcorrespondências sucessivas da expressão.
• Se Index estiver presente, as correspondências e subcorrespondências são identificadas por pares de índices de bytes dentro da string de entrada.

Também existem 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 o uso de alguns métodos a seguir. Consulte a documentação da API para saber mais sobre essas e outras funções.

Exemplos de MatchString

O método MatchString informa se uma string contém alguma correspondência de uma 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 retorna 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 retorna um slice de strings com o texto da correspondência mais à esquerda da expressão regular e as correspondências, se houver, de suas subexpressões. Isso pode ser usado para identificar as strings que correspondem a grupos de captura. Um valor de retorno nil indica que não houve 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) retorna 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 retorna um slice das substrings entre essas correspondências da expressão. A contagem n determina o número máximo de substrings a retornar. Se n<0, o método retorna 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"}

Desempenho

A implementação de regexp fornecida por este pacote tem garantia de execução em tempo linear em relação ao tamanho da entrada.

Ressalva

O pacote regexp implementa expressões regulares RE2 (exceto por \C). A sintaxe é amplamente compatível com PCRE ("Perl Compatible Regular Expression"), mas há algumas diferenças. Consulte a seção "Caveat" em neste artigo para mais detalhes.