&Anders.Lund; &Anders.Lund.mail;
Lisiane
Sztoltz

    lisiane@conectiva.com.br

Tradução

# Expressões Regulares

    Este Apêndice contém uma breve mas suficiente introdução sobre o
    mundo das expressões regulares. Ele documenta
    expressões regulares na forma disponível dentro do &kappname;, que
    não é compatível com as expressões regulares do Perl, ou de
    outros comandos como o grep.

## Introdução

As Expressões Regulares nos fornecem uma maneira de descrever alguns possíveis conteúdos de uma string de texto, de modo a ser entendido por um pedaço de software, e assim, ele pode investigar se um texto combina, e também no caso de aplicativos avançados, com o objetivo de salvar pedaços ou o texto que combina com a busca.

Um exemplo. Digamos que você deseja buscar, em um texto, por parágrafos que iniciam com um desses nomes: Henrik ouPernille , seguido por alguma forma do verbo dizer.

Com uma pesquisa normal, você iria começar a procurar pelo primeiro nome, Henrique, sendo talvez seguido de di, como o seguinte: `Henrique di` e, enquanto procura por ocorrências, iria ignorar os que não se encontram no início de um parágrafo, assim como os que têm uma palavra que começa por di que não é diz, disse ou algo do gênero. Claro, e ainda ter que repetir isto com o próximo nome...

Com as Expressões Regulares, aquela tarefa poderia ser cumprida com uma única busca, e com um grau maior de precisão.

Para obter isto, as Expressões Regulares definem regras para expressar em detalhes uma generalização de uma string que será procurada. Podemos literalmente expressar nosso exemplo assim: Uma linha iniciada com Henrik ou Pernille (possivelmente seguido por 4 caracteres em branco ou tabs) seguido por um espaço em branco, seguido por um di e então, um iz ou sse, que poderia ser colocado na seguinte expressão regular:

`^[ \t]{0,4}(Henrik|Pernille) di(sse|z)`

O exemplo anterior demonstra todos os quatro conceitos principais das Expressões Regulares modernas, chamados:

- Padrões

- Afirmações

- Quantificadores

- Referências para trás

O acento circunflexo (`^`) no início da expressão é uma afirmação, sendo verdade somente se a string relacionada estiver no início de uma linha.

As strings `[ \t]` e `(Henrik|Pernille) di(sse|z)` são padrões. A primeira é uma classe de caractere que combina ou com um espaço em branco ou com um caractere de tabulação (horizontal); o outro padrão contém primeiramente um subpadrão que combina ou com `Henrik` ou com `Pernille`. Em seguida, vem um pedaço que corresponde exatamente com a string `di` e, finalmente segue um subpadrão que combina com `sse` ou com `z`.

A string `{0,4}` é um quantificado dizendo qualquer número de 0 até 4 da string anterior.

Por causa do suporte ao conceito de referência para trás das expressões regulares, é economizado uma parte inteira combinada da string, bem como os subpadrões incluídos em parênteses; fornecidos alguns tipos de acesso para aquelas referências, podemos obter nossos meios de encontrar a string inteira (ao se procurar um documento de texto em um editor com uma expressão regular, o que é marcado frequentemente) ou o nome encontrado, ou a última parte do verbo.

Toda junta, a expressão procurará o que você desejar que ela procure, e somente ali.

As seções seguintes descreverão em detalhes como construir e usar padrões, classes de caracteres, afirmações, quantificadores e referências para trás, e a seção final fornecerá alguns exemplos úteis.

## Padrões

Padrões consistem de strings literais e classes de caracteres, e podem conter subpadrões, que são padrões cercados por parênteses.

### Escapando caracteres

Em padrões, bem como em classes de caracteres, alguns caracteres possuem um significado especial. Para combinar literalmente quaisquer um destes caracteres, eles devem ser marcados ou escapados, para deixar com que o software saiba que deve interpretar tais caracteres de maneira literal.

