expressos regulares

8/22/2019 Expressos Regulares

http://slidepdf.com/reader/full/expressos-regulares 1/97

Consulta Rápida

Expressões

Regulares

Autor

Aurélio Marinho Jargas

[email protected]

Editado como eBook

em Maio, 2013 por

[email protected]

http://[email protected]/

http://[email protected]/



Sumário

Expressões Regulares ................................................... 6

Apresentação ............................................................... 7

História ....................................................................... 9Terminologia ............................................................. 10

Para que servem? ...................................................... 12

Metaacaracteres ......................................................... 14

Metacaracteres tipo Representante ............................... 17

Lista:a exigente [...] ................................................... 19Metacaracteres tipo Quantificador ................................ 24

Opcional: o opcional ? ............................................. 25

Asterisco: o tanto-faz * ........................................... 27

Mais: o tem-que-ter + ............................................. 29

Chaves: o controle {n,m} ........................................ 30

Metacaracteres tipo Áncora ......................................... 31

Circunflexo: o início ^ ............................................. 32

Cifrão: o fim $ ........................................................ 33

Borda: a limítrofe \b ................................................ 34

Outros Metacaracteres ................................................ 35

Escape: a contrabarra \ ........................................... 35

Ou: o alternativo | .................................................. 36

Grupo: (...) ............................................................ 37

Retrovisor: o saudosista \1 ... \9 .............................. 40

Mais sobre Metacaracteres .......................................... 43

Época e aplicativos diversos, Metacaracteres distorcidos . 44

Qualificadores gulosos ................................................ 46

Qualificadores não-gulosos .......................................... 50

Metacaracteres tipo barra-letra .................................... 52

Metacaracteres modernos............................................ 56

(?#texto) ............................................................... 58(?:ER) ................................................................... 58

(?=ER) .................................................................. 58

(?!ER) ................................................................... 59

(?<=ER), (?<!ER) .................................................. 59

(?modificador) ........................................................ 59(?(condição)ER-sim|ER-não) .................................... 60

(?{código}) ............................................................ 60

Precedência entre metacaracteres ................................ 61

Os 6 mandamentos do Criador ..................................... 63

Não complique ......................................................... 64

Use o circunflexo ...................................................... 65

Evite a lista negada .................................................. 67

Evite o curinga ......................................................... 67

Seja específico ......................................................... 68

Não seja afobado, seja ninja ...................................... 70

Como lidar com ... ...................................................... 73Problemas com maiúsculas e minúsculas ..................... 73

ERs pré-processadas e cruas ...................................... 75

Negação de uma palavra ........................................... 76

Multilinha ................................................................ 79

Acentuação .............................................................. 80



Liguagens de programação .......................................... 81

Java * ..................................................................... 82

JavaScript ............................................................... 82

VBscript .................................................................. 84

Bibliotecas e programas relacionados ............................ 88Bibliotecas ............................................................... 88

Programas ............................................................... 88

Onde obter mais informações ...................................... 89

Livros ...................................................................... 89

Tabelas ..................................................................... 91Webliografia .............................................................. 96

Agradecimentos ......................................................... 97



Sobre autor

Sou Aurélio Marinho Jargas. Nasci em Curitiba, hoje moroem Joinville com minha amada esposa Mog. Já ui operário-padrão da indústria de informática, quando era

programador e redator técnico na Conectiva (hojeMandriva), empresa de Linux que vi crescer e ganhar omundo. Já fui baterista de bandas de punk e hardcore,escrevi livros, fiz viagens a lugares legais e pratico algunsesportes bacanas como surfe, carveboard, bumerangue e jacaré :) Nunca bebi, nunca f umei, nunca me droguei. Me

orgulho disso e quero continuar assim até o fim da vida.Hoje sou desempregado por opção, trabalho em casa e soudesenvolvedor e feliz assim.

Introdução

Neste nosso mundo tecnoinformatizado onde o acessorápido à informação desejada é algo crucial, temos nasexpressões regulares uma mão amiga, que quanto maisrefinada for sua construção, mais preciso e rápido será oresultado, diferenciando aqueles que as dominam daquelesque perdem horas procurando por dados que estão ao

alcance da mão. O assunto é algo bem peculiar, poisapesar de a maioria das linguagens de programação,programas e editores de texto mais utilizados possuíremesse recurso, poucos o dominam, principalmente pelo fatode a documentação sobre o assunto, quando existente, serenigmática e pouco didática, ou simplesmente se resumir alistagens, sem explicar os conceitos. Esta obra nasceudessa necessidade e tem como objetivo preencher essa

http://aurelio.net/musica/



http://aurelio.net/livro/



http://aurelio.net/viagem/





http://aurelio.net/surf/



http://aurelio.net/carve/





http://aurelio.net/blog/2010/09/23/estou-ha-5-anos-desempregado-viva/

http://aurelio.net/blog/2010/09/23/estou-ha-5-anos-desempregado-viva/








lacuna, sendo uma documentação completa e didática parainiciantes, tipo tutorial, e um guia de referência para os jáiniciados. Este guia é totalmente dedicada ao assunto, eespero que traga muitos frutos.

Expressões Regulares

A primeira parte é o "feijão com arroz", indicada àquelesque desconhecem ou ainda não se sentem à vontade paracriar suas próprias expressões regulares. Faremos um

"tour" por todas as pecinhas que compõem esse mundofantástico, explicando didaticamente, do zero, o que são,de onde vieram, para que servem e como utilizá-las(Exemplos! Exemplos!). Após ler e entender essa primeiraparte, algo como ^ *[A-Za-z0-9_]+:(.*)..$ vai fazerparte de sua realidade, sem lhe causar pânico. A segunda

parte é a "feijoada", para aqueles que querem umaexperiência mais intensa. Mergulharemos de cabeça eentenderemos de vez essa maquininha esquisita. São asexplicações dos conceitos envolvidos, bem como táticas edicas para você realmente entender e otimizar seu uso dasexpressões regulares. Ao final da leitura, você entenderáporque ^[^:]+:([[:alpha:]]+): é melhor que .*:(.*):.

Mas note que tudo isso, sem viajar muito nos detalhesintrínsecos e sem conhecer os becos escuros que vocêtalvez nunca precisará saber que existem. Acima de tudoeste é um guia prático. É para ler e fazer suas expressões.Isso não o torna superficial, apenas direto.

Com tudo isso temos diversas tabelas e listagens, que



servem para serem consultadas rapidamente em caso dedúvida ou esquecimento. Relaxe, não é um bicho de [0-9]+ cabeças... Vamos bater um papo descontraído sobre oassunto. Então respire fundo, desligue a TV, olhe fixamentepara estas letras e vamos! Espere, antes disso vamos veras notações utilizadas neste guia:

itálico: texto a ser casado sublinhado: casamentos expressão: expressão regular, ou parte dela destaque: opções, texto substituído

"termo": termos estrangeiros

Apresentação Então, para podermos começar nossa viagem, nada comouma apresentação de nosso objetivo, pois afinal de contas,que raios são estas expressões?Bem resumido, uma expressão regular é um método formalde se especificar um padrão de texto.Mais detalhadamente, é uma composição de símbolos,caracteres com funções especiais, que, agrupados entre sie com caracteres literais, formam uma sequência, umaexpressão. Essa expressão é interpretada como uma regra,que indicará sucesso se uma entrada de dados qualquercasar com essa regra, ou seja, obedecer exatamente atodas as suas condições.

Ou como variações aceitas também pode-se afirmar que é:



uma maneira de procurar um texto que você nãolembra exatamente como é, mas tem ideia dasvariações possíveis;

uma maneira de procurar um trecho em posiçõesespecíficas como no começo ou no fim de uma linha,ou palavra;

uma maneira de um programador especificar padrõescomplexos que podem ser procurados e casados emuma cadeia de caracteres;

uma construção que utiliza pequenas ferramentas,feita para obter determinada sequencia de caracteres

de um texto.

Ou ainda, didaticamente falando, é:

Como o brinquedo LEGO, várias pecinhas diferentes,cada uma com sua característica, que juntascompõem estruturas completas e podem ser

arranjadas com infinitas combinações diferentes. Como um jogo de truco, com as cartas normais e as

quentes: gato, copas, espadilha e mole, que sãoespeciais e têm uma ordem de grandeza.

Como um quebra-cabeça, sempre tem solução, àsvezes óbvia, às vezes difícil, mas decifrando as

partes, junta-se tudo e chega-se ao todo. Como um jogo, no começo é difícil, mas após

conhecer todas as regras, basta jogar e curtir. Como uma receita culinária, com seus ingredientes e

uma ordem correta para adicioná-los à mistura. Como consertar carros. Você tem várias peças e

várias ferramentas. Dependendo do tipo da peça, há



uma ferramenta certa para você lidar com ela. Edependendo da sua localização, você tem deincrementar a ferramenta com mais barras ecotovelos para alcançá-la.

Como o alfabeto. Você aprende primeiro as letrasindividualmente. Depois as sílabas, as palavras,frases e finalmente os textos. Mas no fundo, sãoapenas letras.

Ao final da leitura, ficará claro que as expressões sãoapenas pequenos pedacinhos simples que agrupados

formam algo maior. O importante é você compreender bemcada um individualmente, e depois apenas lê-los emsequencia. Lembre-se do alfabeto: são apenas letras...

História

Sim! Vou te contar uma história. A fecundação dessas

expressões aconteceu no ano de 1943, quando os "pais",dois neurologistas, publicaram um estudo que teorizava ofuncionamento dos nossos neurônios. Sentiu o drama?Nosso assunto é nobre desde a sua origem.

Anos depois o "parteiro", um matemático, descreveu

algebricamente os modelos desse estudo, utilizandosímbolos para representar seus recém-criados gruposregulares (do inglês "regular sets"). Com a criação dessanotação simbólica, nasceram as expressões regulares, quedurante toda a sua infância e juventude (cerca de 20anos), foram bastante estudadas pelos matemáticos daépoca.



Mas o encontro com o computador, só aconteceu mesmoem 1968, em um algoritmo de busca utilizado no editor detextos qed, que depois virou o ed, EDitor padrão dosprimeiros sistemas Unix. Este ed tinha o comando decontexto g, que aceitava expressões regulares e umcomando p, e sua sintaxe ficava g/RE/p("Global RegularExpression Print"), que deu origem ao aplicativo grep, quepor sua vez originou o egrep.

Outros filhos como o sed e o AWK também apareceram,cada um implementando as expressões do seu próprio

jeito; e finalmente em 1986 foi criado o divisor de águas,um pacote pioneiro em C chamado regex que tratava dasexpressões regulares e qualquer um poderia incluí-lo emseu próprio programa, de graça. Opa! Falaram as palavrasmágicas: "de graça". Aí não teve mais volta, as expressõescaíram no gosto popular e cada vez mais e mais programas

e linguagens as utilizam.CURIOSIDADE: apesar de esse assunto ser antigo, o quevamos ver aqui basicamente é o mesmo que um estudanteveria há 15 anos atrás. É um conceito consistente, que nãosofre alterações com o passar do tempo.

Terminologia

E se eu te disser que "ERs são metacaracteres que casamum padrão"? Não entendeu?

Bem, como expressões regulares é um termo muitoextenso, daqui adiante, chamarei apenas de ER (ê-

érre) para simplificar a leitura. Outras nomenclaturas que



podem ser encontradas em outras fontes são expreg,"regexp", "regex" e "RE". Particularmente "regex" é umaboa escolha para usar em ferramentas de busca naInternet.

E como estamos falando de termos, tem mais alguns novosque farão parte de nossa conversa. Lembra que asexpressões são formadas por símbolos e caracteresliterais? Esses símbolos são chamadosde metacaracteres, pois possuem funções especiais, queveremos detalhadamente adiante.

Outro termo que é interessante e às vezes pode assustarum leitor meio distraído é o casar ("match"). Casamentoaqui não é juntar os trapos, mas sim o ato de bater,conferir, combinar, igualar, encontrar, encaixar, equiparar.É como em um caixa 24 horas, em que você só retirará odinheiro se sua senha digitada casar com aquela já

cadastrada no banco.

Também temos o padrão ("pattern"), que é nosso objetivoquando fazemos uma ER: casar um padrão. Esse padrãopode ser uma palavra, várias, uma linha vazia, um número,ou seja, o que quer que precise ser encontrado pela nossa

ER.E ainda tem o robozinho, que é uma referência aocompilador e interpretador das expressões regulares, ocódigo que vai ler, checar, entender e aplicar sua ER notexto desejado. Como exemplo, para programas em C orobozinho é a biblioteca regex , que faz todo o serviço.

Para que servem?

Basicamente servem para você dizer algo abrangente deforma específica. Definido seu padrão de busca, você temuma lista (finita ou não) de possibilidades de casamento.

Em um exemplo rápido, [rgp]ato podecasar rato, gato e pato. Ou seja, sua lista "abrangeespecificamente" essas três palavras, nada mais.

<html><body><script type="text/javascript">

var str="Jato pato lado gato dado rato";var pat=/[rgp]ato/g;document.write(str.match(pat));

</script>

</body></html>Resultado: pato,gato,rato

