Quantificadores gulosos

Como já vimos, todos os quantificadores são gulosos, pois sempre casam o máximo possível. Mas por que isso? Como isso acontece? Acompanhe um passo-a-passo para esclarecer o assunto e nunca mais sofrer por não entender a gulodice.

Para a demonstração, vamos pegar uma frase:

um negrito aqui.

E supondo que nosso objetivo seja casar os marcadores  e  para apagá-los. Mas ao aplicarmos a ER <.*>, vemos que ela casou além, pegando de uma vez todo o trecho negrito. O que aconteceu?

Aconteceu que o asterisco, como todo quantificador, é guloso e casou o máximo que conseguiu. Vamos entrar na abstração da abstração e entender como isso aconteceu.

Imaginemos que somos o próprio robozinho, então como aplicaremos a ER no texto?

um <b>negrito</b> aqui.
^                           <.*>

Temos a frase e o circunflexo logo abaixo indica onde está o foco da ER e mais à direita está nossa ER. Estamos no estado inicial, parados no começo da linha, e agora vamos tentar casar a expressão. A primeira coisa que temos para casar, é o <.

Como a primeira letra da frase é um u, mudamos o foco para o próximo caractere, pois este não é o < que procuramos:

um <b>negrito</b> aqui.
.^                          <.*>

Mmmmmmm, ainda não deu, então continuamos assim, um por um, até conseguirmos um casamento:

um <b>negrito</b> aqui.
..^                         <.*>
...^                        <.*>

Opa, agora achamos um <! Conseguimos casar o primeiro átomo de nossa ER. Então marcamos como casado esses caracteres e seguimos adiante para o próximo:

um <b>negrito</b> aqui.
...x^                       "<".*>

Os trechos já casados são representados pelos x marcando a frase e as aspas marcam a ER. Os pontinhos representam apenas os "rastros" do foco, as partes já visitadas e não casadas.

A próxima parte da ER a ser casada é o curinga, que casa qualquer caractere em qualquer quantidade. Então, procurando qualquer caractere, nosso curinga segue casando:

um <b>negrito</b> aqui.
...x^                       "<.*">
...xx^                      "<.*">
...xxx^                     "<.*">
...xxxx^                    "<.*">

Ei! Mas ele passou batido pelo > que a gente queria! Por quê? Lembre-se de que o ponto casa qualquer caractere? E por acaso o > também não é qualquer caractere? É, então o ponto casa ele também, seguindo guloso até o fim da linha:

um <b>negrito</b> aqui.
...xxxxxxxxxxxxxxxxxxxx^    "<.*">

Pronto. Como bateu lá no final e não tem mais caracteres para casar, o asterisco sossega. Mas ainda temos um componente da ER para casar, o >. E agora?

Bem, o asterisco é guloso, mas não é egoísta, então se ele precisar ceder alguma coisa, ele cede. E assim acontece, ele vai devolvendo até satisfazer o próximo componente da ER:

um <b>negrito</b> aqui.
...xxxxxxxxxxxxxxxxxxx^     "<.*">
...xxxxxxxxxxxxxxxxxx^      "<.*">
...xxxxxxxxxxxxxxxxx^       "<.*">
...xxxxxxxxxxxxxxxx^        "<.*">
...xxxxxxxxxxxxxxx^         "<.*">
...xxxxxxxxxxxxxx^          "<.*">
...xxxxxxxxxxxxx^           "<.*">

Opa, agora o asterisco devolveu um > que servirá para casar o último átomo de nossa ER:

um <b>negrito</b> aqui.
...xxxxxxxxxxxxxx^          "<.*>"

Pronto! Nossa ER agora está casada por inteiro, então não temos mais o que fazer, fim do processo. Agora ficou fácil entender essa gulodice? É sempre assim, casa o máximo possível, e se precisar, devolve alguns caracteres para satisfazer o resto da expressão.

Por causa dessa gulodice e da subseqüente procura de trás para frente é que acaba se casando além do desejado. Exatamente assim também funcionam todos os outros quantificadores: mais, chaves e opcional. Sempre casam o máximo possível. Então, em uma visão diferente, vamos ver o que cada parte da ER casou na frase:

um <b>negrito</b> aqui.
...x                        <
....xxxxxxxxxxxx            .*
................x           >

Quando o que normalmente se esperava conseguir era:

um <b>negrito</b> aqui.
...x.........x              <
....x.........xx            .*
.....x..........x           >

Para o asterisco ter esse comportamento, ou você faz uma ER mais específica, ou usa um quantificador não-guloso, se o aplicativo suportá-lo. Vamos conhecê-los!

Está gostando da leitura?
Está aprendendo?
Compre o livro novo que traz mais conteúdo, texto atualizado e ilustrações!