Uma das coisas que sempre adorei no terminal Linux é o que pode ser feito usando expressões regulares. Quer precisemos encontrar um texto complicado ou substituí-lo por outra coisa, o uso de expressões regulares pode simplificar muito o trabalho. Vamos começar pelo começo:
O que é uma expressão regular?
Uma expressão regular é uma série de caracteres especiais que nos permitem descrever um texto que desejamos encontrar. Por exemplo, se quiséssemos pesquisar a palavra "linux" bastaria colocar essa palavra no programa que estamos usando. A própria palavra é uma expressão regular. Até agora parece muito simples, mas e se quisermos encontrar todos os números em um determinado arquivo? Ou todas as linhas que começam com letra maiúscula? Nesses casos, você não pode mais colocar uma palavra simples. A solução é usar uma expressão regular.
Expressões regulares vs. padrões de arquivo.
Antes de entrarmos no assunto das expressões regulares, quero esclarecer um mal-entendido comum sobre as expressões regulares. Uma expressão regular não é o que colocamos como parâmetro em comandos como rm, cp, etc. para nos referirmos a vários arquivos no disco rígido. Isso seria um padrão de arquivo. As expressões regulares, embora semelhantes por usarem alguns caracteres comuns, são diferentes. Um padrão de arquivo é disparado contra os arquivos no disco rígido e retorna aqueles que correspondem totalmente ao padrão, enquanto uma expressão regular é disparada contra um texto e retorna as linhas que contêm o texto pesquisado. Por exemplo, a expressão regular correspondente ao padrão *.* seria algo como ^.*\..*$
Tipos de expressões regulares.
Nem todos os programas usam as mesmas expressões regulares. Nem muito menos. Existem vários tipos mais ou menos padronizados de expressões regulares, mas existem programas que mudam ligeiramente a sintaxe, incluem suas próprias extensões ou mesmo usam caracteres completamente diferentes. Portanto, quando você quiser usar expressões regulares com um programa que você não conhece bem, a primeira coisa a fazer é olhar o manual ou a documentação do programa para ver como são as expressões regulares que ele reconhece.
Primeiro, existem dois tipos principais de expressões regulares, que estão contidos no padrão POSIX, que é o que as ferramentas do Linux usam. Eles são as expressões regulares básicas e estendidas. Muitos dos comandos que funcionam com expressões regulares, como grep ou sed, permitem que você use os dois tipos. Vou falar sobre eles abaixo. Existem também as expressões regulares do estilo PERL e, em seguida, existem programas como vim ou emacs que usam variantes destas. Dependendo do que queremos fazer, pode ser mais apropriado usar um ou outro.
Testando expressões regulares.
A sintaxe das expressões regulares não é nada trivial. Quando tivermos que escrever uma expressão regular complicada estaremos diante de uma string de caracteres especiais impossíveis de entender à primeira vista, portanto, para aprender a usá-los é essencial ter uma maneira de fazer todos os testes que queremos e ver os resultados facilmente. É por isso que agora vou colocar vários comandos com os quais podemos fazer os testes e experimentar tudo o que precisamos até ter as expressões regulares dominadas.
O primeiro é o comando grep. Este é o comando que usaremos com mais frequência para fazer pesquisas. A sintaxe é a seguinte:
grep [-E] 'REGEX' FICHERO
COMANDO | grep [-E] 'REGEX'
Eu recomendo sempre colocar expressões regulares entre aspas simples para que o shell não faça isso. A primeira maneira é localizar uma expressão regular em um arquivo. A segunda permite filtrar a saída de um comando por meio de uma expressão regular. Por padrão, grep usa expressões regulares básicas. A opção -E é para usar expressões regulares estendidas.
Um truque que pode nos ajudar a ver como as expressões regulares funcionam é habilitar o uso de cores no comando grep. Dessa forma, a parte do texto que corresponde à expressão regular que estamos usando será destacada. Para ativar a cor no comando grep, apenas certifique-se de que a variável de ambiente GREP_OPTIONS contém em valor --color, que pode ser feito com este comando:
GREP_OPTIONS=--color
Podemos colocá-lo no .bashrc para tê-lo sempre ativado.
Outra maneira de usar expressões regulares é usando o comando sed. É mais adequado para substituir texto, mas também pode ser usado para pesquisar. A sintaxe seria assim:
sed -n[r] '/REGEX/p' FICHERO
COMANDO | sed -n[r] '/REGEX/p'
O comando sed também usa expressões regulares básicas por padrão, você pode usar expressões regulares estendidas com a opção -r.
Outro comando que também quero nomear é awk. Este comando pode ser usado para muitas coisas, pois permite que você escreva scripts em sua própria linguagem de programação. Se o que queremos é encontrar uma expressão regular em um arquivo ou na saída de um comando, a forma de usá-la seria a seguinte:
awk '/REGEX/' FICHERO
COMANDO | awk '/REGEX/'
Este comando sempre usa expressões regulares estendidas.
Para fazer nossos testes também precisaremos de um texto que servirá de exemplo para buscá-lo. Podemos usar o seguinte texto:
- Lista de páginas wiki: ArchLinux: https://wiki.archlinux.org/ Gentoo: https://wiki.gentoo.org/wiki/Main_Page CentOS: http://wiki.centos.org/ Debian: https://wiki.debian.org/ Ubuntu: https://wiki.ubuntu.com/ - Fechas de lanzamiento: Arch Linux: 11-03-2002 Gentoo: 31/03/2002 CentOs: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntu: 20/10/2004 Desde Linux Rulez.
Este é o texto que usarei para os exemplos do resto do post, então recomendo que você copie em um arquivo para tê-lo acessível do terminal. Você pode colocar o nome que quiser. Eu chamei de regex.
Lição inicial.
Agora temos tudo o que precisamos para começar a testar as expressões regulares. Vamos aos poucos. Vou colocar vários exemplos de buscas com expressões regulares em que vou explicar para que serve cada caractere. Não são exemplos muito bons, mas como terei um post muito longo, não quero complicar mais. E vou apenas arranhar a superfície do que pode ser feito com expressões regulares.
O mais simples de tudo é pesquisar por uma palavra específica, por exemplo, suponha que desejamos pesquisar todas as linhas que contêm a palavra "Linux". Este é o mais fácil, pois só temos que escrever:
grep 'Linux' regex
E podemos ver o resultado:
arcoLinux: https://wiki.archlinux.org/ Arch Linux: 11-03-2002 De Linux Regraz.
Estas são as três linhas que contêm a palavra "Linux" que, se tivermos usado o truque de cores, aparecerá em destaque. Observe que ele reconhece a palavra que procuramos, mesmo que seja parte de uma palavra mais longa como em "ArchLinux". No entanto, não destaca a palavra "linux" que aparece na URL "https://wiki.archlinux.org/". Isso porque ele aparece lá com o "l" minúsculo e nós o procuramos em maiúsculas. O comando grep tem opções para isso, mas não vou falar sobre elas em um artigo sobre expressões regulares.
Com este teste simples, podemos tirar a primeira conclusão:
- Um caractere normal colocado em uma expressão regular corresponde a si mesmo.
O que quer dizer que se você colocar a letra "a", irá procurar a letra "a". Parece lógico, certo? 🙂
Agora, suponha que queremos pesquisar a palavra "CentO" seguida por qualquer caractere, mas apenas um único caractere. Para isso, podemos usar o caractere ".", Que é um curinga que corresponde a qualquer caractere, mas apenas um:
grep 'CentO.' regex
E o resultado é:
CentOS: http://wiki.centos.org/ centavos: 14-05-2004 03:32:38
O que significa que inclui o "S" em "CentOS", embora em um caso seja maiúsculo e em outro minúsculo. Se qualquer outro caractere aparecesse naquele lugar, também o incluiria. Já temos a segunda regra:
- O caráter "." corresponde a qualquer personagem.
Já não é tão trivial como parecia, mas com isso não podemos fazer muito. Vamos um pouco mais longe. Suponhamos que queremos encontrar as linhas em que aparecem os anos de 2002 e 2004. Parecem duas pesquisas, mas podem ser feitas ao mesmo tempo desta forma:
grep '200[24]' regex
O que significa que queremos encontrar o número 200 seguido por 2 ou 4. E o resultado é este:
ArchLinux: 11-03-2002 Gentoo: 31/03 /2002 CentOS: 14-05-2004 03:32:38 Ubuntu: 20/10/2004
O que nos leva à terceira regra:
- Vários caracteres entre colchetes correspondem a qualquer um dos caracteres entre colchetes.
Os colchetes oferecem mais jogo. eles também podem ser usados para excluir caracteres. Por exemplo, suponha que desejamos pesquisar sites onde o caractere ":" aparece, mas não é seguido por "/". O comando seria assim:
grep ':[^/]' regex
É simplesmente uma questão de colocar um "^" como o primeiro caractere dentro do colchete. Você pode colocar todos os personagens que quiser abaixo. O resultado deste último comando é o seguinte:
ArchLinux: https://wiki.archlinux.org/ Gentoo: https://wiki.gentoo.org/wiki/Main_Page CentOS: http://wiki.centos.org/ Debian: https://wiki.debian.org/ Ubuntu: https://wiki.ubuntu.com/ Arch Linux: 11-03-2002 Gentoo: 31/03/2002 CentOs: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntu: 20/10/2004
Agora, o ":" por trás dos nomes das distros são destacados, mas não os das URLs, porque as URLs têm "/" depois deles.
- Colocar o caractere "^" no início de um colchete corresponde a qualquer caractere, exceto aos outros caracteres do colchete.
Outra coisa que podemos fazer é especificar um intervalo de caracteres. Por exemplo, para pesquisar qualquer número seguido por "-", seria assim:
grep '[0-9]-' regex
Com isso, estamos especificando um caractere entre 0 e 9 e, em seguida, um sinal de menos. Vamos ver o resultado:
Arco Linux: 11-03-CentOs de 2002: 14-05-2004 03: 32: 38
Vários intervalos podem ser especificados dentro dos colchetes para até mesmo misturar intervalos com caracteres únicos.
- Colocar dois caracteres separados por "-" dentro dos colchetes corresponde a qualquer caractere dentro do intervalo.
Vamos ver agora se podemos selecionar a primeira parte dos URLs. Aquele que diz "http" ou "https". Eles diferem apenas nos "s" finais, então vamos fazer da seguinte maneira:
grep -E 'https?' regex
O ponto de interrogação é usado para tornar opcional o caractere à sua esquerda. Mas agora adicionamos a opção -E ao comando. Isso ocorre porque o interrogatório é um recurso das expressões regulares estendidas. Até agora estávamos usando expressões regulares básicas, então não precisamos inserir nada. Vamos ver o resultado:
ArchLinux: https: //wiki.archlinux.org/ Gentoo: https: //wiki.gentoo.org/wiki/Main_Page CentOS: http: //wiki.centos.org/ Debian: https: //wiki.debian.org/ Ubuntu: https: //wiki.ubuntu.com/
Portanto, já temos uma nova regra:
- Um caractere seguido por "?" corresponde a esse caractere ou a nenhum. Isso só é válido para expressões regulares estendidas.
Agora vamos encontrar duas palavras completamente diferentes. Vamos ver como encontrar as linhas que contêm as palavras "Debian" e "Ubuntu".
grep -E 'Debian|Ubuntu' regex
Com a barra vertical, podemos separar duas ou mais expressões regulares diferentes e encontrar as linhas que correspondem a qualquer uma delas:
Debian: https://wiki.debian.org/ Ubuntu: https://wiki.ubuntu.com/ Debian: 16 / 08 / 1993 Ubuntu: 20 / 10 / 2004
- O personagem «|» serve para separar várias expressões regulares e corresponder a qualquer uma delas. Também é específico para expressões regulares estendidas.
Vamos continuar. Agora vamos procurar a palavra "Linux", mas apenas onde ela não está presa a outra palavra à esquerda. Podemos fazer assim:
grep '\
O caractere importante aqui é "<", mas precisa ser escapado colocando "\" na frente dele para que grep o interprete como um caractere especial. O resultado é o seguinte:
arco Linux: 11-03-2002 De Linux Regraz.
Você também pode usar "\>" para pesquisar palavras que não estão próximas umas das outras. Vamos dar um exemplo. Vamos tentar este comando:
grep 'http\>' regex
A saída que ele produz é esta:
CentOS: http: //wiki.centos.org/
Saiu "Http", mas não "https", pois em "https" ainda há um caractere à direita do "p" que pode fazer parte de uma palavra.
- Os caracteres "<" e ">" correspondem ao início e ao final de uma palavra, respectivamente. Esses caracteres devem ser escapados para que não sejam interpretados como caracteres literais.
Vamos com as coisas um pouco mais complicadas. O caractere "+" corresponde ao caractere à sua esquerda, repetido pelo menos uma vez. Este caractere está disponível apenas com expressões regulares estendidas. Com ele podemos encontrar, por exemplo, sequências de vários números seguidos que começam com ":".
grep -E ':[0-9]+' regex
resultado:
CentOs: 14-05-2004 03: 32: 38
O número 38 também é destacado porque também começa com ":".
- O caractere "+" corresponde ao caractere à sua esquerda, repetido pelo menos uma vez.
Você também pode controlar o número de repetições usando "{" e "}". A ideia é colocar entre colchetes um número que indica o número exato de repetições que queremos. Você também pode colocar um intervalo. Vamos ver exemplos dos dois casos.
Primeiro, vamos encontrar todas as sequências de quatro dígitos que existem:
grep '[0-9]\{4\}' regex
Observe que você precisa escapar as chaves se estiver usando expressões regulares básicas, mas não se usar expressões estendidas. Com o extendido seria assim:
grep -E '[0-9]{4}' regex
E o resultado em ambos os casos seria este:
ArchLinux: 11-03-2002 Gentoo: 31/03 /2002 CentOS: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntu: 20/10 /2004
- Os caracteres "{" e "}" com um número entre eles correspondem ao caractere anterior repetido o número especificado de vezes.
Agora, o outro exemplo com as chaves. Suponha que queremos encontrar palavras que tenham entre 3 e 6 letras minúsculas. Podemos fazer o seguinte:
grep '[a-z]\{3,6\}' regex
E o resultado seria este:
- EUista de páginas wiki: PARArchLinux: https:/ /wiki.archlinux.org/ Gentão: https:/ /wiki.gentoo.org/wiki/Main_Pidade CentOS: http:/ /wiki.centos.org/ Debian: https:/ /wiki.debian.org/ ORfim da linha: https:/ /wiki.ubuntu.com/ - Fvocê sente falta de lançamento: PARArch Linux: 11-03-2002 Gentão: 31/03/2002 CentOs: 14-05-2004 03:32:38 Debian: 16/08/1993 Ufim da linha: 20/10/2004 Desde Linux Rulez.
Que, como você pode ver, não se parece muito com o que queríamos. Isso ocorre porque a expressão regular encontra as letras em outras palavras que são mais longas. Vamos tentar esta outra versão:
grep '\<[a-z]\{3,6\}\>' regex
resultado:
- Lista de páginas wiki: ArchLinux: https:/ /wiki.archlinux.org/ Gentoo: https:/ /wiki.gentoo.org/wiki/ Main_Page CentOS: http:/ /wiki.centos.org/ Debian: https:/ /wiki.debian.org/ Ubuntu: https:/ /wiki.ubuntu.com/
Isso já se parece mais com o que queríamos. O que fizemos foi exigir que a palavra comece logo antes da primeira letra e termine logo depois da última.
- Os caracteres "{" e "}" com dois números separados por vírgula correspondem ao caractere anterior repetido pelo número de vezes indicado pelos dois números.
Vejamos agora um caractere primo de "+". É "*" e sua operação é muito semelhante, apenas que corresponde a qualquer número de caracteres, incluindo zero. Ou seja, ele faz o mesmo que o "+", mas não exige que o caractere à sua esquerda apareça no texto. Por exemplo, vamos tentar procurar os endereços que começam no wiki e terminam na org:
grep 'wiki.*org' regex
Vamos ver o resultado:
ArchLinux: https: //wiki.archlinux.org/ Gentoo: https: //wiki.gentoo.org/ wiki / Main_Page CentOS: http: //wiki.centos.org/ Debian: https: //wiki.debian.org/
Perfeito.
Agora o último personagem que veremos. O caractere "\" é usado para escapar do caractere à sua direita, de modo que perca seu significado especial. Por exemplo: suponha que desejamos localizar as linhas que terminam em um ponto. A primeira coisa que nos pode ocorrer é:
grep '.$' regex
O resultado não é o que procuramos:
- Lista de páginas wiki: ArchLinux: https://wiki.archlinux.org/ Gentoo: https://wiki.gentoo.org/wiki/Main_Page CentOS: http://wiki.centos.org/ Debian: https://wiki.debian.org/ Ubuntu: https://wiki.ubuntu.com/ - Datas de lançamento: Arch Linux: 11-03-2002 Gentoo: 31/03/2002 CentOs: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntu: 20/10/2004 Desde Linux Regras.
Isso ocorre porque o "." corresponde a qualquer coisa, para que a expressão regular corresponda ao último caractere de cada linha, seja ela qual for. A solução é esta:
grep '\.$' regex
Agora o resultado é o que queremos:
Desde Linux Regras.
Game Over
Embora o assunto das expressões regulares seja tão complexo que eu daria para uma série de artigos, acho que já lhe dei bastante trabalho. Se você conseguiu chegar, parabéns. E se você leu tudo isso de uma vez, tome uma aspirina ou algo assim, porque não pode ser bom.
Por enquanto, isso é tudo. Se você gostou deste artigo, talvez possa escrever outro. Enquanto isso, recomendo que você experimente todas as expressões regulares no terminal para ver claramente como elas funcionam. E lembre-se: apenas Chuck Norris pode analisar HTML usando expressões regulares.
O que seria nossa vida sem o regex?
O artigo é muito útil, mas irei lê-lo aos poucos. Muito obrigado.
Obrigado por comentar. Ainda não acredito que meu artigo foi publicado. 🙂 Ocorreu um erro, mas espero que seja útil. 🙂
Obrigadassssssss! ..
Faz muito tempo que não tenho que estudar um pouco sobre expressões regulares .. ..Agradeço por ensinar .. e pelo guia passo a passo para aprender cada uma delas ..
Muito bom! .. .. Vou pegar aquela aspirina .. ee
De nada. Coragem e expressões regulares não podem com você. 🙂
Postagem fantástica! Grande trabalho. Eu me pergunto quantas horas você demorou 😀
Kkkkk!! A questão é: quantas horas teria levado se eu tivesse dito tudo o que pretendia dizer? Infinito !! 🙂
uma coisa que eu não sabia, bom artigo!
Obrigado. É um prazer compartilhar com você.
ótima explicação. parabéns! muito útil!
Estou feliz que você achou útil. Portanto, é um prazer escrever.
Isso deve ir para algum lugar especial. Gosta do destaque, mas tem uma utilidade muito específica. Muito útil, embora eu gostaria de ver aplicado ao Vim.
É uma questão de me perguntar. Tenho mais alguns artigos sobre expressões regulares em mente. E eu poderia falar sobre o vim neles. Tem algumas diferenças em relação ao que expliquei neste artigo. É uma questão de seguir em frente. 🙂
Good!
Seu artigo é muito bom, é curioso, recentemente (agora) publiquei em meu site um verbete que vinha preparando há alguns dias onde coletei uma lista de metacaracteres para expressões regulares e alguns exemplos. E foi justo entrar DesdeLinux e veja uma entrada sobre o mesmo tópico!
Se serve de consolo, o meu é MUITO MAIS BICHANO 😀
Certamente regex é uma das coisas mais úteis, eu geralmente os uso para cortar a saída dos comandos e manter a parte que me interessa, e então interagir com ela em um script bash, por exemplo. Também os usei muito na universidade e são de vital importância na construção de compiladores (na definição de lexicográficos e analisadores). Em suma, um mundo inteiro.
Saudações e um trabalho muito bom.
Muito obrigado.
Eu também gostei do seu artigo. É mais conciso do que o meu. Pode servir como uma referência rápida. É uma coincidência que os tenhamos escrito ao mesmo tempo. Você pode ver que as pessoas estão interessadas no assunto. 🙂
Expressões regulares para dummies =), agora está mais claro para mim, a propósito, uma maneira de ter a saída com cor para grep é criando um alias em .bashrc alias grep = 'grep –color = always', caso funcione para alguém .
lembranças
Verdadeiro. Essa é outra maneira de fazer isso. Obrigado pela contribuição. 🙂
O_O… contribuição !!! O_O ...
Muito obrigado pelo post, fiquei um tempo esperando algo assim hahaha, já deixo aberto para ler com calma em casa sem nenhum incômodo para me concentrar hahaha.
Obrigado pelo artigo, realmente 😀
Eu sabia que você gostaria. RI MUITO!! A verdade é que faltam muitas coisas, mas já tenho uma segunda parte em mente. 🙂
Ótimo artigo, se eu tivesse lido ontem, a aula que dei hoje teria sido ainda mais fácil para meus alunos!
RI MUITO!! Que pena que estava atrasado, mas feliz por ter ajudado. 🙂
Finalmente !!!, super bom o post .... Finalmente encontrei algo que explica claramente as expressões regulares ...
Existem muitas informações por aí, mas é mais difícil encontrar algo que seja fácil de entender. Estou feliz por ter preenchido essa lacuna. 🙂
Saudações.
Ei, preciso de ajuda, tenho que fazer uma pesquisa em / var / logs com o formato: yymmdd, e os logs vêm assim 130901.log -130901.log, tenho que pesquisar todos aqueles que estão entre 1 de setembro a 11 de outubro, A única coisa que consegui fazer foi remover todo o mês de setembro, mas não sei como fazer a corrente completa:
ex: 1309 [0-3] me retorna os registros entre 1º de setembro a 30 de setembro, mas não sei como entrar na mesma cadeia de 1º a 11 de outubro.
Fazer isso usando expressões regulares é um pouco complicado. Ocorre-me que algo assim pode funcionar:
13(09[0-3]|10(0|1[01]))
É uma expressão regular estendida. Você não diz qual ferramenta está usando, então não posso dar mais detalhes.
De qualquer forma, acho que esse é o caso, em vez de usar expressões regulares, é melhor fazê-lo com find. Você pode tentar algo assim:
encontrar. -newermt '01 sep '-a! -newermt '11 out '-print
Sorte. Espero que sirva.
Olá! Em primeiro lugar, gostaria de agradecer o seu trabalho, pois esta página está dentro do meu "top 3" dos melhores sites Linux.
Eu estava praticando e não sabia porque um RegExp em um número de telefone não funcionava para mim e era que estava faltando o "-E" (que percebi graças a este post).
Queria perguntar se você não conhece nenhum bom pdf ou site onde existam exercícios no RegExp, embora com um pouco de imaginação você possa praticar inventando-os sozinho.
Saudações, Pablo.
Muito bom, acabei de ler tudo e agora preciso de uma aspirina 🙂
A melhor explicação que já vi das expressões regulares. Meus agradecimentos ao autor por compartilhar este trabalho.
Uma saudação.
Eu realmente gostei de uma explicação muito boa