Na prática as expressões regulares servem para umainfinidade de tarefas, é difícil fazer uma lista, pois elas sãoúteis sempre que você precisar buscar ou validar umpadrão de texto que pode ser variável, como:

data horário número IP nome de pessoa

endereço de e-mail

endereço de Internet nome de usuário e senha declaração de uma função() dados na coluna N de um texto dados que estão entre <tags></tags> campos específicos de um texto tabulado número de telefone, RG, CPF, cartão de crédito dados que estão apenas no começo ou no fim da

linha

E mais uma infinidade de outros padrões que não podem

ser especificados com caracteres literais. Um exemploprático: você tem uma lista diária de acesso de usuáriosque entraram em seu sistema, onde consta em cada linha,o horário do acesso e o "login" do usuário, algo como:

05:15 ernesto

08:39 ricardo10:32 patricia14:59 gabriel16:27 carla22:23 marcelo

Como fazer para buscar automaticamente apenas osusuários que acessaram o sistema no período da tarde(meio-dia às seis)? Você tem várias opções, desde procuraruma a uma manualmente até fazer um programa quecompare os primeiros caracteres de cada linha, masfalando de algo prático e rápido, que não exija

conhecimentos de programação, a ER.

<html><body><script type="text/javascript">

var str= '05:15 ernesto ';str+='08:39 ricardo ';

str+='10:32 patricia ';str+='14:59 gabriel ';str+='16:27 carla ';str+='22:23 marcelo ';

document.write( str );var pat=/[1-2][2-9]:../g;if (str.match(pat) != null) {

document.write(' REEX (' +pat+'):');document.write(str.match(pat));

}</script></body></html>Resultado: 14:59, 16:27, 22:23

Acompanhe o próximo tópico e vamos conhecer todos osmetacaracteres, essas coisinhas úteis que facilitam nossavida.

Metaacaracteres

Então, para já matar sua curiosidade, aqui estão os tãofalados metacaracteres-padrão que serão nossospersonagens das próximas páginas: . ? * + ^ $ | [ ] { } () \. E aí, sentiu um frio na barriga? Cada simbolozinhodesses tem sua função específica, que pode mudar

dependendo do contexto no qual está inserido, e podemos



agregá-los uns com os outros, combinando suas funções efazendo construções mais complexas. Além destes, temosoutros metacaracteres estendidos que foram criadosposteriormente, pois tarefas mais complexas requisitavamfunções mais específicas, sua sintaxe de utilização não é amesma para todos os programas que suportam expressõesregulares.

Vamos logo ao que interessa, e para começar vamos darnomes aos bois. Leia, releia e "treleia" esta lista, repetindopara si mesmo e associando o nome ao símbolo, pois estas

palavras farão parte de sua vida, de sua rotina. Acostume-se com os nomes e não os mude.

meta mnemônico . ponto[] lista

[^] lista negada? opcional* asterisco+ mais{} chaves^ circunflexo

$ cifrão\b borda\ escape| ou() grupo\1 retrovisor



Agora que sabemos como chamar nossos amigos novos,veremos uma prévia, um apanhado geral de todos osmetacaracteres e suas funções. Eles estão divididos emquatro grupos distintos, de acordo com característicascomuns entre eles.

Representantes

meta mnemônico função . ponto um caractere qualquer[...] lista lista de caracteres permitidos[^...] lista negada lista de caracteres proibidos

Quantificadores

meta mnemônico função ? opcional zero ou um* asterisco zero, um ou mais+ mais um ou mais{n,m} chaves de n até m

Âncoras

meta mnemônico função^ circunflexo início da linha



$ cifrão fim da linha\b borda início ou fim de palavra

Outros

meta mnemônico função \c escape torna literal o caractere c| ou ou um ou outro(...) grupo delimita um grupo\1...\9 retrovisor texto casado nos grupos 1...9

Não confunda! Os curingas usados na linha de comandopara especificar nomes de arquivos,como *.txt, relatorio.{txt,doc} eguia-??.html nãosão expressões regulares. São curingas específicos denomes de arquivo, e apesar de parecidos, são outra coisa e

os significados de seus símbolos são diferentes dos dasexpressões, então o melhor que você faz agoraé esquecer esses curingas, senão eles podem confundi-loe atrapalhar seu aprendizado.

Metacaracteres tipo Representante

O primeiro grupo de metacaracteres que veremos são osdo tipo representante, ou seja, são metacaracteres cujafunção é representar um ou mais caracteres. Tambémpodem ser encarados como apelidos, links, ou qualqueroutra coisa que lhe lembre essa associação entre

elementos.



Todos os metacaracteres deste tipo casam a posição de umúnico caractere, e não mais que um.

Ponto: O necessitado.

O ponto é nosso curinga solitário, que está sempre àprocura de um casamento, não importa com quem seja.Pode ser um número, uma letra, um TAB, um @, pois o ponto casa qualquer coisa. Suponhamos uma ER quecontenha os caracteres "fala" e o metacaractere ponto,assim: fala.. No texto a seguir, essa ER casaria tudo o queestá sublinhado:

"Olha, com vocês me pressionando a falar não vai sairnatural. Eu não consigo me concentrar na minha fala. Aliás,isso é um falatório, pois nunca vi um comercial comtantas falas assim. Vou me queixar com [email protected]"

Nesse pequeno trecho de texto, nossa ER casou 5 vezes,tendo o ponto casado com os seguintes caracteres: " .ts@".

Como exemplos de uso do ponto, em um texto normal emportuguês, você pode procurar palavras que não lembra seacentuou ou não, que podem começar com maiúsculas ou

não, ou que foram escritas errado:

n.o não, nao, ....eclado teclado, Teclado, ...e.tendido estendido, extendido, eztendido, .

Ou para tarefas mais específicas, procurar horário comqualquer separador, ou marcações ("tags") HTML:

12.45 12:45, 12 45, 12.45, ...

<.> , , , ...

Lista:a exigente [...]

Bem mais exigente que o ponto, a lista não casa comqualquer um. Ela sabe exatamente o que quer, e nada

diferente daquilo, a lista casa com quem ela conhece.Ela guarda dentro de si os caracteres permitidos paracasar, então algo como [aeiou] limita nosso casamento aapenas letras vogais.

No exemplo anterior do ponto, sobre acentuação, tínhamos

a ER n.o. Além dos casamentos desejados, ela é muitoabrangente, e também casa coisas indesejáveiscomo neo, n-o,n5o e n o.

Para que nossa ER fique mais específica, trocamos o pontopela lista, para casar apenas o não e nao desejados, veja:

n[ãa]o

E assim como o n.o, todos os outros exemplos anterioresdo ponto casam muito mais que o desejado, justo pela suanatureza "promíscua".

Exatamente, eles indicam que havia mais possibilidades decasamento. Como o ponto casa com qualquer coisa, ele énada específico. Então vamos impor limites às ERs:

n[ãa]o não, nao[Tt]eclado Teclado, tecladoe[sx]tendido estendido, extendido12[:. ]45 12:45, 12.45, 12 45<[BIP]> , , 

Registre em algum canto de seu cérebro: dentro da lista,todo mundo é normal . Repetindo: dentro da lista, todomundo é normal . Então aquele ponto é simplesmente umponto normal e não um metacaractere.

No exemplo de marcação <[BIP]>, vemos que as ERs são

sensíveis a maiúsculas e minúsculas, então se quisermosmais possibilidades, basta incluí-las:

<[BIPbip]> , , , , , 

Intervalos em listas

Por enquanto, vimos então que a lista abriga todos oscaracteres permitidos em uma posição. Como seria umalista que dissesse que numa determinada posição poderiahaver apenas números? Sim! Então para casar uma hora,qualquer que ela seja, fica como? Lembre que o formato

é hh:mm. Pois é! Assim também pensaram nossos ilustres



criadores das ERs, e, para evitar esse tipo de listagemextensa, temos somente dentro da lista o conceito deintervalo. Lembra, que eu disse para você memorizar quedentro da lista, todo mundo é normal? Pois é, aqui temos aprimeira exceção à regra. Todo mundo, fora o traço. Setivermos um traço (-) entre dois caracteres, issorepresenta todo o intervalo entre eles.

Não entendeu? É assim, olhe:

[0123456789] é igual a [0-9]

É simples assim. Aquele traço indica um intervalo, então 0-9 se lê: "de zero a nove". Voltando a nossa ER da hora,poderíamos fazer [0-9][0-9]:[0-9][0-9], mas veja quenão é específico o bastante, pois permite uma hora como

99:99, que não existe. Como poderíamos fazer uma ER quecase no máximo 23 horas e 59 minutos?

Excelente! Com o que aprendemos até agora, esse é omáximo de precisão que conseguimos. Mais adiante, quempoderá nos ajudar será o ou. Depois voltamos a esseproblema. Era isso que eu ia falar agora. Sim, qualquer

intervalo é válido, como a-z, A-Z, 5-9 , a-f , :-@, etc.Por exemplo, se eu quiser uma lista que case apenas letrasmaiúsculas, minúsculas e números: [A-Za-z0-9]. Como otraço é especial dentro da lista, como fazer quando vocêquiser colocar na lista um traço literal? Basta colocar otraço no final da lista, [0-9-] casa números ou um traço. E

tem os colchetes, que são os delimitadores da lista. Como

incluí-los dentro dela? O colchete que abre não temproblema, pode colocá-lo em qualquer lugar na lista, poisela já está aberta mesmo e não se pode ter uma listadentro da outra. O colchete que fecha deve ser colocado nocomeço da lista, ser o primeiro item dela, para não

confundir com o colchete que termina a lista. Então []-] casa um ] ou um -.

Vamos juntar tudo e fazer uma lista que case ambos oscolchetes e o traço: [][-]. Calma. Pare, pense, respirefundo, encare esta ER. Vamos lê-la um por um: o

primeiro [ significa que é o começo de uma lista, já dentroda lista, temos um ] literal, seguido de um [ literal, seguidode um - literal, e por último o ] que termina a lista.Intuitivo, não? &:)

Tudo bem, você venceu. Nesse intervalo tem : ; < = > ?@ . Como saber isso? Os intervalos respeitam a ordem

numérica da tabela ASCII, então basta tê-la em mãos paraver que um intervalo como A-z não pega somente asmaiúsculas e minúsculas como era de se esperar.

Para sua comodidade, a tabela está no fim do guia, e nelapodemos ver que A-z pega também "[\]^_`" e não pega oscaracteres acentuados como "áéóõç". Infelizmente, não háum intervalo válido para pegarmos todos os caracteresacentuados de uma vez. Mas veremos a solução...

Dominando caracteres acentuados (POSIX)

Como para nós brasileiros se a-z não casar letrasacentuadas não serve para muita coisa, temos unscuringas somente para usar em listas. Eles são chamados



de classes de caracteres POSIX. São grupos definidospor tipo, e POSIX é um padrão internacional que defineesse tipo de regra, como será sua sintaxe, aqui estão asclasses:

classe POSIX similar significa[:upper:] [A-Z] letras maiúsculas[:lower:] [a-z] letras minúsculas[:alpha:] [A-Za-z] maiúsculas/minúsculas[:alnum:] [A-Za-z0-9] letras e números

[:digit:] [0-9] números[:xdigit:] [0-9A-Fa-f] números hexadecimais[:punct:] [.,!?:...] sinais de pontuação[:blank:] [ \t] espaço e TAB[:space:] [ \t\n\r\f\v] caracteres brancos[:cntrl:] - caracteres de controle

[:graph:] [^ \t\n\r\f\v] caracteres imprimíveis[:print:] [^\t\n\r\f\v] imprimíveis e o espaço

Note que os colchetes fazem parte da classe e não são osmesmos colchetes da lista. Para dizer maiúsculas,fica [[:upper:]], ou seja um [:upper:] dentro de uma lista

[]. Então, em uma primeira olhada, [:upper:] é o mesmoque A-Z, letras maiúsculas. Mas a diferença é que essasclasses POSIX levam em conta a localidade do sistema.Atenção para essa diferença, pois a literatura na línguainglesa sempre fala sobre esse assunto muitosuperficialmente, pois eles não utilizam acentuação e deve

ser às vezes até difícil para quem está escrevendo o



documento entender isso. Como nossa situação é inversa,e nossa língua é rica em caracteres acentuados, entenderessa diferença é de suma importância. Como estamos noBrasil, geralmente nossas máquinas estão configuradascomo tal, usando números no formato nnn.nnn,nn , a dataé no formato dd/mm/aaaa, medidas de distância são emcentímetros e outras coisinhas que são diferentes nosdemais países. Entre outros, também está definidoque áéíóú são caracteres válidos em nosso alfabeto, bemcomo ÁÉÍÓÚ . Então, toda essa volta foi para dizer que o[:upper:] leva isso em conta e inclui as letras acentuadas

também na lista. O mesmo para o [:lower:], o [:alpha:] eo [:alnum:]. Por isso para nós essas classes POSIX sãoimportantíssimas, e sempre que você tiver de fazer ERsque procurarão em textos em português, prefira [:alpha:]em vez de A-Za-z, sempre. Então refazendo a ER quecasava maiúsculas, minúsculas e números,