Isto é feito anexando no início do caractere uma barra invertida (`\`).

O software de expressão regular silenciosamente ignorará, escapando um caractere que não possui nenhum significado especial no contexto; assim, escapar, por exemplo, um j (`\j` ) é seguro. Se você tiver dúvidas se um caractere possui significado especial, você pode, portanto, escapá-lo seguramente.

A marcação inclui o próprio caractere de barra; por isso, para escapar uma barra, você deveria escrever `\\`.

### Classes de Caracteres e abreviações

Uma classe de caractere é uma expressão que combina um dos caracteres de um conjunto definido. Em Expressões Regulares, as classes de caracteres são definidas colocando-se os caracteres legais em uma classe com colchetes (`[]`), ou usando uma das classes abreviadas descritas abaixo.

Classes de caracteres simples contém um ou mais caracteres literais, como por exemplo `[abc]` (combinando com uma das letras: a, b ou c) ou `[0123456789]` (combinando com qualquer dígito).

Uma vez que as letras e os números possuem uma ordem lógica, você poderá abreviá-los, definindo para isso intervalos: `[a-c]` é igual a `[abc]` e `[0-9]` é igual a `[0123456789]`. Combinar estas opções, por exemplo `[a-fynot1-38]` é perfeitamente possível (a última classe irá corresponder a um dos seguintes caracteres: a,b,c,d, e,f,y,n,o,t, 1,2,3 ou 8).

Como as letras maiúsculas são diferentes de minúsculas em expressões, para criar uma classe de caracteres que não diferenciasse maiúsculas de minúsculas, combinando por exemplo com a ou b, em qualquer caso, você precisaria escrever `[aAbB]`.

Obviamente, é possível criar uma classe negativa que corresponda a tudo exceto. Para fazer isso, coloque um acento circunflexo (`^`) no início da classe:

`[^abc]` combinará com qualquer caractere menos com a, b ou c.

Além disso, para caracteres literais, algumas abreviações são definidas, tornando a vida um pouco mais fácil:

`\a`

  Isto combina com o caractere &ASCII; da campainha (BEL, 0x07).

`\f`

  Isto combina com o caractere &ASCII; de nova página (FF, 0x0C).

`\n`

  Isto combina com o caractere &ASCII; de nova linha (LF, 0x0A, nova linha do Unix).

`\r`

  Isto combina com o caractere &ASCII; de retorno de carro (CR, 0x0D).

`\t`

  Isto combina com o caractere &ASCII; de tabulação horizontal (HT, 0x09).

`\v`

  Isto combina com o caractere &ASCII; de tabulação vertical (VT, 0x0B).

`\xhhhh`

  Isto combina com o caractere Unicode correspondente ao número hexadecimal hhhh (entre 0x0000 e 0xFFFF). \0ooo (&ie;, \zero ooo) combina com o caractere &ASCII;/Latin-1 correspondente ao número octal ooo (entre 0 e 0377).

`.` (ponto)

  Isto combina com qualquer caractere (incluindo nova linha).

`\d`

  Isto combina com um dígito. É igual a `[0-9]`

`\D`

  Isto combina com um caractere que não seja dígito. Igual a `[^0-9]` ou `[^\d]`

`\s`

  Isto combina com um caractere em branco. Praticamente igual a `[\t\n\r]`

`\S`

  Combina com o que não seja espaço em branco. Praticamente igual a `[^\t\r\n]`, e igual a `[^\s]`

`\w`

  Combina com quaisquer caractere da palavra, neste caso quaisquer letras , dígitos ou sublinhado. Igual a `[a-zA-Z0-9]`

`\W`

  Combina com qualquer caractere diferente de palavra - qualquer coisa menos letras, números ou sublinhado. Igual a `[^a-zA-Z0-9]` ou `[^\w]`

A notação POSIX de classes, `[:<class name>:]` também é suportada. Por exemplo, `[:digit:]` é equivalente a `\d`, e `[:space:]` a `\s`. Veja a lista completa de classes de caracteres POSIX aqui.

As classes abreviadas pode ser colocadas dentro de classes personalizadas, como por exemplo: para combinar um caractere de palavra, um em branco ou um ponto, você poderia escrever `[\w\.]`

#### Caracteres com significado especial dentro das classes

Os seguintes caracteres possuem um significado especial dentro da construção [] de classes de caractere, e deve ser escapado para ser literalmente incluído em uma classe:

`]`

  Finaliza a classe. Deve ser escapado, a menos que este caractere seja o primeiro da classe (pode ser seguido por um circunflexo não-escapado).

`^` (circunflexo)

  Denota uma classe negativa, se for o primeiro caractere. Deve ser escapado para combinar literalmente, se for o primeiro caractere da classe.

`-` (hífen)

  Denota um intervalo lógico. Deve sempre ser escapado dentro de uma classe.

`\` (barra invertida)

  O caractere de escape. Deve sempre ser escapado.

### Alternativas: combinando um deles

Se você deseja combinar um de um conjunto de padrões alternativos, pode separá-los com o caractere de barra vertical: `|`

Por exemplo: para encontrar a palavra John ou a palavra Harry, você usaria uma expressão do tipo `John|Harry`.

### Subpadrões

Subpadrões são padrões fechados entre parênteses, e possuem vários usos no mundo das expressões regulares.

#### Especificando alternativas

Você pode usar subpadrões para agrupar um conjunto de alternativas dentro de um padrão maior. As alternativas são separadas pelo caractere | (barra vertical).

Por exemplo: Para procurar uma das palavras int, float ou double, você poderia usar o padrão `int|float|double`. Se você deseja somente encontrar delas, se for seguida por algum espaço em branco e então algumas letras, coloque as alternativas dentro de um subpadrão: `(int|float|double)\s+\w+`.

#### Capturando texto relacionado (referências anteriores)

Se você quiser usar uma referência anterior, use um subpadrão `(PADRÃO)` para que a parte desejada do padrão seja lembrada. Para impedir que o subpadrão seja lembrado, use um grupo não capturador `(?:PADRÃO)`.

Por exemplo: Se você deseja encontrar duas ocorrências da mesma palavra, separadas por vírgula, e possivelmente algum espaço em branco, poderia escrever: `(\w+),\s*\1`. O subpadrão `\w+` procuraria pelo pedaço dos caracteres da palavra, e a expressão inteira combinaria se aquelas forem separadas por uma vírgula, 0 ou mais espaços em branco, e então, um pedaço igual de caracteres da palavra (a string `\1` referencia o primeiro subpadrão entre os parênteses).

Para evitar ambiguidades com o uso de `\1` com alguns dígitos depois dele (por exemplo, `\12` pode ser o 12º subpadrão ou apenas o primeiro subpadrão com `2`), usamos `\{12}` como sintaxe para subpadrões com vários dígitos.

Exemplos:

- `\{12}1` é usar subpadrão 12

- `\123` é usar captura 1 e então 23 como texto normal

#### Afirmações Adiante

Uma afirmação do tipo adiante é um subpadrão, iniciando com `?=` ou `?!`.

Por exemplo: para combinar a string literal Bill, mas somente seguida por Gates, você poderia usar esta expressão: `Bill(?! Gates)` (isto procuraria por Bill Clinton, bem como por Billy the kid, mas ele silenciosamente ignoraria as outras combinações).

Os subpadrões usados para as afirmações não são capturados.

Veja também em Afirmações.

#### Afirmações atrás

Uma afirmação atrás é um subpadrão, iniciando com `?<=` ou `?<!`.

Atrás tem o mesmo efeito que a adiante, mas funciona de trás para frente. Por exemplo, para corresponder à string literal fruit mas somente se não for precedida por grape, você poderia usar esta expressão: `(?<!grape)fruit`.

Os subpadrões usados para as afirmações não são capturados.

Veja também em Afirmações

### Caracteres com significado especial dentro de padrões

Os seguintes caracteres possuem um significado especial dentro de um padrão, e devem ser escapados, caso você deseje procurá-los literalmente:

`\` (barra invertida)

  O caractere de escape.

`^` (circunflexo)

  Combina com o início da string.

`$`

  Combina com o fim da string.

`()` (parênteses esquerdo e direito)

  Denota subpadrões.

`{}` (abre e fecha chaves)

  Denota quantificadores numéricos.

`[]` (abre e fecha colchetes)

  Denota classes de caracteres.

`|` (barra vertical)

  OR lógico. Alternativas separadas.

`+` (sinal de mais)

  Quantificador, 1 ou mais.

`*` (asterisco)

  Quantificador, 0 ou mais.

`?` (ponto de interrogação)

  Um caractere opcional. Pode ser interpretado como um quantificador, 0 ou 1.

## Quantificadores

Quantificadores permitem que uma expressão regular combine dentro de um número especificado ou de um intervalo de números, com um caractere, uma classe de caracteres ou um subpadrão.

Os quantificadores estão dentro de chaves (`{` e `}` ), e possuem como forma geral: `{[mínimo-ocorrências][, [máximo-ocorrências]]}`

O uso é melhor explicado através do exemplo:

`{1}`

  Exatamente 1 ocorrência

`{0,1}`

  Zero ou 1 ocorrência

`{,1}`

  O mesmo, mas com menos trabalho ;)

`{5,10}`

  No mínimo 5 e no máximo 10 ocorrências.

`{5,}`

  No mínimo 5 ocorrências, sem máximo.

Adicionalmente, existe algumas abreviações:

`*` (asterisco)

  igual a `{0,}`, procura por quaisquer número de ocorrências.

`+` (sinal de mais)

  similar a `{1,}`, no mínimo 1 ocorrência.

`?` (ponto de interrogação)

  similar a `{0,1}`, zero ou 1 ocorrência.

### Guloso

Ao usar os quantificadores sem máximo, as expressões regulares padronizam a combinação para o mais próximo da string procurada possível, comumente conhecido como comportamento guloso.

O software moderno de expressões regulares fornece o chamado desligamento do modo 'guloso', embora em um ambiente gráfico a interface fornece a você o acesso a isto. Por exemplo, um diálogo de busca, fornecendo a busca para uma expressão regular, poderia ter uma caixa chamada Combinação Mínima, bem como indicar se o 'modo guloso' é o comportamento padrão.

### Exemplos do Contexto

Aqui estão alguns exemplos do uso de quantificadores:

`^\d{4,5}\s`

  Combina com os dígitos em 1234 ir e 12345 agora, mas não combina com 567 sete nem com 223459 algum local.

`\s+`

  Combina uma ou mais vezes com caracteres de espaço em branco.

`(bla){1,}`

  Combina com todos os blablabla, e com bla em blackbird ou tabla.

`/?>`

  Combina com /> em <fecharitem/> bem como com > em <abriritem>.

## Afirmações

Afirmações permitem que uma expressão regular combine com certas condições controladas.

Uma afirmação não precisa de um caractere para combinar, e em vez disso ela investiga as adjacentes de uma possível combinação, antes de conhecê-la. Por exemplo: a afirmação limite da palavra não tenta encontrar um caractere que não seja da palavra, oposto de uma palavra em sua posição, e ao invés disso, ele certifica-se de que não existe um caractere da palavra. Isto significa que a afirmação pode combinar onde não existe caractere, &ie;, no final de uma string procurada.

Algumas verificações, de fato, possuem um padrão de correspondência, mas a parte do texto que correspondeu não será uma parte do resultado da correspondência, em relação à expressão completa.

As Expressões Regulares, como documentadas aqui, suportam as seguintes afirmações:

`^` (circunflexo: início de string)

  Combina com o início da string procurada.

  A expressão `^Peter` combinará com Peter na string Peter, ei!, mas não com Ei, Peter!

`$` (final da string)

  Combina com o fim da string procurada.

  A expressão `você\?$` combinará com o 'você' no final da string É isto que deseja para você?, mas não combinará com É isto que deseja para você, certo?

`\b` (limite da palavra)

  Combina se existir um caractere da palavra, mas não combina com o caractere de outra.

  Isto é útil para encontrar finais de palavras, como por exemplo, finais para encontrar uma expressão inteira. A expressão `\bem\b` procurará separado por em na string Ele estava em prantos no embarque, mas não combinará, por exemplo, com o em de embarque.

`\B` (sem limite de palavra)

  Combina com tudo que \b não combina.

  Isto significa que ele combinará com string dentro de palavras. A expressão `\Em\B` combinará com embarque mas não com Ele estava em prantos.

`(?=PADRÃO)` (adiante positivo)

  Uma afirmação adiante olha na parte da string seguinte, como uma possível combinação. O 'adiante positivo' prevenirá a string de combinação, se o texto seguinte não combina com o PADRÃO da afirmação, mas o texto combinado não será incluído no resultado.

  A expressão `carta(?=\w)` combinará com carta em cartada, mas não em O jogador deu uma cartada!

`(?!PADRÃO)` (adiante negativo)

  O 'adiante negativo' previne que uma possível combinação seja de conhecimento, se a seguinte parte da string buscada não combina com seu PADRÃO.

  A expressão `const \w+\b(?!\s*&)` combinará com const char na string const char* foo enquanto que não combinará const QString em const QString& bar, pois o & combina com o padrão de afirmação negativo.

`(?<=PADRÃO)` (atrás positivo)

  Retrospectiva tem o mesmo efeito que o adiante, mas funciona de trás para frente. Retrospectiva examina a parte da string anterior a uma possível correspondência. Retrospectiva positiva corresponderá a uma string somente se ela for precedida pelo PADRÃO da asserção, mas o texto correspondido por esse PADRÃO não será incluído no resultado.

  A expressão `(?<=cup)cake` corresponderá a cake se for seguida por cup (em cupcake mas não em cheesecake ou em cake sozinho).

`(?<!PADRÃO)` (retrospectiva negativa)

  A 'atrás negativo' previne que uma possível combinação seja de conhecimento, se a seguinte parte da string buscada não combina com seu PADRÃO.

  A expressão `(?<![\w\.])[0-9]+` corresponderá em 123 nas strings =123 e -123 enquanto não pode corresponder a 123 em . 123 ou word123.

`(PADRÃO)` (grupo de captura)

  O subpadrão dentro dos parênteses é capturado e memorizado, para que possa ser usado em referências anteriores. Por exemplo, a expressão `(&quot;+)[^&quot;]*\1` corresponde a `"""texto"""` e `"texto"`.

  Consulte a seção Captura de texto correspondente (referências anteriores) para obter mais informações.

`(?:PADRÃO)` (grupo não-captura)

  O subpadrão dentro dos parênteses não é capturado e não é lembrado. É preferível usar sempre grupos não capturantes se as capturas não forem usadas.