temos: [[:upper:] [:lower:] [:digit:]], oumelhor: [[:alpha:] [:digit:]], ou melhorainda: [[:alnum:]]. Todas são equivalentes. Mas não seassuste, a lista é o único metacaractere que tem suaspróprias regras, funcionando como uma minilinguagemdentro das expressões regulares.

Metacaracteres tipo Quantificador

Aqui chegamos ao segundo tipo de metacaracteres, osquantificadores, que servem para indicar o número derepetições permitidas para a entidade imediatamente

anterior. Essa entidade pode ser um caractere ou



metacaractere. Em outras palavras, eles dizem aquantidade de repetições que o átomo anterior pode ter,quantas vezes ele pode aparecer. Os quantificadores nãosão quantificáveis, então dois deles seguidos em uma ER éum erro, salvo quantificadores não-gulosos, que veremosdepois. E memorize, por enquanto sem entender o porquê:todos os quantificadores são gulosos.

Opcional: o opcional ?

O opcional é um quantificador que não esquenta a cabeça,para ele pode ter ou não a ocorrência da entidade anterior,pois ele a repete 0 ou 1 vez. Por exemplo, a ER6? significazero ou uma ocorrência do número 6. Se tiver um 6,beleza, casamento efetuado. Se não tiver, beleza também.Isso torna o 6 opcional (daí o nome), que tendo ou não, aER casa. Veja mais um exemplo, o plural. AER ondas? tem a letra s marcada como opcional, então ela

casa onda e ondas. Claro! Agora vamos começar a ver opoder de uma expressão regular. Já vimos o metacaracterelista e agora vimos o opcional, que tal fazermos uma listaopcional? Voltando um pouco àquele exemplo dapalavra fala, vamos fazer a ER fala[r!]?. Mmmmmm, asERs estão começando a ficar interessantes não? Mas antes

de analisar essa ER, uma dica que vale ouro, memorize já: leia a ER átomo por átomo, da esquerda para a direita.Repetindo: leia a ER átomo por átomo, da esquerda para adireita.



Como ler uma ER

É bem simples, uma ER se lê exatamente como o robozinholeria. Primeiro lê-se átomo por átomo, depois entende-se otodo e depois se analisa as possibilidades. Na nossa

ER fala[r!]? em questão, sua leitura fica: um f seguido deum a, seguido de um l, seguido de um a, seguido de: ou r,ou !, ambos opcionais. Essa leitura é essencial para oentendimento da ER. Ela pode em um primeiro momentoser feita em voz alta, de maneira repetitiva, até esseprocesso se tornar natural. Depois ela pode ser feita

mentalmente mesmo, e de maneira automática. É comovocê está fazendo agora repetindo mentalmente estaspalavras escritas aqui enquanto as lê. Você não percebe,faz normalmente. Feita a leitura, agora temos de entendero todo, ou seja, temos um trecho literal fala, seguido deuma lista opcional de caracteres. Para descobrirmos as

possibilidades, é o fala seguido de cada um dos itens dalista e por fim seguido por nenhum deles, pois a lista éopcional. Então fica:

fala[r!]? falar, fala!, fala

Pronto! Desvendamos os segredos da ER. É claro, esta épequena e fácil, mas o que são ER grandes senão váriaspartes pequenas agrupadas? O principal é dominar essaleitura por átomos. O resto é ler devagar até chegar aofinal. Não há segredo. Então voltemos ao nosso exemplo demarcações HTML, podemos facilmente incluir agora as

marcações que fecham o trecho, em que a única diferençaé que vem uma barra / antes da letra:

</?[BIPbip]> , , , , , ,

, , , , , 

Por alguns segundos, contemple a ER anterior. Estamoscomeçando a dizer muito com poucos caracteres, sendoespecíficos. Vamos continuar que vai ficar cada vez maisinteressante.

Asterisco: o tanto-faz *

Se o opcional já não esquenta a cabeça, podendo ter ounão a entidade anterior, o asterisco é mais tranquilo ainda,pois para ele pode ter, não ter, ou ter vários, infinitos. Emoutras palavras, a entidade anterior pode aparecer em

qualquer quantidade.

6*0 0, 60, 660, 6660, ..., 666666666660, ...bi*p bp, bip, biip, biiip, biiiip...b[ip]* b, bi, bip, biipp, bpipipi, biiiiip, bppp, ...

Como HTML é sempre um ótimo exemplo, voltamos aonosso exemplo das marcações, que podem ter váriosespaços em branco após o identificador, então e são válidos. Vamos colocar essa condição na ER:

</?[BIPbip] *> , , , ..., ,...

Note que agora com o asterisco, nossa ER já não tem maisum número finito de possibilidades. Vejamos como fica aleitura dessa ER: um <, seguido ou não de uma /, seguidode: ou B, ou I, ou P, ou b , ou i, ou p, seguido ou não devários espaços, seguido de >.

Apresentando a gulodice

Pergunta: o que casará [ar]*a na palavra arara?

1) a [ar] zero vezes, seguido de a2) ara [ar] duas vezes (a,r), seguido de a3) arara [ar] quatro vezes (a,r,a,r), seguido de a

4) n.d.a.

Acertou se você escolheu a número 3. O asterisco repeteem qualquer quantidade, mas ele sempre tentará repetiro máximo que conseguir. As três alternativas são válidas,

mas entre casar a lista [ar] zero, duas ou quatro vezes,ele escolherá o maior número possível. Por isso se diz queo asterisco é guloso. Essa gulodice às vezes é boa, àsvezes é ruim. Os próximos quantificadores, mais e chaves,bem como o opcional já visto, são igualmente gulosos. Maisdetalhes sobre o assunto, confira mais adiante.



Apresentando o curinga .*

Vimos até agora que temos dois metacaracteresextremamente abrangentes, como o ponto (qualquercaractere) e o asterisco (em qualquer quantidade). E se

juntarmos os dois? Teremos qualquer caractere, emqualquer quantidade. O que isso significa, tudo? Nada? Aresposta é: ambos. O nada, pois "qualquer quantidade"também é igual a "nenhuma quantidade". Então é opcionaltermos qualquer caractere, não importa. Assim, uma ERque seja simplesmente .* sempre será válida e casará

mesmo uma linha vazia. O tudo, pois "qualquerquantidade" também é igual a "tudo o que tiver". E éexatamente isso o que o asterisco faz, ele é guloso,ganancioso, e sempre tentará casar o máximo queconseguir. Assim, temos aqui o curinga das ERs, uma cartapara se usar em qualquer situação. É muito comum ao

escrever uma expressão regular, você definir algunspadrões que procura, e lá no meio, em uma parte que nãoimporta, pode ser qualquer coisa, você coloca um .* edepois continua a expressão normalmente. Por exemplo,para procurar ocorrência de duas palavras na mesmalinha,relatório.*amanhã serve para achar aquela linha

maldita em que lhe pediram um trabalho "pra ontem". Ou,ainda, procurar acessos de usuários em uma dataqualquer: 22/11/2001.*login.

Mais: o tem-que-ter +

O mais tem funcionamento idêntico ao do asterisco, tudo oque vale para um, se aplica ao outro. A única diferença éque o mais não é opcional, então a entidade anterior deve



casar pelo menos uma vez, e pode ter várias. Sua utilidadeé quando queremos no mínimo uma repetição. Não hámuito o que acrescentar, é um asterisco mais exigente...

Pois é...

6+0 60, 660, 6660, ..., 666666660, ...bi+p bip, biip, biiip, biiiip...b[ip]+ bi, bip, biipp, bpipipi, biiiiip, bppp, ...

Chaves: o controle {n,m}As chaves são a solução para uma quantificação maiscontrolada, onde se pode especificar exatamente quantasrepetições se quer da entidade anterior.Basicamente, {n,m} significa de n até m vezes, assim algocomo 6{1,4} casa 6, 66,666 e 6666. Só, nada mais que

isso. Temos também a sintaxe relaxada das chaves, emque podemos omitir a quantidade final, ou ainda,especificar exatamente um número:

{1,3} de 1 a 3{3,} pelo menos 3 (3 ou mais){0,3} até 3{3} exatamente 3{1} exatamente 1{0,1} zero ou 1 (igual ao opcional)



{0,} zero ou mais (igual ao asterisco){1,} um ou mais (igual ao mais)

Note que o {1} tem efeito nulo, pois 6{1} é igual a 6.Pode ser útil caso você queira impressionar alguém comsua ER, pode encher de {1} que não mudará sua lógica.Mas observe os três últimos exemplos.

Com as chaves, conseguimos simular o funcionamento deoutros três metacaracteres, o opcional, o asterisco e o

mais.Se temos as chaves que já fazem o serviço, então pra quêter ou outros três? Você pode escolher a resposta queachar melhor. Algumas:

* é menor e mais fácil que {0,}

As chaves foram criadas só depois dos outros Precisavam de mais metacaracteres para complicar o

assunto *, + e ? são links para as chaves Alguns teclados antigos vinham sem a tecla {

Como você pode perceber não há uma resposta certa.

Então todas as especulações acima podem ser corretas. Esendo {0,} um simples *, isso também pode ser usadopara tornar sua ER grande e intimidadora. Só cuidado paranão conseguir entender sua própria criação...

Metacaracteres tipo Áncora



Bem, deixando os quantificadores de lado, vamos agorafalar sobre os metacaracteres do tipo âncora. Por queâncora? Porque eles não casam caracteres ou definemquantidades, ao invés disso eles marcam uma posiçãoespecífica na linha. Assim, eles não podem serquantificados, então o mais, o asterisco e as chaves nãotêm influência sobre âncoras.

Circunflexo: o início ^

O nosso amigo circunflexo marca o começo de uma linha.Nada mais. Apenas dentro da lista (e no começo), fora delaele é a âncora que marca o começo de uma linha, veja:

veja:

^[0-9]

Isso quer dizer: a partir do começo da linha, case umnúmero , ou seja, procuramos linhas que começam comnúmeros. O contrário seria:

^[^0-9]

Ou seja, procuramos linhas que não começam comnúmeros. O primeiro circunflexo é a âncora e o segundo éo "negador" da lista. E como não poderia deixar de ser, éclaro que o circunflexo como marcador de começo de linhasó é especial se estiver no começo da ER. Não faz sentido

procurarmos uma palavra seguida de um começo de linha,



pois se tiver uma palavra antes do começo de uma linha,ali não é o começo da linha! Desse modo, a ER:

[0-9]^

Casa um número seguido de um circunflexo literal, emqualquer posição da linha. Com isso em mente, você podeme dizer o que casa a ER:

^^

Procura por linhas que começam com um circunflexo. Epara fechar, uma ER que em um e-mail, casa as conversasanteriores, aquelas linhas que começam com aqueles sinaisde maior >.

Cifrão: o fim $

Similar e complementar ao circunflexo, o cifrão marca o fimde uma linha e só é válido no final de uma ER. Como oexemplo anterior, [0-9]$ casa linhas que terminam comum número. E o que você me diz da ER a seguir?

^$

Essa ER é sempre bom ter na manga, pois procurar porlinhas vazias é uma tarefa comum nas mais diversas



situações. Podemos também casar apenas os cinco últimoscaracteres de uma linha.

.....$

Ou, ainda, que tal casarmos linhas que tenham entre 20 e60 caracteres?

^.{20,60}$

É comum pessoas chamarem o cifrão de "dólar".

Borda: a limítrofe \b

A outra âncora que temos é a borda, que como o próprionome já diz, marca uma borda, mais especificamente, uma

borda de palavra.

Ela marca os limites de uma palavra, ou seja, onde elacomeça e/ou termina. Muito útil para casar palavrasexatas, e não partes de palavras. Veja como se comportamas ERs nas palavras dia, diafragma, radial ,melodia e bom-dia!:

dia dia, diafragma, radial, melodia, bom-dia!\bdia dia, diafragma, bom-dia!dia\b dia, melodia, bom-dia!\bdia\b dia, bom-dia!



Assim vimos que a borda força um começo ou terminaçãode palavra. Entenda que "palavra" aqui é um conceito queengloba [A-Za-z0-9_] apenas, ou seja, letras, números eo sublinhado. Por isso \bdia\b também casa bom-dia! poiso traço e a exclamação não são parte de uma palavra.

Dependendo do aplicativo, o sublinhado não faz parte deuma palavra.

Outros Metacaracteres

Deixando as âncoras mergulhadas em nossa memória,agora já sabemos como casar algo, emalguma quantidade, em algum lugar na linha. Entãovamos ver outros metacaracteres, que têm funçõesespecíficas e não relacionadas entre si, portanto nãopodem ser agrupados em outra classe fora a tradicional"outros". Mas atenção, isso não quer dizer que eles são

inferiores, pelo contrário, o poder das ERs é multiplicadocom seu uso e um mundo de possibilidades novas se abre asua frente. E primeiro deles, o "contra barra".

Escape: a contrabarra \

Se você está atento, lembrará que a lista tem suas própriasregras e que...

Precisou de um caractere que é um meta, mas você querseu significado literal, coloque-o dentro de uma lista,então lua[*] casa lua*. O mesmo serve para qualquer

outro metacaractere. Para não precisar ficar toda hora



criando listas de um único componente só para tirar seuvalor especial, temos o metacaractere contrabarra \, que"escapa" um metacaractere, tirando todos os seusrecursos. Escapando, \* é igual a [*] que é igual a umasterisco literal. Similarmente podemos escapar todos osmetacaracteres jávistos: \., \[ , \], \?, \+ , \{, \},\^ e \$. E para vocêver como são as coisas, o escape é tão poderoso que podeescapar a si próprio! O \\ casa uma barrainvertida \ literal. Escapar um circunflexo ou cifrão somenteé necessário caso eles estejam em suas posições especiais,

como casar o texto ^destaque^, em que ambos oscircunflexos são literais, mas o primeiro será consideradouma âncora de começo de linha caso não esteja escapado.

Então, agora que sabemos muito sobre ERs, que tal umaexpressão para casar um número de RG no formato

n.nnn.nnn-n? É fácil!

[0-9]\.[0-9]{3}\.[0-9]{3}-[0-9]

Ou: o alternativo |

É muito comum em uma posição específica de nossa ERtermos mais de uma alternativa possível, por exemplo, aocasar um cumprimento amistoso, podemos ter umaterminação diferente para cada parte do dia:

boa-tarde|boa-noite



O ou, representado pela barra vertical |, serve para essescasos em que precisamos dessas alternativas. Essa ER selê: "ou boa-tarde, ou boa-noite", ou seja "ou isso ouaquilo". Lembre que a lista também é uma espécie de ou,mas apenas para uma letra, então:

[gpr]ato e gato|pato|rato

São similares, embora nesse caso em que apenas umaletra muda entre as alternativas, a lista é a melhor escolha.

Em outro exemplo, o ou é útil também para casarmos umendereço de Internet, que pode ser uma página, ou umsítio FTP

http://|ftp://

Ou isso ou aquilo, ou aquele outro... E assim vai. Pode-seter tantas opções quantas se precise. Não deixe deconhecer o parente de 1º grau do ou, o grupo, quemultiplica seu poder. A seguir, neste mesmo canal.

Grupo: (...)

O grupo tem o dom de juntar vários tipos de sujeitos emum mesmo local. Dentro de um grupo podemos ter um oumais caracteres, metacaracteres e inclusive outros grupos!Como em uma expressão matemática, os parêntesesdefinem um grupo, e seu conteúdo pode ser visto como um

bloco na expressão.



Todos os metacaracteres quantificadores que vimosanteriormente, podem ter seu poder ampliado pelo grupo,pois ele lhes dá mais abrangência. E o ou, pelo contrário,tem sua abrangência limitada pelo grupo, e pode parecerestranho, mas é essa limitação que lhe dá mais poder.

Em um exemplo simples, (ai)+ agrupa a palavra "ai" eesse grupo está quantificado pelo mais. Isso quer dizer quecasamos várias repetições da palavra, como ai, aiai, aiaiai,... E assim podemos agrupar tudo o que quisermos, literaise metacaracteres, e quantificá-los:

(ha!)+ ha!, ha!ha!, ha!ha!ha!, ...

(\.[0-9]){3} .0.6.2, .2.8.9, .6.6.6, ...

(www\.)?zz\.com www.zz.com, zz.com

E em especial nosso amigo ou ganha limites e seu podercresce:

boa-(tarde|noite) boa-tarde, boa-noite

(#|n\.|núm) 6 # 6, n. 6, núm 6

(in|con)?certo incerto, concerto, certo

Note que o grupo não altera o sentido da ER, apenas serve

como marcador. Podemos criar subgrupos também, então



imagine que você esteja procurando o nome de umsupermercado em uma listagem e não sabe se este é ummercado, supermercado ou um hipermercado.

(super|hiper)mercado

Consegue casar as duas últimas possibilidades, mas noteque nas alternativas super e hiper temos umtrecho per comum aos dois, então podíamos apenas asdiferenças su e hi :

(su|hi)permercado

Precisamos também casar apenas o mercado sem osaumentativos, então temos de agrupá-los e torná-los

opcionais:

((su|hi)per)?mercado

Pronto! Temos a ER que buscávamos e ainda esbanjamos

habilidade utilizando um grupo dentro do outro.

(mini|(su|hi)per)?mercado

E assim vai... Acho que já deu para notar quão poderosas ecomplexas podem ficar nossas ERs ao utilizarmos grupos,



não? Mas não acaba por aqui! Acompanhe o retrovisor naseqüência.

Ah! Lembra-se do escape criptonita? Basta tirar o poderdos parênteses, escapando-os. Veja um exemplo na ER

para procurar declarações de função em códigos deprogramas como Minha_Funcao()

[A-Za-z0-9_]+

Ou ainda, caso acentuação seja permitida em nomes defunção (lembre-se das classes POSIX!):

[[:alnum:]_]+

Retrovisor: o saudosista \1 ... \9

Já vimos o poder do grupo, e várias utilidades em seu uso.Mas ainda não acabou! Se prepare para conhecer o mundonovo que o retrovisor nos abre. Ao usar um (grupo)qualquer, você ganha um brinde, e muitas vezes nem sabe.

O brinde é o trecho de texto casado pela ER que está nogrupo, que fica guardado em um cantinho especial, e podeser usado em outras partes da mesma ER! Então vamostentar de novo. Como o nome diz, é retrovisor porque ele"olha pra trás", para buscar um trecho já casado. Isso émuito útil para casar trechos repetidos em uma mesma

linha. Veja bem, é o trecho de texto, e não a ER. Como



exemplo, em um texto sobre passarinhos, procuramos oquero-quero. Podemos procurar literalmente por quero-quero , mas assim não tem graça, pois somos mestres emERs e vamos usar o grupo e o retrovisor para fazer isso:

(quero)-\1

Então o retrovisor \1 é uma referência ao texto casado doprimeiro grupo, nesse caso quero, ficando, no fim dascontas, a expressão que queríamos. O retrovisor pode ser

lembrado também como um link, pois copia o texto dogrupo. Pois é, lembra que o escape \ servia para tirar ospoderes do metacaractere seguinte. Então, a essa definiçãoagora incluímos: a não ser que este próximo caractere sejaum número de 1 a 9, então estamos lidando com umretrovisor. Notou o detalhe? Podemos ter no máximo 9

retrovisores por ER, então \10 é o retrovisor número 1seguido de um zero. Alguns aplicativos novos permitemmais de nove. Nesse caso sim. Mas este é só um exemplodidático. O verdadeiro poder do retrovisor é quando nãosabemos exatamente qual texto o grupo casará. Vamosestender nosso quero para "qualquer palavra":

([A-Za-z]+)-\1

Percebeu o poder dessa ER? Ela casa palavras repetidas,separadas por um traço, como o próprio quero-quero, e



mais: bate-bate , come-come, etc. Mas, e se tornássemoso traço opcional?

([A-Za-z]+)-?\1

Agora, além das anteriores, nossa ER tambémcasa bombom, lili, dudu, bibi e outros apelidos e nomes decachorro.

Com uma modificação pequena, fazemos um minicorretor

ortográfico para procurar por palavras repetidas comocomo estas em um texto:

([A-Za-z]+) \1

Mas lembre-se que procuramos por palavras inteiras e nãoapenas trechos delas, então precisamos usar as bordaspara completar nossa ER:

\b([A-Za-z]+) \1\b

Legal né? Note como vamos construindo as ERs aospoucos, melhorando, testando e não simplesmenteescrevendo tudo de uma vez. Esta é a arte de se escreverERs.

Mais detalhes



Como já dito, podemos usar no máximo nove retrovisores.Vamos ver uns exemplos com mais de um de nossosamigos novos:

(lenta)(mente) é \2 \1 lentamente é mente lenta((band)eira)nte \1 \2a bandeirante bandeira bandain(d)ol(or) é sem \1\2 indolor é sem dor((((a)b)c)d)-1 = \1,\2,\3,\4 abcd-1 = abcd,abc,ab,a

Para não se perder nas contagens, há uma dica valiosa:

conte somente os parênteses que abrem, da esquerda paraa direita. Este vai ser o número do retrovisor. E o conteúdoé o texto casado pela ER do parêntese que abre até seucorrespondente que fecha. Nos nossos exemplos acimaocorre a mesma coisa porque a ER dentro do grupo já é opróprio texto, sem metacaracteres. Veja, entretanto,

que ([0-9])\1 casa 66 mas não 69.

Apenas como lembrete, algumas linguagens e programas,além da função de busca, têm a função de substituição. Oretrovisor é muito útil nesse caso, para substituir "algumacoisa" por "apenas uma parte dessa coisa", ou seja, extrairtrechos de uma linha. Mais detalhes sobre isso adiante.

Mais sobre Metacaracteres

Sempre que tiver dúvida ou esquecimento, reveja essaparte e relembre as funções de cada um, as quais você sóvai memorizar com o uso contínuo das ERs. Pratique. É

importante que o que vimos até aqui esteja bem entendido



para seguirmos adiante. Não deixe de conferir também atabela dos os metacaracteres no final do guia.

Época e aplicativos diversos, Metacaracteresdistorcidos Agora que já aprendemos todos aqueles metacaracteres,sua sintaxe, suas regras, seus detalhes, é hora de aplicarna prática esse conhecimento. E aí é que vem a surpresa,quando você percebe que alguns metacaracteres nãofuncionam direito... O que acontece?

O que acontece é que existe uma diferença brutal desintaxe entre aplicativos, em que cada um coloca suapersonalidade, e temos várias maneiras de representar omesmo metacaractere. Por exemplo: o opcional é ? noPython, Perl e linguagens de programação mais novas. Masem aplicativos mais antigos como o grep e o sed, ele é

escapado \?, sendo ?uma mera interrogação literal. Já noeditor de textos vim, o opcional é representado peloesquisito \=. Vai entender?

O motivo mais comum para isso acontecer são as razõeshistóricas. Voltando no tempo, na época em que os

primeiros programas começavam a ter suporte aexpressões regulares, basicamente o que era comum de sefazer em um editor de textos eram códigos de programas,e não textos normais da linguagem falada. Assim, comoera (e ainda é) muito comum de se ter oscaracteres ?, +, {, ( e |nos códigos de programas, era

comum eles fazerem parte da ER por seu valor literal, ou



seja, procurar por uma interrogação, por uma barravertical, etc. Então, no começo de tudo, essesmetacaracteres eram todos escapados para seremespeciais: \?, \+, \{, \( e \|. Já aplicativos e linguagensmais novos, criados em um mundo onde a editoraçãoeletrônica avançou muito e um "texto de computador" nãoera apenas um código de programa, todos os escapesforam retirados e os metacaracteres ficaram mais simples.

Aqueles aplicativos antigos, porém, continuam até hojeutilizando os escapes, pois têm de manter a

compatibilidade com versões anteriores. Alguns são maisespertos e suportam ambas as sintaxes, escolhendo viaconfiguração ou opção de linha de comando. Toda essahistorinha, além de curiosidade, está aqui para que vocêsaiba o porquê das coisas, e isso o ajuda na hora dadúvida, pois se você sabe que o aplicativo é antigo,

provavelmente os metacaracteres devem ser escapados.Ou ainda, se você viu que o opcional ? precisou serescapado, outros provavelmente precisarão também.

Concluindo, ora razões históricas ora vaidade do autor, ofato é que a diversidade impera e você vai ter de seacostumar com isso e aprender as diferenças de cada

aplicativo que for utilizar. Bem-vindo ao mundo caótico daimplementação das expressões regulares. Mas para ajudarnesse reconhecimento da diferença, no final do guia háuma daquelas tabelinhas mágicas, que parece simples, masdemora dias para fazer, e pode e deve ser consultada emcaso de dúvida. Estão registradas todas as diferenças

encontradas em vários aplicativos e linguagens. Com ela

em mãos, você não precisa mais se preocupar com isso. Onome é "Diferenças de Metacaracteres Entre Aplicativos".

Qualificadores gulosos

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

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

um negrito aqui.

E supondo que nosso objetivo seja casar osmarcadores e para apagá-los. Mas aoaplicarmos a ER <.*>, vemos que ela casou além,

pegando de uma vez todo o trecho negrito. O queaconteceu?

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

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

um negrito aqui.^ <.*>

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

Como a primeira letra da frase é um u, mudamos o focopara o próximo caractere, pois este não é o < queprocuramos:


.^ <.*>

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

um negrito 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 negrito aqui....x^ "<".*>

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

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


...x^ "<.*">

...xx^ "<.*">

...xxx^ "<.*">

...xxxx^ "<.*">

Ei! Mas ele passou batido pelo > que a gente queria! Porquê? Lembre-se de que o ponto casa qualquer caractere? Epor acaso o > também não é qualquer caractere? É, entãoo ponto casa ele também, seguindo guloso até o fim dalinha:

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

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

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

um negrito aqui....xxxxxxxxxxxxxxxxxxx^ "<.*">...xxxxxxxxxxxxxxxxxx^ "<.*">...xxxxxxxxxxxxxxxxx^ "<.*">...xxxxxxxxxxxxxxxx^ "<.*">

...xxxxxxxxxxxxxxx^ "<.*">...xxxxxxxxxxxxxx^ "<.*">

...xxxxxxxxxxxxx^ "<.*">

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

um negrito 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ácilentender essa gulodice? É sempre assim, casa o máximopossível, e se precisar, devolve alguns caracteres parasatisfazer o resto da expressão.

Por causa dessa gulodice e da subseqüente procura de tráspara frente é que acaba se casando além do desejado.

Exatamente assim também funcionam todos os outros

quantificadores: mais, chaves e opcional. Sempre casam omáximo possível. Então, em uma visão diferente, vamosver o que cada parte da ER casou na frase:


...x <

....xxxxxxxxxxxx .*

................x >

Quando o que normalmente se esperava conseguir era:

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

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

Qualificadores não-gulosos

A gulodice dos quantificadores é algo geralmente benéfico,mas em certas situações, como a do negrito anterior, você

quer o oposto: o menor casamento possível. Apenas



presente em linguagens e aplicativos mais recentes, essaopção de metacaracteres tem uma sintaxe fácil de lembrar,basta acrescentar uma interrogação logo após osquantificadores normais:

meta mnemônico?? opcional não-guloso*? asterisco não-guloso+? mais não-guloso{n,m}? chaves não-gulosas

Não há muito o que demonstrar, visto que jáesmiuçamos a gulodice. A não-gulodice é o efeitocontrário, um quantificador "tímido", que só casa se opróximo átomo da ER não estiver precisando daquelecaractere. Veja a comparação entre ambos os tipos degulodice em todos os quantificadores, aplicados aotexto aaaaa :

gulososa.* aaaaaa.+ aaaaa

a.? aaa.{1,3} aaaa

não-gulososa.*? a



a.+? aaa.?? aa.{1,3}? aa

Metacaracteres tipo barra-letra

Os metacaracteres do tipo barra-letra são átomosrepresentados por uma barra invertida \ seguida de umaletra qualquer, como \s e \W. Dependendo da letra, muda-se o significado desse metacaractere. Contando que o

alfabeto nos dá 26 letras e que maiúsculas são diferentesde minúsculas, duplicamos para 52 metacaracteres novos.Calma, nem todas as letras estão ocupadas... Ainda &:)

Tudo começou nas linguagens de programação comos printf da vida, que começaram a interpretar coisas,como \n e\t, para significar quebra de linha e TAB, poisvisualmente é ambíguo se "1 2" é um, TAB, dois ou um,espaços, dois. Exceto estes, havia outros barra-letra pararepresentar aqueles caracteres de controle chatos que devez em quando aparecem em nossa vida e são difíceis dever e representar. Essa representação simplificada e útil setornou padrão e hoje a grande maioria dos aplicativos os

entende. Eis a lista:

b-l nome tradução \a alert alerta (bipe)\b backspace caractere Backspace\e escape caractere Esc



\f form feed alimentação\n newline linha nova\r carriage ret retorno de carro\t htab tabulação horizontal\v vtab tabulação vertical

Como esses barra-letras também poderiam ser muito úteispara escrever nossas expressões regulares, os robozinhoscomeçaram a ter suporte a eles também, ou senão a

linguagem recebe a ER como um dado do tipo string e osinterpreta, passando ao robozinho seus valores literais.Mais detalhes sobre isso no tópico "ERs Pré-Processadas eCruas" adiante. Ah! Note que o \b se confunde com aborda. Cada aplicativo trata essa exceção à sua maneira:ou só é válido dentro da lista, ou depende do contexto,

ou...Aí é aquela história: onde passa boi, passa boiada.Observaram bem as classes POSIX, com aquelarepresentação extensa e feia, depois compararam com osbarra-letra, que são curtos e charmosos e foi um estalo:criaram barra-letras novos para representar as classes

mais utilizadas. São como "apelidos", pois têm a mesmafuncionalidade de seu equivalente POSIX, levando emconta a localização do sistema (acentuação), o que muitonos interessa.



b-l POSIX equiv. mnemônico\d [[:digit:]] dígito\D [^[:digit:]] não-dígito\w [[:alnum:]_] palavra

\W [^[:alnum:]_] não-palavra\s [[:space:]] branco\S [^[:space:]] não-branco

A grande diferença desses barra-letras para as classesPOSIX, é que eles são válidos fora das listas. Dependendo

do aplicativo, eles são válidos dentro das listas também,bagunçando aquela regra que vimos de que dentro da listatodo mundo é normal . Dependendo também, o sublinhadofaz parte ou não do \w. Com os poderes barra-letrísticosrecém-adquiridos, podemos diminuir nossa ER para casar oRG:

[0-9]\.[0-9]{3}\.[0-9]{3}-[0-9]

\d\.\d{3}\.\d{3}-\d

Mas aí, como já estava feita a festa e ainda sobravammuitas letras do alfabeto, começaram a aparecer barra-letras aleatórios. Segue uma coletânea misturada deles,encontrados apenas em alguns poucos aplicativos, entãoconfirme antes de usá-los:



b-l significado similar \a alfabeto [[:alpha:]]\A não-alfabeto [^[:alpha:]]\h Inicio de palavra [[:alpha]_]

\H não-Ini de palavra [^[:alpha:]_]\l minúsculas [[:lower:]]\L não-minúsculas [^[:lower:]]\u maiúsculas [[:upper:]]\U não-maiúsculas [^[:upper:]]\o número octal [0-7]

\O não-número octal [^0-7]\B não-borda\A início do texto\Z fim do texto\l torna minúscula\L torna minúscula até \E

\u torna maiúscula\U torna maiúscula até \E\Q escapa até \E\E fim da modificação\G fim do casamento anterior

Conclusão: agora lhe resta procurar na documentação deseu aplicativo, se os barra-letras são suportados, se sim,se pelo robozinho ou pela interpretação de strings, quais

barra-letras, e se são válidos dentro e/ou fora das listas.



Nossa! Essa "padronização" das implementações deexpressões regulares realmente impressiona...

Metacaracteres modernos

Bem, tem gente que não sossega mesmo.

Talvez até pelo fato de ser gostoso brincar com ERs, com opassar do tempo, desenvolveu-se uma tendência de "ERssão a solução da fome mundial, elas têm de fazer tudo", eo conceito foi maculado. Hoje, além de simplesmente casar

um trecho de texto, criaram conceitos como:

Case esta ER somente se seguida de tal coisa. Case esta ER somente se não precedida de tal coisa. O "tal coisa" pode ser uma ER mais complicada que a

original. Grupos nomeáveis que geram pseudovariáveis (veja

Python). Grupos que não são acessíveis por retrovisores. Case isso somente se o grupo anterior também casou. Estrutura de "if-then-else" dentro de ERs. A "configuração" de apenas partes da ER. Execução de trechos de linguagem de programação no

meio de ERs.

E como tudo isso exige vários metacaracteres novos,alguns compostos de até cinco caracteres, exceto oconteúdo, as ERs ficaram muito feias e complexas,exercendo funções que a linguagem de programação

deveria fazer, como condicionais, atrelamentos e definiçãode variáveis.

Daí, para tentar domar o monstro ilegível que eles próprioscriaram (como "eles", entenda Perl e Python), agora temos

também:

Comentários no meio das ERs. ERs estruturadas (com "indent"), ocupando várias

linhas.

Como Perl e Python estão ditando o rumo das ERs, e essas

"novidades" tendem a virar padrão em todos os outrosaplicativos, vamos conhecê-los. Primeiramente, todosesses metacaracteres novos só foram possíveis, pois asERs têm certas brechas em construções antes impossíveis,que agora viraram a base para criações novas. Aqui está:

(?...)

Esta era uma estrutura inválida, pois você não pode tornaropcional a abertura de um grupo. Então, usá-la não teriaproblemas de compatibilidade, pois ainda não existia, foiesta a escolhida. Então os metacaracteres novos têm aestrutura:

(?<identificador><conteúdo>)

Onde identificador é o que realmente diz com que tipo de

metacaractere estamos lidando, e conteúdo é o que será



manipulado por esse metacaractere, e pode ser textonormal, outros metacaracteres, opções e até códigos delinguagem externa. Vamos utilizar os personagensamarelos como nossas cobaias de testes.

(?#texto)

Onde texto é um comentário, que não pode ter ocaractere ) e é simplesmente ignorado pelo robozinho.Assim, pode-se colocar lembretes na ER como em (?#onome)Homer (?#e agora o sobrenome)Simpson, que

sem os comentários é Homer Simpson.

(?:ER)

É como um grupo normal () só que não é guardado nemincluído na contagem de grupos, ou seja, não é acessívelcom retrovisores ou $1, pode ser considerado um grupo

fantasma. Assim ^(Homer) (?:J\.) (Simpson) casa onome completo, mas \1 e \2contém Homer e Simpson,respectivamente.

(?=ER)

Não casa caracteres na posição atual, mas dá uma

"espiada" adiante e caso a ER embutida case, retornasucesso. É como só apostar na loteria se você já souber oresultado. Por exemplo a ER Homer (?=Simpson) sócasará o Homer se for seguido de Simpson. Mas osobrenome não faz parte do trecho casado, serviu apenaspara checagem.

(?!ER)

É o contrário do anterior, só casando um trecho seeste não for seguido da ER embutida. Então Homer(?!morreu) casa o Homer do texto Homer comeu, mas

não do Homer morreu. Para memorizar os dois últimosmetacaracteres, veja seus identificadores: = e !, quelembram os operadores == e !=.

(?<=ER), (?<!ER)

Estes dois são complementares aos dois anteriores, a

diferença é que em vez de espiar para frente, eles espiampara trás (note o <apontando para a esquerda).Então (?<!Barney) Simpson casará Simpson em Homer Simpson, mas não em Barney Simpson.

(?modificador)

Pode-se "configurar" uma parte da ER precedendo-a comesta construção, e modificador pode ser um únicocaractere, entre:

i: ignorar a diferença entre maiúsculas e minúsculas; m: trata o texto como multilinha; s: trata o texto como uma única linha; x: permite inclusão de espaços e comentários; L: levar em conta a localização do sistema (somente

Python).

(?(condição)ER-sim|ER-não)

O "if-then-else" dos metacaracteres.

A condição geralmente é um número, que referencia a umgrupo prévio. Se esse grupo casou, a condição é verdadeirae ER-sim é a ER "da vez". Se a condição falhar, a ER-não éutilizada. Isso é basicamente usado para fazer amarraçõese balanceamentos, utilizando condicionais.

É algo como "case um número entre possíveis parênteses,

mas se tiver tem de ter o parênteses que abre E o quefecha", ou seja,669 e (669) são válidos,mas (669 e 669) não. Veja como fica a ER: ($)?[0-9]+(?(1)$). Isso porque nem preenchemos apossibilidadeER-não...

(?{código})

E agora, a prova de que isso já foi longe demais, e o marcoda perda definitiva de compatibilidade de ERs entreaplicativos: a possibilidade de colocar códigos Perl paraserem executados no meio da ER. Por enquanto é só o

Perl que ousou fazer isso.Vou colocar aqui um exemplo tirado do manual do Perl,estruturado e comentado:

$_ = 'a' x 8;m<

(?{ $cnt = 0 }) #inicializa



(a(?{

local $cnt = $cnt + 1; #incrementa})

)*

aaaa

(?{ $res = $cnt }) # se ok, copia para# uma var não-local

>x;

Precedência entre metacaracteres

É bem simples, sabe na matemática, onde temos as ordensde precedência entre a adição e a multiplicação, onde estaé mais "forte" que aquela?

Por exemplo "2+4*6", é "quatro vezes seis, e depois somacom o dois". Mesmo vindo depois, a multiplicação tempreferência. Com as ERs acontece o mesmo, seguindoestas regras:

tipo de meta exemplo precedência quantificador ab+ maiorconcatenação ab média

ou ab|c menor



Ou seja, na situação ab* não é "a com b, em qualquerquantidade", e sim "a, seguido de b em qualquerquantidade", ou seja, a concatenação a seguido de b não émais forte que a quantificação, que rouba o b para ela.

Na última ab|c em vez de "a, seguido de b ou c" é naverdade "ab ou c", pois o ou é o mais fraquinho de todos,não puxa nada para o cesto dele.

Por isso que boa-tarde|boa-noite funciona, pois oscaracteres se juntam e se grudam uns com os outros, e oou não tem força para quebrar isso.

E como na matemática também, os parênteses servempara juntar na marra e dar força aos fracos. Por isso se dizque o grupo aumenta o poder do ou.

Só com a dobradinha grupo+ou é possível algo como boa-tard(e|b)oa-noite, o que não faz sentido, mas mostra

que juntos eles conseguem quebrar a união daconcatenação.

Com isso em mente, como fica a relação de forçasem ab|cd*? Vamos colocar os "amigos" entre chaves parailustrar essa quebra de braço:

ab|c{d*}

O d é do * pela quantificação ser mais forte que aconcatenação, então o c coitado não tem força para puxaro seu amigo d para o seu lado.

ab|{c{d*}}



Agora o c fica na dúvida, mas se juntar com o | não dá,pois ele é o mais fraquinho de todos, então ele se juntacom o d quantificado. Como o | já perdeu a briga à direita,ele olha para o outro lado e...

{ab}|{c{d*}}

O b rapidinho se junta com o a (concatenação) para fugirdo fraco. O | fica com o que sobrou, de um lado ab e dooutro cd*.

Os 6 mandamentos do Criador

No mundo das ERs, temos diversas "leis" não escritas queora ou outra vão bater a sua porta e você verá que segui-las fará com que suas ERs sejam mais precisas e nãofalhem.

Essas leis são um misto de dicas de prevenção deproblemas e ganhos de performance. Se você estácomeçando, não se preocupe com essas regras. Mas sevocê já tem uma experiência grande com ERs, verá queessas leis podem lhe poupar estresse.

Sobre a performance, em situações normais, não énecessário se preocupar com a velocidade de uma ER, poisindependentemente de como você a faça, o resultado viráinstantaneamente. Mas quando aplicadas a vários arquivos,ou a um arquivo muito extenso, a demora pode ser grande.

Temos técnicas simples e complicadas de otimização. Como

as complicadas são de difícil implementação e manutenção,



às vezes não compensando o custo-benefício de seu uso,não vamos vê-las. O assunto é simples e vamos tratá-lo deforma simples, sem testes gratuitos de performance("benchmark"), detalhes específicos de certos programas eexceções raras.

As dicas que seguem, no geral podem ser usadas emqualquer tipo de programa ou linguagem, pois são detalhesconceituais e não dependentes de implementação.

Não complique

Ao construir uma ER, lembre-se que um dia alguém,provavelmente você mesmo, terá de dar manutenção a ela,para arrumar algum problema ou incrementá-la. Tendo issoem mente, evite fazer construções complicadasdesnecessariamente. Nem sempre a menor ER é a melhor,tudo vai depender do quão comentada ela está ou das

habilidades de quem for mantê-la. Vamos ver um exemplobem simples. Lembra na explicação do escape, quandovimos uma ER que casava um número de RG?

[0-9]\.[0-9]{3}\.[0-9]{3}-[0-9]

Note que o trecho para casar um ponto e três númerosseguidos \.[0-9]{3} se repete duas vezes, entãopodemos agrupá-lo e aplicar as chaves, diminuindo otamanho da ER:

[0-9](\.[0-9]{3}){2}-[0-9]



Note, porém, que nesse caso, essa "simplificação" daexpressão acabou ficando não tão simples assim, e exigeum pouco de reflexão até você pescar exatamente o queela faz. Foi vantagem ter diminuído seu tamanho? Isso équestionável, mas geralmente não. E aquela do mercado?

(mini|(su|hi)per)?mercado

Será que se a deixássemos mais simples, não ficaria maisfácil entendê-la? A mudança é pequena, mas veja como

visualmente fica mais agradável e fácil:

(mini|super|hiper)?mercado

Então muito cuidado ao colocar grupos dentro de grupos,

quantificar grupos, usar chaves quando se pode usar oasterisco, entre outros. Procure manter sua ER simples.

Use o circunflexo

Sempre que possível, comece sua ER com o circunflexo.Como já vimos, o robozinho vai tentando casá-la, caractere

por caractere, da esquerda para a direita, a partir docomeço da linha. Então, o ponto inicial de pesquisa, é ocomeço de linha.

Se você não coloca o circunflexo em sua ER, o robozinhotentará casá-la em qualquer parte da linha. Isso significa irvarrendo a linha, um por um, até chegar no final e caso

não encontre o padrão, retorna falha na pesquisa.



Se você coloca o circunflexo na sua ER, forçando ocasamento do começo de linha, se o primeiro componenteda ER após o ^ já não casar com o primeiro caractere dalinha, dali mesmo já retorna falha de pesquisa, semprecisar varrer o resto da linha.

Por exemplo, se você procura valores em reais "R$", podesimplesmente dizer R\$. Mas se você sabe que os reaisque lhe interessam estão sempre no começo da linha,digam isso com sua ER: ^R\$. Assim, em um exemplocomo:

R$ 200,00 : fósforos e velasessenciais na crise de energia.comprados das marcas mais baratas.

R$ 100,00 : caixas de ovos vazias

Ambas as ERs casam as linhas 1 e 4 imediatamente, poistêm o R$ já no começo. Mas nas linhas 2 e 3, onde não hánossos reais desejados, a primeira ER seria tentada emambas, em todas as posições, até o final, para ver quefalhou. Já a segunda, ao encontrar um espaço em brancono começo da linha, já retorna falha, pois ele não é um R.

Em um exemplo mais palpável, suponha que seu chefetenha uma mesa enorme, com oito gavetas. E se ele lhefalar: "Me traga a pasta verde, está na minha gaveta", ouentão "Me traga a pasta verde, que está na última gaveta.Na última hein? Não mexa nas outras!".



Evite a lista negada

A lista negada é um grande aliado quando não se sabeexatamente que tipo de dados estão em uma determinada

posição. Mas lembre-se: a tabela ASCII tem 255caracteres. Dizer algo como [^:] significa negar umcaractere e permitir outros 254, o que muitas vezes é umexagero. Essa abrangência toda pode trazer resultadosnegativos, casando partes incorretas. Sempre que possível,tente descobrir quais as possibilidades válidas de dados em

uma determinada posição e cadastre todas elas dentro deuma lista normal. Nesse exemplo, se o tipo de dados quenão pode ser os dois pontos forem letras, números ealguns símbolos, liste-os: [A-Za-z0-9,.()%!].

Assim, mais descritivo e preciso, se tiver algum caractereque não os listados, a ER vai falhar e você saberá que

alguém fez caca onde não devia. Do contrário, o erropassaria despercebido.

Evite o curinga

Quando pegamos o jeito com expressões regulares e as

usamos regularmente, é comum usar o .* para qualquersituação, pois como todo curinga que se preze, é uma mãona roda. Mas à medida que você vai usando ERs paracoisas mais complicadas e mais intensivamente, vocêcomeça a perceber que grande parte de seus problemas foiter usado o curinga guloso e genérico, onde você poderia

ter sido mais específico, e ele casou o que não devia.

Nem sempre é fácil trocar um curinga por outra coisa.Supõe-se que se você já o usou, é porque precisava de"qualquer coisa". Mas pare para pensar, esse qualquercoisa é realmente QUALQUER coisa? Lembre que isso émuito abrangente, o tudo e o nada. Não seria apenas"qualquer letra em qualquer quantidade" ou "quaisquercaracteres fora espaços em branco"?

Percebeu? As listas são nossa opção para tirar o curinga,trocando-o por algo não tão abrangente. Então, se em umtexto normal, você procura parte de uma frase, o restante

dela até o ponto final não diga que é .*\., mas [^.]*\. ,ou melhor: [A-Za-z ,]*\.. Isso evita de o curinga casaralém do ponto final da frase e ir até o ponto final doparágrafo. Lembra a nossa demonstração da gulodice emque o asterisco casou demais? Podemos evitar isso sendomais específicos em nossa ER. Em vez de dizer <.*>, ou

seja, uma marcação pode ter "qualquer coisa" antes do >,dizemos que pode ter "qualquer coisa fora o fechamento damarcação". Invocaremos a lista negada para nos ajudarnessa supertarefa, assim: <[^>]*> , ou mais visual:


...xxxxxxxxxxxxxx <.*>

...xxx.......xxxx <[^>]*>

Seja específico



E agora a regra de ouro, aquela que acaba resumindo asoutras, a mãe de todas: seja específico. Memorize bemisso: seja específico. De novo: seja específico.

Se você sempre tiver esta regra em mente ao construir

uma ER, as chances de falha ficam muito reduzidas. Osmetacaracteres são vários e servem para criarmos umuniverso de possibilidades para casarmos um texto, entãoo quente é fazer um universo restrito, onde todos oscomponentes fazem sua parte no todo, cada um com seupedacinho.

Algumas regrinhas e dicas de como ser específico já foramvistas, mas basicamente para isso, primeiro você devesaber exatamente que tipo de dados procura. Umconhecimento do trecho que se quer casar acontecequando se pode responder a estas três perguntas:

O que você quer casar? Em que quantidade? Em qual contexto ou posição?

Sabendo o que se quer, basta traduzir isso para uma ER,lembrando sempre de evitar generalizações como o ponto,o curinga, a lista negada, ignorar maiúsculas e minúsculas,

não usar âncoras. Sempre descreva em detalhes suasintenções, delimitando e especificando bem sua ER.

Em outras palavras, se você está com fome, não digasimplesmente "Quero uma pizza", diga: "Quero uma pizzade calabreza, sem cebola, tamanho médio, cortada em 8

pedaços e com borda de catupiry". Percebeu a diferença?



Não seja afobado, seja ninja

"Encere à direita, lixe à esquerda e pinte para cima e parabaixo."

Vamos ver uma maneira diferente e interessante demostrar exemplos de expressões regulares: mostrandocomo funciona o processo criativo, passo a passo. A arteninja milenar de criar ERs do nada, pela primeira vezdemonstrada.

Mentalizando seu objetivo (data, horário, e-

mail , número, telefone), comece a primeiratentativa tímida e abrangente, usando o ponto para seter um esqueleto genérico do que se quer casar. Teste a ERassim mesmo.

Deu certo? Então agora você trocará alguns dos pontospara ser mais específico, de acordo com as regras do tipo

de dado que você quer casar. E assim segue, devagar,sempre testando cada modificação e seguindo a passoscurtos, com modificações pequenas.

Ao chegar em um ponto onde já está bem específico,procure por alternativas, exceções, elas sempre existem.

Aquele trecho da ER é realmente obrigatório, não seriaopcional? E quando você acha que a ER está pronta, chegaum dado novo um pouquinho diferente e você vê que tinhaesquecido que aquilo também era válido. Para incrementara ER, suas armas são os grupos, o ou, o opcional e aschaves.



Quando sua ER ficar grande e cheia de alternativas, é sinalde que você está conseguindo dizer ao robozinhoexatamente o que quer. E assim é que se fazem ERscomplicadas Daniel San, de grão em grão!

Tolo daquele que senta e quer escrever o todo de uma vez!A arte de criar ERs deve ser sem pressa, e com inspiração.

"Dê um passo após o outro pequeno."

dd/mm/aaaa

../../....

[0-9]{2}/[0-9]{2}/[0-9]{4}[0123][0-9]/[0-9]{2}/[0-9]{4}[0123][0-9]/[01][0-9]/[0-9]{4}

[0123][0-9]/[01][0-9]/[12][0-9]{3}([012][0-9]|3[01])/[01][0-9]/[12][0-9]{3}([012][0-9]|3[01])/(0[1-9]|1[012])/[12][0-9]{3}(0[1-9]|[12][0-9]|3[01])/(0[1-9]|1[012])/[12][0-

9]{3}

hh:mm..:..

[0-9]{2}:[0-9]{2}[012][0-9]:[0-9]{2}[012][0-9]:[0-5][0-9]



([01][0-9]|2[0-3]):[0-5][0-9]

[email protected]

.*@.*

[^@]*@[^@]*[^@]+@[^@]+[A-Za-z0-9_.-]+@[A-Za-z0-9_.]+[A-Za-z0-9_.-]+@[A-Za-z0-9_]+\.[a-z]{2,3}

[A-Za-z0-9_.-]+@([A-Za-z0-9_]+\.)+[a-z]{2,3}[A-Za-z0-9_.-]+@([A-Za-z0-9_]+\.)+[A-Za-z]{2,3}[A-Za-z0-9_.-]+@([A-Za-z0-9_]+\.)+[A-Za-z]{2,4}

números

[0-9][0-9]+-?[0-9]+[-+]?[0-9]+[-+]?[0-9]+,[0-9]{2}[-+]?[0-9]+(,[0-9]{2})?

[-+]?[0-9]+\.[0-9]+(,[0-9]{2})?[-+]?[0-9]+\.[0-9]{3}(,[0-9]{2})?[-+]?[0-9]{3}\.[0-9]{3}(,[0-9]{2})?[-+]?[0-9]{1,3}\.[0-9]{3}(,[0-9]{2})?[-+]?[0-9]{1,3}(\.[0-9]{3})?(,[0-9]{2})?

telefone...-....



[0-9]{3}-[0-9]{4}[0-9]{4}-[0-9]{4}$..$[0-9]{4}-[0-9]{4}$..$ ?[0-9]{4}-[0-9]{4}

$0xx..$ ?[0-9]{4}-[0-9]{4}$0xx[0-9]{2}$ ?[0-9]{4}-[0-9]{4}($0xx[0-9]{2}$ ?)?[0-9]{4}-[0-9]{4}

Como lidar com ...

Esta seção nos traz várias táticas e dicas para tratarmos deproblemas genéricos e frequentes, que apesar de comuns,geram muitas dúvidas na hora de construir a ER.

Nada muito complicado, é simples até, mas são dicas quegeralmente a documentação dos programas não nos dá.

Ao contrário dos mandamentos anteriores, em que sua vidapode seguir tranqüila sem nunca conhecê-los, as dicas queseguem podem fazer a diferença de uma noite bem ou maldormida.

Problemas com maiúsculas e minúsculas

Verdade absoluta: as ERs são sensíveis a letras maiúsculase minúsculas, levando em conta sua diferença. Essedetalhe pode ajudar ou atrapalhar, dependendo da atençãodo criador da ER, ou da estabilidade dos dadospesquisados.



É muito comum às vezes, após meses de funcionamentosem problemas, uma ER falhar. Depois de quebrar acabeça nas partes mais complicadas dela, você percebeufoi uma falha simples de maiúsculas e minúsculas, poisuma parte de sua ER era o trecho jipe 4x4 e no textoagora estava jipe 4X4.

Este é um erro muito difícil de perceber, por ser tão triviale visualmente difícil de detectar, sobretudo se você estiversob pressão para "arrumar isso logo". Encontrado oproblema, usamos a lista para saná-lo: jipe 4[xX]4. Mas

um mês depois o texto muda novamente para Jipe 4X4, eassim vai... Como descobrir isso rapidamente?

Vários aplicativos e linguagens, como veremos adiante,têm modificadores para ignorar essa diferença entremaiúsculas e minúsculas ("ignore case"), e essa é nossachave de ouro para descobrir se o problema é esse.

É simples. Se há algo errado e você não sabe o que é, dêeste chute, colocando a opção de ignorar essa diferença eveja se o problema some. Se sim, bingo! Basta revisarcada parte de sua ER que contenha letras ou listas econfira o texto pesquisado para ver o que mudou.

Encontrado o problema, arrume-o e desligue a opção"ignorante". São várias letras? Nãotem [Pr][Rr][Oo][Bb][Ll][Ee][Mm][Aa]. Fica feio?Fica, mas é seguro, portanto desligue a opção.

Conclusão: ignore apenas se for algo temporário, para

testes, ou se você tem muita certeza do que está fazendo.



ERs pré-processadas e cruas

Algumas linguagens recebem a ER como um dado do tipo"string", e não simplesmente como uma ER pronta.

Essa string é primeiramente interpretada pela linguagem, esó depois é passada ao robozinho. Mas o que exatamenteisso quer dizer? Muitas coisas.

Primeiro, esse tratamento prévio não é algo específico dasERs, pois também acontece com qualquer string nalinguagem, seja para ecoar uma mensagem na tela, seja

para fazer indexação. Trechos da ER podem serconfundidos com variáveis e outras estruturas especiais,como, por exemplo, a ER $nome poderia ser expandidapara o conteúdo da variável $nome. Mas o que geralmentepega mesmo é a interpretação de escapes, incluindo osbarra-letras.

Isso nos afeta diretamente ao escrever uma ER, poisimagine que queremos casar um \t literal, entãoescapamos o escape: \\t. Mas ao receber essa string, alinguagem primeiro a interpreta, e quando vê dois escapesseguidos, o que faz? O troca por apenas um,

pois \\ representa um escape literal. Com isso nossorobozinho recebe a ER \t, que por sua vez seráinterpretado como um TAB literal e nossa busca falhará.Nesse caso, temos de prever o pré-processamento eescapar duplamente \\\\t, para que o robozinho recebao \\t que queríamos.



Felizmente, para que não precisemos ficar escapando tudoduplicado, a maioria dessas linguagens tem maneiras de seespecificar uma "string crua" ("raw string"), que não éinterpretada e é passada diretamente ao robozinho.Detalhes de como fazer isso estão no capítulo específico dacada linguagem, mais adiante. Mas essa característicatambém tem seu lado bom. Como alguns robozinhos nãosuportam os barra-letras, esse pré-processamento osreconhece e os converte, passando-os literais para o robô.

Concluindo, se a linguagem que você usa recebe as ERs

como strings, descubra como deixá-las cruas, ou fique comdor de cabeça de tanto escapar os escapes...

Negação de uma palavra

Vamos agora esclarecer um mito da mitologia ERística:

como negar uma palavra. Resposta:depende. Depende daposição dela na linha ou se seu aplicativo suporta osmetacaracteres modernosos. Por enquanto esquecendoestes, temos que o único metacaractere que proíbe algumacoisa é a lista negada, mas ela vale apenas para a posiçãode um caractere, não tendo como proibir uma palavra.

Intuitivamente e de sopetão, as tentativas de negar apalavra aqui poderiam ser coisas como:

[^aqui], (^aqui) e [^(aqui)]

O que, como sabemos, são inválidos pois o primeiro negaos quatro caracteres em qualquer ordem, para uma



posição, o segundo é um grupo que casa a palavra nocomeço da linha e o último é uma viagem astral,simplesmente negando todos os caracteres da lista, emqualquer ordem. O que fazer então? Se, e somente se apalavra sempre estiver no começo ou fim da linha, aâncora nos dá a base e podemos fazer uma seqüência delistas negadas de um caractere, completando a palavra,assim:

^[â][^q][û][î]

Mas como cada lista é independente uma da outra,qualquer uma que falhe é suficiente para falhar a ER toda.Isso significa que qualquer linha que comece coma, seja aonde, agora ou assim, falhará a primeira lista negada ecom ela toda a ER. Para lidar com isso, precisamos amarrar

a seqüência das letras, em uma ER gigante, feia e literal,mas que funciona:

^( [â] | a[^q] | aq[û] | aqu[î] )

Note que os espaços em branco foram colocados parafacilitar a leitura apenas, eles não fazem parte da ER.Vamos fazer a leitura dela para clarificar. A primeira letrada linha não pode ser um a . Se for, este não pode serseguido de um q. Se for, este aq não pode ser seguido porum u, mas caso seja, em hipótese alguma a próxima pode

ser um i. Se for, falhou a ER e conseguimos ignorar a



palavra aquino começo da linha. Ufa! Se a palavra fosse nofim da linha, basta usar o cifrão, aliás, acho que nemprecisava falar isso né? E se você não quisesse apalavrachato também?

^([â]|a[^q]|aq[û]|aqu[î]|[^c]|c[^h]|ch[â]|...)

E assim vai, podendo ficar quilométrica. Mas funciona. Sefor no meio da linha, esqueça, pois qualquer linha casará,mesmo as que contenham a palavra proibida. Tome como

exemplo a frase "o aqui é proibido.". Aplicando a ERquilométrica apresentada, mesmo sem a âncora ela casano começo da linha na maior cara-de-pau:

o aqui é proibido.xxxx

Então a ER casa o aq, considerando a frase válida e o queera para ser proibido, passou... O motivo é simples e esseproblema nunca terá solução, pois as ERs são orientadas acaracteres e repetições para casar um texto. O que

precisaríamos aqui é algo que não case caracteres emseqüência, sob qualquer contexto. As ERs não foram feitaspara isso.

Mas como não poderia deixar de ser, esta regra tambémtem uma exceção. Legal né? Você se lembra do tópico dosmetacaracteres modernosos? Mais especificamente

o (?!...). No nosso exemplo em questão, a ER



ficaria (?!aqui), pois esse metacaractere fará a ER falharcaso encontre um aqui na linha.

Para ficar mais simples, você pode considerar essaconstrução uma "lista negada de ERs", que casa qualquer

coisa fora o que casar a ER contida. Em nosso caso as EReram apenas caracteres literais, mas poderia ser uma ERtão complicada quanto se precise. Levando-se isso emconta, fica aqui nossa conclusão:

Multilinha

Algumas linguagens possuem modificadores para que suaER consiga lidar com um texto de várias linhas. Geralmentesão dois os modificadores, um para tratar estas váriaslinhas como apenas uma, em que o metacaractere pontotambém casa o \n(quebra de linha), e outra complementarpara tratar como várias linhas, onde o circunflexo e o cifrão

podem casar começo e final de qualquer uma dessas linhascontidas no texto, chamado multilinha. Vejamos:

$a = $b = $c = "linha 1\nlinha 2\nlinha 3";$a =~ s/^.*/!!/g ; print "$a\n-------\n";$b =~ s/^.*/!!/gs; print "$b\n-------\n";

$c =~ s/^.*/!!/gm; print "$c\n-------\n";

# RESULTADO (normal, uma linha, multilinha)



!!linha 2linha 3!!

!!!!!!

Ah, nada como um exemplo para ilustrar conceitos... Esse

trecho em Perl casa a ER ^.* no texto de três linhas,fazendo substituições globais (modificador g), primeironormal, depois com o modificador uma linha, e depois omultilinha.

Como era de se esperar, o primeiro, como não sabe o que

é multilinha casou apenas a primeira e não tocou nasoutras linhas.

O segundo, como o ponto casa a quebra de linha,considerou o texto todo como apenas uma única linha ecasou tudo, trocando todas por apenas um !!.

Já o último, que é multilinha, considerou o \n o fim de umalinha e casou as três linhas separadamente.

Acentuação

Use classes POSIX. Use \w. Ponto final.



Maaaaaaas se seu aplicativo não reconhece ambos, ou seusistema não está configurado para a localidade correta, háum remendo que não é 100%, mas pode ajudar.

Você pode usar uma lista com um intervalo aproximado,

que pega todos os caracteres acentuados que queremos,porém traz consigo alguns lixinhos no meio.

Confira na tabela ASCII no fim do guia, que podemos usaro intervalo À-ú para englobar todos os acentuados, ouainda À-Ú e à-ú caso se queria só maiúsculas ouminúsculas. Os lixos que ganhamos de brinde usando essesintervalos são coisas como "äåæËÎÏÐðÑ×÷ØÝÞß", mascomo eles não são muito comuns em nossos documentos,a princípio não há muito problema em utilizá-los.

Mas fique atento, se alguma coisa estiver errada pode serque por azar o texto contenha um desses caracteres, e

você não possa usar o remendo, mas é difícil. Então,vamos à listagem:

classe POSIX remendo [[:lower:]] [a-zà-ú][[:upper:]] [A-ZÀ-Ú]

[[:alpha:]] [A-Za-zÀ-ú][[:alnum:]] [A-Za-zÀ-ú0-9]

Liguagens de programação



Java *

Conteúdo exclusivo do livro Expressões Regulares - UmaAbordagem Divertida, disponível nas livrarias de todo país.

JavaScript

característica como fazerbusca métodos test, search, exec, matchsubstituição método replacedivisão método splitER crua /entre barras/ignore M/m modificador iglobal modificador g

O suporte a ERs no Javascript foi incluído nos doisnavegadores mais famosos desde as seguintesversões: Netscape 4.0x e Internet Explorer 4.0, e o nossopersonagem principal agora vai ser o objeto global RegExp.

Para definir uma ER no formato cru, basta colocá-la entre /barras/, e logo após a segunda barra, podemos colocar os

modificadores de maiúsculas e minúsculas e substituiçãoglobal, assim: /[a-z]/ig.

Para criar um objeto do tipo RegExp, basta definir umavariável com uma /ER/. O método test é um dos que fazema busca de padrões:

http://www.piazinho.com.br/








var er = /^[a-z]+$/i;if (er.test("JAVA")) alert("casou!");

Fácil, não? Então para complicar, se você quiser fazer umasubstituição, o métodoreplace deve ser usado. Detalhe: eleé um método de uma string e não de uma /ER/, masrecebe ERs. Não entendeu? Veja:

var eu = "estou com fome";document.write(eu.replace(/....$/, "sono"));

Em Javascript, temos uma simetria entre osobjetos regexp e string, com métodos de mesma função,mas nomes diferentes. Os "gêmeos siameses"sãotest e search para busca simples e exec e match para

busca com pescagem de dados. E lembre-se de que ummétodo regexp recebe como parâmetro umastring e vice-versa, veja:

regexp.test("string")string.search(/regexp/)

regexp.exec("string")string.match(/regexp/)

Cuidado para não confundir! Falando em confundir, vamosver o mais complicado de todos: o exec, que, além de fazero casamento, povoa uma matriz com vários dados que

podem ser recuperados posteriormente. Acompanhe o

exemplo a seguir e note que o matriz[1] é o similarJavascript para o retrovisor \1 :

var er = /^(\w+) (\w+)/;

var matriz = er.exec("um dois três");document.write(matriz.index, " ",

matriz.input, " ",matriz[0], " ",matriz[1], " ",matriz[2]);

//Resultado: // 0 // índice do casamento // um dois três // texto original // um dois // trecho casado // um // conteúdo do grupo 1 // dois // conteúdo do grupo 2

Mais informações podem ser encontradas em:http://www.webreference.com/js/column5 http://www.zdnet.com/devhead/stories/articles/0,4413,

2354285,00.html

VBscript

http://www.zdnet.com/devhead/stories/articles/0,4413,2354285,00.html



http://www.webreference.com/js/column5



característica como fazerbusca método Testsubstituição método Replacedivisão método Execute

ER crua -ignore M/m propriedade IgnoreCaseglobal propriedade Global

Demorou, mas em 1999 finalmente os usuários do Visual Basic® Scripting Editionpuderam experimentar o tão

desejado recurso de expressões regulares, implementadona versão 5.0 do Microsoft® Scripting Engines. O nome doobjeto que trata das expressões é RegExp, e para o alíviodos programadores, a sintaxe e a funcionalidade das ERsno VBScript são similares ao Perl, então não precisaaprender uma linguagem nova.

Assim, se na sintaxe da ER não há novidade, podemos nosconcentrar em como utilizar esse objeto. Dentro dele osmétodos que temos são Test e Execute para buscae Replace para substituições. Para ignorar maiúsculas eminúsculas e fazer substituições globais, temos as duaspropriedades booleanas IgnoreCase eGlobal, que devemser definidas como true para entrarem em ação.

Como peculiaridade, a ER não pode ser passadadiretamente ao método, ela precisa primeiro ser definidana propriedade Pattern . Vamos a um exemplo:



Dim er, textoSet er = new regexptexto = "visual"

er.Pattern = "^[A-Z]+$"er.IgnoreCase = true

if er.Test(texto) thenmsgbox ("casou!")

end if

Então instanciamos o objeto er e definimos um textoqualquer a ser casado. Depois definimos a ER, uma linhatoda de maiúsculas, na propriedade Pattern e ligamos aopção de "ignorância". Por fim, fazemos o Test da ER notexto. OReplace funciona de maneira similar, sem

surpresas.

O método Execute funciona como um split ao contrário, emque você informa o padrão e não o separador. Ele casa aER no texto e retorna todos os pedaços de texto em que aER casou de maneira organizada, seguindo uma hierarquia.Ele retorna um objeto "collection" chamado Matches que,por sua vez, contém zero ou mais objetos Match. Cada umdesses Match contém um pedaço casado, que além dotexto propriamente dito, também tem a posição de iníciodo casamento no texto original e o tamanho desse trecho.Vamos ver um exemplo que separa os trechos por espaçosem branco, com um diagrama de brinde no cabeçalho:



' --- hierarquia do Execute e seus objetos'' Execute' |

' Matches ---> Count, Item' |' Match ---> FirstIndex, Lenght, Value*'' * o Value é o padrão de acesso'

Dim er, texto

er = new regexp

texto = "um dois três"er.Pattern = "[^ ]+"

z = er.Execute(texto) 'retorna 3 objetos Match

for i = 0 to (z.Count - 1) 'para cada Match,msgbox z.Item(i) 'mostre o trecho casado

next

Você pode ter mais informações e exemplos em:

http://msdn.microsoft.com/scripting/vbScript/doc/vsob jRegExp.asp

http://msdn.microsoft.com/scripting/vbScript/doc/vscolMatches.asp

http://msdn.microsoft.com/scripting/vbScript/doc/vsob jMatch.asp

http://msdn.microsoft.com/scripting/vbScript/doc/vsobjRegExp.asp










http://msdn.microsoft.com/scripting/vbScript/doc/vsobjMatch.asp

http://msdn.microsoft.com/scripting/vbScript/doc/vsobjMatch.asp







Bibliotecas e programas relacionados

Todos os programas e bibliotecas listados aqui sãosoftwares completos e de código aberto, ou seja, você temacesso aos fontes e não precisa pagar para utilizá-los. E,

além de tudo, são de excelente qualidade.

Bibliotecas

O pacotão de funções para lidar com ERs nos programasem C tem duas versões: o regexoriginal de 1986 do HenrySpencer, atualizado

( ftp://ftp.zoo.toronto.edu/%2f/pub/regex.shar) e o rx daGNU (http://www.gnu.org/directory/rx.html). Essasbibliotecas são "plug'n'play", basta incluir o diretório com os fontes de seu programa, sem maiores traumas.Para java tem o jakartaregexp (http://jakarta.apache.org/regexp), um pacote

completo feito pela equipe de desenvolvimento do apache.

E para C++ tem abiblioteca Regexx (http://bazar.conectiva.com.br/~niemeyer/projects/regexx) que é uma solução completa comexecução, busca, substituição, divisão e fácil acesso aostextos casados.

Programas

O programa txt2regex (http://aurelio.net/txt2regex/) éum assistente ("wizard") que constrói ERs em que vocêapenas responde perguntas (em português inclusive) e aER vai sendo construída. Por conhecer metacaracteres dediversos aplicativos, também é útil para tirar dúvidas de

ftp://ftp.zoo.toronto.edu/%2f/pub/regex.shar








http://www.gnu.org/directory/rx.html

http://jakarta.apache.org/regexp

http://bazar.conectiva.com.br/~niemeyer/projects/regexx



http://aurelio.net/txt2regex/





http://jakarta.apache.org/regexp

http://www.gnu.org/directory/rx.html




sintaxe. E para fechar, o VisualREGEXP (http://laurent.riesterer.free.fr/regexp) quemostra graficamente, em cores distintas, cada parte da ERe o que ela casa em um determinado texto. Simples emuito útil, bom para iniciantes e ERs muito complicadas.

Onde obter mais informações

http://aurelio.net/regex/guia/.

No capítulo de cada linguagem de programação há dicas de

como encontrar mais informações. A documentação queacompanha cada aplicativo também pode ajudar bastante.Aqui seguem então dicas de informações relacionadas àsexpressões regulares em geral:

Livros

Não há dúvidas, sobre expressões regulares desde tópicossimples até os mais avançados e viajantes, com detalhesde funcionamento e testes de performance, leia a bíblia:"Mastering Regular Expressions", de Jeffrey E. F. Friedl(ISBN 1-56592-257-3). Outro livro que trata bem oassunto é "Programming Perl", de Larry Wall, Tom

Christiansen, e Randal L. Schwartz (ISBN 1-56592-149-6).Ambos são da editora O'Reilly (http://www.oreilly.com).

Para saber como funcionam internamente e como sãoimplementados os robozinhos, o assunto é "autômatosfinitos determinísticos e não-determinísticos", que constaem qualquer livro que explique como escrevercompiladores. A lista sed-br é sobre o sed, mas é aberta

http://laurent.riesterer.free.fr/regexp



http://aurelio.net/regex/guia/



http://www.oreilly.com/







para discussões gerais sobre ERs (em português). Para seinscrever, mande um e-mail para [email protected] ou visite a página comhistórico emhttp://br.groups.yahoo.com/group/sed-br.

Fora esta, temos outras listas nacionais sobre linguagens eeditores de texto em que dúvidas sobre como aplicar a ERneles podem ser sanadas:

http://groups.yahoo.com/group/perl-br http://groups.yahoo.com/group/vi-br http://groups.yahoo.com/group/emacs-br http://groups.yahoo.com/group/dsjava http://groups.yahoo.com/group/listadeweb http://lists.allfinder.com.br/php

Páginas aleatórias para ler com calma, infelizmente todasem inglês...

http://www.linux-learn.org/regexp.tut http://www.cs.rochester.edu/u/leblanc/csc173/fa /re.ht

ml http://news.tucows.com/ext2/99/10/articles/ext21031

1999.shtml http://www.phpbuilder.com/columns/dario19990616.p

hp3 http://www.zdnet.com/devhead/stories/articles/0,4413

,2266839,00.html

mailto:[email protected]



http://br.groups.yahoo.com/group/sed-br



http://groups.yahoo.com/group/perl-br




http://groups.yahoo.com/group/vi-br




http://groups.yahoo.com/group/emacs-br




http://groups.yahoo.com/group/dsjava








http://groups.yahoo.com/group/listadeweb




http://lists.allfinder.com.br/php

http://www.linux-learn.org/regexp.tut



http://www.cs.rochester.edu/u/leblanc/csc173/fa/re.html





http://news.tucows.com/ext2/99/10/articles/ext210311999.shtml





http://www.phpbuilder.com/columns/dario19990616.php3
















http://lists.allfinder.com.br/php









Aproveito este espaço para os agradecimentos:

Valeu mesmo!

bom-humor Julio Cezar Nevesincentivo Wanderlei Cavassin Osvaldo

Santanaapoio Família Conectivaoportunidade Editora Novatecmarcas do PM6 equipe do PageMaker®

Foram 96 horas prazerosas de escrita, corridas em doismeses, de um texto escrito do zero. Comoferramentas, o bom e velho vim, e os superconversoresde /texto/*estruturado* txt2{sgml,html} e txt2pagemaker que

foram subprodutos desse guia, me mostrando como iaficar o resultado final. Nada contra o produto daAdobe®, mas foi um prazer não ter digitado uma frasesequer nele graças a sua linguagem marcada.

Tabelas

Você deve estar se perguntando: "Mas por que esse caracolocou essas tabelas aqui no final?".

Bem, um guia de referência é para se encontrarrapidamente o que se procura, certo? Não é irritante ficarfolheando algo procurando uma tabela perdida em meio a



um texto? E quando tem, o índice das tabelas nunca nos dádescrições muito claras do conteúdo.

Então, por isso, elas estão todas aqui. Após a leitura, vocêvai jogar este livrinho em um canto e só vai vê-lo

novamente quando precisar tirar alguma dúvida quegeralmente está respondida em uma das tabelas. Nessahora de aperto basta ver as últimas páginas, simples comoexpressões regulares!

Guarde-as com carinho, mande para os amigos, grude emseu monitor ou mande ampliar e faça um quadro &:)

Resumo dos Metacaracteres e seus detalhes

. -ponto curinga de um caractere

[] -lista dentro todos são normais,traço é intervalo ASCII,[:POSIX:] tem acentuação

[^] lista negada sempre casa algo,[^[:POSIX:]]? opcional guloso, 0 ou 1, pode ter ou

não* asterisco guloso, 0 ou mais, repete em

qualquer quantidade+ mais guloso, 1 ou mais,

repete em qualquer quantidade, pelomenos uma vez

{,} chaves guloso, número exato, mínimo,



máximo, ou uma faixa numérica^ circunflexo casa o começo da linha,

especial no começo da ER$ cifrão casa o fim da linha,

especial no fim da ER\b borda limita uma palavra

(letras, números e sublinhado)\ escape escapa um meta, tira seu poder

escapa a si mesmo \\ | ou indica alternativas, poder

multiplicado pelo grupo

() grupo agrupa, é quantificado, podeconter outros grupos

\1 retrovisor usado com o grupo, máximo9, conta da esquerda para direita

.* curinga qualquer coisa, o tudo e o nada?? opcional não-guloso, 0 ou 1, casa o

mínimo possível*? asterisco não-guloso, 0 ou mais,

casa o mínimo possível+? mais não-guloso, 1 ou mais,

casa o mínimo possível{}? chaves não-guloso, numérico,

casa o mínimo possível

POSIX, barras-letras e outros



POSIX similar significa[:upper:] [A-Z] letras maiúsculas[:lower:] [a-z] letras minúsculas[:alpha:] [A-Za-z] maiúsculas e

minúsculas[:alnum:] [A-Za-z0-9] letras e números[:digit:] [0-9] números[:xdigit:] [0-9A-Fa-f] números hexadecimais[:punct:] [.,!?:...] caracteres de pontuação[:blank:] [ \t] espaço em branco e

TAB[:space:] [ \t\n\r\f\v] caracteres brancos[:cntrl:] - caracteres de controle[:graph:] [^ \t\n\r\f\v] caracteres imprimíveis[:print:] [^\t\n\r\f\v] imprimíveis e o espaço

b-l nome tradução\a alert alerta (bipe)\b backspace caractere Backspace\e escape caractere Esc\f form feed alimentação\n newline linha nova\r carriage ret retorno de carro\t htab tabulação horizontal\v vtab tabulação vertical

b-l POSIX equiv. mnemônico\d [[:digit:]] dígito\D [^[:digit:]] não-dígito



\w [[:alnum:]_] palavra\W [^[:alnum:]_] não-palavra\s [[:space:]] branco\S [^[:space:]] não-branco

b-l significado similar\a alfabeto [[:alpha:]]\A não alfabeto [^[:alpha:]]\h cabeça de palavra [[:alpha]_]\H não cab. de palavra [^[:alpha:]_]\l minúsculas [[:lower:]]

\L não minúsculas [^[:lower:]]\u maiúsculas [[:upper:]]\U não maiúsculas [^[:upper:]]\o número octal [0-7]\O não número octal [^0-7]\B não-borda

\A início do texto\Z fim do texto\l torna minúscula\L torna minúscula até \E\u torna maiúscula\U torna maiúscula até \E

\Q escapa até \E\E fim da modificação\G fim do casamento anterior

Modernos, alternativos e precedências

meta significado(?#texto) texto é um comentário(?:ER) grupo fantasma, retrovisor não conta(?=ER) casa se ER casar adiante ==(?!ER) casa se ER não casar adiante !=(?<=ER) casa se ER casar antes <--

(?<!ER) casa se ER não casar antes <--(?letra) letra é um modificador: imsxL(?{código}) executa código Perl(?(cond)s|n) if-then-else

classe POSIX remendo

[[:lower:]] [a-zà-ú][[:upper:]] [A-ZÀ-Ú][[:alpha:]] [A-Za-zÀ-ú][[:alnum:]] [A-Za-zÀ-ú0-9]

tipo de meta exemplo precedênciaquantificador ab+ maiorconcatenação ab médiaou ab|c menor

Webliografia



http://aurelio.net/

Agradecimentos

Esta obra é o resultado da experiência de pessoas, queacreditam que a melhor forma do conhecimento é oconhecimento compartilhado.

http://aurelio.net/

http://aurelio.net/

http://aurelio.net/

expressos regulares

Documents