Post

Guia Completo: Expressões Regulares no Linux com Ferramentas de Linha de Comando

Aprenda a utilizar expressões regulares no Linux com ferramentas essenciais como grep, sed, awk, e find. Descubra como automatizar buscas e manipulações de texto com exemplos práticos e detalhados.

Posted Updated
By Gean Martins
31 min read
Guia Completo: Expressões Regulares no Linux com Ferramentas de Linha de Comando

Sumário

  1. Introdução ao Uso de Expressões Regulares
  2. Meta Caracteres
  3. Âncoras
  4. Representantes
  5. Quantificadores
  6. POSIX e Expressões Regulares Estendidas (ER)
  7. Usando o AWK com Expressões Regulares
  8. Usando o SED com Expressões Regulares
  9. Usando o GREP, EGREP e FGREP com Expressões Regulares
  10. Usando o FIND com Expressões Regulares
  11. Conclusão

1. Introdução ao Uso de Expressões Regulares

Objetivo

Nesta seção, vamos introduzir o conceito de expressões regulares (regex) e entender sua aplicação em buscas e manipulações de texto no Linux. Vamos explorar como regex é utilizado para realizar filtros e padrões específicos em diferentes arquivos e textos.

O Que São Expressões Regulares?

As expressões regulares, ou regex, são sequências de caracteres que formam um padrão de busca. Esse padrão permite realizar buscas e substituições precisas em grandes volumes de texto ou em arquivos específicos. No Linux, regex é amplamente suportado por várias ferramentas de linha de comando, como grep, sed, awk, find, entre outras.

Principais Aplicações de Regex

  • Buscar padrões específicos em arquivos de texto, como endereços de e-mail, números de telefone, datas, etc.
  • Filtrar resultados de busca para encontrar correspondências exatas.
  • Substituir texto de maneira automatizada e rápida.
  • Processar e manipular arquivos de texto, especialmente em análise de logs e dados de grande volume.

Ferramentas que Suportam Regex no Linux

Algumas das ferramentas mais comuns que suportam regex incluem:

  • grep: Realiza buscas de texto em arquivos com base em padrões regex.
  • sed: Editor de texto de fluxo que utiliza regex para substituições e edições de texto.
  • awk: Linguagem de programação para processamento de texto, capaz de usar regex em buscas e filtros.
  • find: Utiliza regex para localizar arquivos e diretórios específicos.

Começando a Escrever e Testar Expressões Regulares

Para começar a testar regex, uma boa abordagem é usar o comando grep para buscar padrões em um arquivo ou diretamente em um texto.

Exemplo 1: Procurando Palavras Específicas

No exemplo a seguir, procuramos por uma palavra específica dentro de um arquivo:

1

echo "Este é um teste de regex no Linux" | grep "teste"

Exemplo 2: Procurando Padrões Simples

Você pode usar regex para encontrar padrões complexos em arquivos. Por exemplo, para encontrar todas as linhas de um arquivo documento.txt que contenham números, você pode usar:

1

grep '[0-9]' documento.txt

Práticas Recomendadas ao Trabalhar com Regex

  1. Comece com Padrões Simples: Entenda como o regex básico funciona antes de avançar para padrões mais complexos.
  2. Use Ferramentas Interativas: Ferramentas como o grep, sed e awk permitem testar e ajustar expressões regulares facilmente.
  3. Conheça as Variantes de Regex: No Linux, você pode encontrar variações, como regex básico (usado em grep) e regex estendido (usado em egrep).

2. Meta Caracteres

Objetivo

Compreender os meta caracteres das expressões regulares e seu uso em diferentes contextos para realizar buscas precisas no Linux. Vamos explorar como cada um funciona e aplicar exemplos práticos de busca.

O Que São Meta Caracteres?

Os meta caracteres são símbolos especiais usados nas expressões regulares que representam ações específicas. Eles permitem que regex seja mais flexível e poderoso, permitindo buscar padrões complexos com eficiência.

Principais Meta Caracteres e Suas Funções

Meta CaractereDescriçãoExemplo de Uso
.Representa qualquer caractere individual (exceto nova linha).g.e encontra “gato”, “gite”, “gipe”.
*Indica zero ou mais ocorrências do caractere anterior.a* encontra “a”, “aa”, ou ausência de “a”.
+Indica uma ou mais ocorrências do caractere anterior.a+ encontra “a”, “aa”, mas não ausência de “a”.
[ ]Conjunto de caracteres. Busca qualquer caractere especificado dentro dos colchetes.[abc] encontra “a”, “b”, ou “c”.
( )Agrupa caracteres. Usado para delimitar partes de um padrão.(ab)+ encontra “ab”, “abab”, “ababab”.
|Operador de alternância. Busca padrões alternativos (OR).carro|moto encontra “carro” ou “moto”.
\Caracter de escape. Indica que o próximo caractere deve ser interpretado literalmente.\$ encontra o símbolo “$”.

Exemplos Práticos de Meta Caracteres

  1. Usando o Ponto (.) para Encontrar Qualquer Caractere

    O ponto . representa qualquer caractere. No exemplo a seguir, ele é usado para buscar palavras que começam com “c” e terminam com “r”, com qualquer caractere entre elas:

    1

    echo -e "caro\ncair\ncor" | grep 'c.r'

    Resultado:

    1
2

    caro
cor

  2. Usando o Asterisco (*) para Zero ou Mais Ocorrências

    O asterisco * representa zero ou mais ocorrências do caractere anterior. No exemplo, ele encontra todas as palavras que contêm “ab”, seguido de zero ou mais letras “c”:

    1

    echo -e "abc\nabcc\nabccc\nab" | grep 'abc*'

    Resultado:

    1
2
3

    abc
abcc
abccc

  3. Usando o Mais (+) para Uma ou Mais Ocorrências

    O sinal + indica uma ou mais ocorrências do caractere anterior. No exemplo, ele busca “ab” seguido de uma ou mais letras “c”:

    1

    echo -e "abc\nabcc\nabccc\nab" | grep -E 'abc+'

    Resultado:

    1
2
3

    abc
abcc
abccc

  4. Usando Colchetes ([ ]) para Conjunto de Caracteres

    Os colchetes [ ] permitem especificar um conjunto de caracteres. No exemplo, ele encontra palavras que contêm qualquer letra entre “a” e “c”:

    1

    echo -e "ana\nbob\ncat\ndog" | grep '[abc]'

    Resultado:

    1
2
3

    ana
bob
cat

  5. Usando Parênteses (( )) para Agrupamento

    Os parênteses agrupam partes da expressão para aplicar operadores em conjunto. No exemplo, ele encontra uma ou mais ocorrências da sequência “ab”:

    1

    echo -e "ab\nabab\nababab\nac" | grep -E '(ab)+'

    Resultado:

    1
2

    abab
ababab

  6. Usando o Operador Alternativo (|)

    O operador | representa uma alternativa (OR) entre padrões. No exemplo, ele encontra linhas que contêm “cão” ou “gato”:

    1

    echo -e "cão\ngato\npássaro" | grep 'cão|gato'

    Resultado:

    1
2

    cão
gato

  7. Usando a Barra Invertida (\) para Escapar Caracteres Especiais

    A barra invertida \ é usada para indicar que o próximo caractere deve ser interpretado literalmente. Por exemplo, para buscar o símbolo $:

    1

    echo -e "valor1$\nvalor2\nvalor3$" | grep '\$'

    Resultado:

    1
2

    valor1$
valor3$

Prática Recomendada

  • Teste Cada Meta Caractere Separadamente: Familiarize-se com o comportamento de cada meta caractere antes de combiná-los.
  • Combine Caracteres para Busca Complexa: À medida que ganhar confiança, experimente combinar os meta caracteres para criar padrões mais complexos.

3. Âncoras

Objetivo

Aprender a usar âncoras nas expressões regulares para limitar buscas a posições específicas em uma linha, como o início ou o fim. Isso é muito útil para realizar buscas precisas e filtrar texto de maneira mais eficiente.

O Que São Âncoras?

As âncoras são símbolos usados nas expressões regulares para indicar uma posição específica em uma linha de texto. Elas não correspondem a caracteres reais, mas sim a posições, como o início ou o fim de uma linha. As âncoras mais comuns são:

  • ^: Início de linha
  • $: Fim de linha

Principais Âncoras e Suas Funções

ÂncoraDescriçãoExemplo de Uso
^Limita a busca ao início da linha.^A encontra linhas que começam com “A”.
$Limita a busca ao fim da linha.z$ encontra linhas que terminam com “z”.

Exemplos Práticos de Uso de Âncoras

  1. Usando ^ para Encontrar Palavras no Início da Linha

    O símbolo ^ é usado para limitar a busca ao início da linha. No exemplo abaixo, ele busca linhas que começam com a palavra “início”:

    1

    echo -e "início de uma linha\nfim de outra linha" | grep '^início'

    Resultado:

    1

    início de uma linha

  2. Usando $ para Encontrar Palavras no Fim da Linha

    O símbolo $ limita a busca ao final da linha. No exemplo, ele encontra linhas que terminam com a palavra “fim”:

    1

    echo -e "linha no início\noutra no fim" | grep 'fim$'

    Resultado:

    1

    outra no fim

  3. Combinando ^ e $ para Buscar Linhas Específicas

    Ao usar ^ e $ juntos, é possível buscar uma linha exata. O exemplo abaixo busca linhas que contêm apenas a palavra “exata”:

    1

    echo -e "exata\nexata mesmo\nquase exata" | grep '^exata$'

    Resultado:

    1

    exata

  4. Buscando Palavras que Aparecem no Início e Fim da Linha

    Usando âncoras, você pode encontrar palavras em posições específicas. No exemplo a seguir, buscamos palavras que começam com “A” e terminam com “a”:

    1

    echo -e "Ana\nAmiga\nAmor\naula" | grep '^A.*a$'

    Resultado:

    1

    Ana

  5. Filtrando Linhas Vázias

    Para encontrar linhas vazias em um arquivo, usamos ^$, que indica o início e o fim da linha sem conteúdo no meio:

    1

    echo -e "linha 1\n\nlinha 2" | grep '^$'

    Resultado:

    1

    (linha vazia)

Tabela: Resumo de Âncoras Comuns em Expressões Regulares

ÂncoraDescriçãoExemplo
^Início de linha^início para buscar o início.
$Fim de linhafim$ para buscar o final.
^$Linha vazia^$ para encontrar linhas vazias.

Exercícios Práticos com Âncoras

  1. Buscar Linhas que Começam com um Número

    Busque linhas em um arquivo que comecem com um número:

    1

    grep '^[0-9]' arquivo.txt

  2. Encontrar Linhas que Terminam com uma Letra Específica

    Encontre todas as linhas que terminam com “s”:

    1

    grep 's$' arquivo.txt

  3. Verificar Linhas Vázias

    Verifique se há linhas vazias em um arquivo de texto:

    1

    grep '^$' arquivo.txt

Dicas de Prática

  • Combine Âncoras com Meta Caracteres: Usar âncoras junto com outros meta caracteres, como * e ., permite buscas mais precisas.
  • Âncoras para Validação de Padrões: Âncoras são ideais para validar entradas que precisam ter um formato específico, como linhas que começam com um prefixo específico ou terminam com um sufixo.

4. Representantes

Objetivo

Nesta seção, vamos explorar o uso de representantes (ou classes de caracteres) em expressões regulares. Eles permitem especificar conjuntos ou intervalos de caracteres e são úteis para definir padrões complexos e altamente personalizados em buscas de texto.

O Que São Representantes?

Os representantes são caracteres e símbolos que permitem a definição de conjuntos de caracteres dentro de uma expressão regular. Em vez de especificar cada caractere individualmente, podemos definir um conjunto ou intervalo, tornando as buscas mais flexíveis e eficientes.

Principais Representantes de Caracteres

RepresentanteDescriçãoExemplo de Uso
[abc]Corresponde a qualquer caractere entre “a”, “b” e “c”.[aeiou] encontra qualquer vogal.
[a-z]Corresponde a qualquer caractere minúsculo entre “a” e “z”.[0-9] encontra qualquer dígito.
[^ ]Exclui caracteres. Corresponde a qualquer caractere exceto os especificados.[^aeiou] exclui vogais.
[A-Z]Corresponde a qualquer caractere maiúsculo entre “A” e “Z”.[A-Z] encontra letras maiúsculas.
[a-zA-Z0-9]Corresponde a qualquer letra ou número (intervalo alfanumérico).[a-zA-Z0-9] encontra letras e números.

Exemplos Práticos de Representantes

  1. Encontrar Qualquer Vogal

    No exemplo abaixo, usamos [aeiou] para encontrar qualquer vogal em uma sequência de palavras:

    1

    echo -e "casa\nmesa\nporta" | grep '[aeiou]'

    Resultado:

    1
2
3

    casa
mesa
porta

  2. Encontrar Qualquer Dígito

    Para localizar qualquer número em uma sequência de texto, usamos [0-9]:

    1

    echo -e "abc123\n456def\nxyz789" | grep '[0-9]'

    Resultado:

    1
2
3

    abc123
456def
xyz789

  3. Excluir Conjuntos Específicos com [^ ]

    O uso de [^ ] permite excluir caracteres específicos. No exemplo, excluímos todas as vogais:

    1

    echo -e "casa\nmesa\nporta" | grep '[^aeiou]'

    Resultado:

    1
2
3

    casa
mesa
porta

  4. Buscar Letras Maiúsculas

    Para localizar palavras que contenham letras maiúsculas, podemos usar [A-Z]:

    1

    echo -e "Casa\nmesa\nPorta" | grep '[A-Z]'

    Resultado:

    1
2

    Casa
Porta

  5. Buscar Letras e Números em uma Única Expressão

    Para localizar caracteres alfanuméricos (letras e números), usamos [a-zA-Z0-9]:

    1

    echo -e "abc123\n456DEF\n!@#" | grep '[a-zA-Z0-9]'

    Resultado:

    1
2

    abc123
456DEF

Tabela de Representantes Comuns em Expressões Regulares

RepresentanteDescriçãoExemplo de Uso
[aeiou]Qualquer vogal[aeiou]
[0-9]Qualquer dígito de 0 a 9[0-9]
[A-Z]Qualquer letra maiúscula[A-Z]
[a-zA-Z0-9]Qualquer caractere alfanumérico[a-zA-Z0-9]
[^aeiou]Exclui caracteres (não-vogais)[^aeiou]

Exercícios Práticos com Representantes

  1. Encontrar Linhas com Letras Maiúsculas

    Use [A-Z] para encontrar linhas que contêm pelo menos uma letra maiúscula:

    1

    grep '[A-Z]' arquivo.txt

  2. Buscar Números Telefônicos

    Para localizar números de telefone no formato “(XX) XXXX-XXXX”, use [0-9] para capturar cada dígito:

    1

    grep '[(][0-9][0-9][)] [0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9]' arquivo.txt

  3. Excluir Linhas com Vogais

    Para encontrar linhas que não contenham nenhuma vogal, use [^aeiouAEIOU]:

    1

    grep '^[^aeiouAEIOU]*$' arquivo.txt

Dicas de Prática

  • Combine Representantes e Âncoras: Combine representantes com âncoras ^ e $ para buscas precisas em posições específicas da linha.
  • Use Intervalos com Cuidado: Definir intervalos como [a-zA-Z] pode incluir caracteres que não são esperados. Teste bem as expressões regulares para garantir que capturam exatamente o que deseja.

5. Quantificadores

Objetivo

Nesta seção, vamos aprender como os quantificadores permitem controlar o número de ocorrências de um caractere ou grupo em expressões regulares. Isso é útil para ajustar as buscas a padrões que aparecem um número específico de vezes.

O Que São Quantificadores?

Os quantificadores indicam a quantidade de ocorrências de um caractere ou padrão que devem ser consideradas em uma expressão regular. Eles tornam as expressões regulares mais flexíveis, permitindo capturar padrões com diferentes frequências de repetição.

Principais Quantificadores e Suas Funções

QuantificadorDescriçãoExemplo de Uso
*Zero ou mais ocorrências do caractere anterior.a* encontra “”, “a”, “aaa”.
+Uma ou mais ocorrências do caractere anterior.a+ encontra “a”, “aaa”.
?Zero ou uma ocorrência do caractere anterior.a? encontra “” ou “a”.
{n}Exatamente n ocorrências do caractere anterior.a{3} encontra “aaa”.
{n,}n ou mais ocorrências do caractere anterior.a{2,} encontra “aa”, “aaa”.
{n,m}Entre n e m ocorrências do caractere anterior.a{1,3} encontra “a”, “aa”, “aaa”.

Exemplos Práticos de Uso dos Quantificadores

  1. Usando * para Zero ou Mais Ocorrências

    O quantificador * encontra zero ou mais ocorrências do caractere anterior. No exemplo, ele busca linhas com zero ou mais “a” seguidos por “b”:

    1

    echo -e "b\nab\naab" | grep 'a*b'

    Resultado:

    1
2
3

    b
ab
aab

  2. Usando + para Uma ou Mais Ocorrências

    O quantificador + busca uma ou mais ocorrências do caractere anterior. No exemplo, ele localiza “b” precedido de uma ou mais letras “a”:

    1

    echo -e "b\nab\naab" | grep -E 'a+b'

    Resultado:

    1
2

    ab
aab

  3. Usando ? para Zero ou Uma Ocorrência

    O quantificador ? busca zero ou uma ocorrência do caractere anterior. No exemplo, ele encontra “cor” e “cores”, já que “s” é opcional:

    1

    echo -e "cor\ncores\ncorar" | grep 'cores?'

    Resultado:

    1
2

    cor
cores

  4. Usando {n} para Exatamente n Ocorrências

    O quantificador {n} encontra exatamente n ocorrências do caractere anterior. No exemplo, ele busca exatamente duas letras “a” seguidas de “b”:

    1

    echo -e "ab\naab\naaab" | grep 'a{2}b'

    Resultado:

    1

    aab

  5. Usando {n,} para n ou Mais Ocorrências

    Com {n,}, o regex busca n ou mais ocorrências do caractere anterior. No exemplo, ele encontra “b” precedido de duas ou mais letras “a”:

    1

    echo -e "ab\naab\naaab" | grep 'a{2,}b'

    Resultado:

    1
2

    aab
aaab

  6. Usando {n,m} para Entre n e m Ocorrências

    O quantificador {n,m} define uma faixa de ocorrências. No exemplo, ele encontra “b” precedido de uma a três letras “a”:

    1

    echo -e "ab\naab\naaab\naaaab" | grep 'a{1,3}b'

    Resultado:

    1
2
3

    ab
aab
aaab

Tabela: Quantificadores Comuns em Expressões Regulares

QuantificadorDescriçãoExemplo
*Zero ou mais ocorrênciasa*
+Uma ou mais ocorrênciasa+
?Zero ou uma ocorrênciaa?
{n}Exatamente n ocorrênciasa{3}
{n,}n ou mais ocorrênciasa{2,}
{n,m}Entre n e m ocorrênciasa{1,3}

Exercícios Práticos com Quantificadores

  1. Buscar Palavras com Múltiplas Letras Específicas

    Use o+ para encontrar palavras com uma ou mais letras “o”:

    1

    echo -e "ola\noooo\nok" | grep 'o+'

  2. Procurar Códigos de 3 Dígitos

    Utilize [0-9]{3} para encontrar linhas com exatamente três números seguidos:

    1

    grep '[0-9]{3}' arquivo.txt

  3. Encontrar Palavras com Intervalo de Letras Repetidas

    Para encontrar palavras que contenham entre duas e quatro letras “a”, use a{2,4}:

    1

    echo -e "a\naa\naaa\naaaa\naaaaa" | grep 'a{2,4}'

Dicas de Prática

  • Teste Quantificadores Individualmente: Familiarize-se com cada quantificador para entender seu efeito antes de combiná-los.
  • Combine com Outros Meta Caracteres: Quantificadores são mais eficazes quando usados junto com outros meta caracteres e âncoras, como ^ e $.

6. POSIX e Expressões Regulares Estendidas (ER)

Objetivo

Nesta seção, vamos explorar as diferenças entre expressões regulares POSIX e expressões regulares estendidas (ER) no Linux. Compreender essas diferenças ajuda a escolher a forma correta de regex para comandos específicos e ambientes de trabalho distintos.

O Que São POSIX e Expressões Regulares Estendidas?

No Linux, as expressões regulares seguem duas principais convenções:

  • POSIX BRE (Basic Regular Expressions): É o padrão básico usado em muitos comandos, incluindo grep por padrão.
  • POSIX ERE (Extended Regular Expressions): É uma forma mais avançada, que permite o uso de operadores e caracteres adicionais sem a necessidade de escapes. Comandos como egrep (ou grep -E) utilizam ER por padrão.
TipoCaracterísticasExemplo de Uso
POSIX BREUsa operadores como ?, +, {}, | e () com escape \.grep 'a\{2\}' para duas letras “a”.
POSIX EREPermite o uso direto de operadores como ?, +, {}, |, e () sem escape, simplificando a sintaxe.grep -E 'a{2}' para duas letras “a”.

Principais Diferenças entre POSIX BRE e POSIX ERE

OperadorPOSIX BREPOSIX EREDescrição
?Necessita de escape (\?)Usado diretamente (?)Indica zero ou uma ocorrência.
+Necessita de escape (\+)Usado diretamente (+)Indica uma ou mais ocorrências.
{n,m}Necessita de escape (\{n,m\})Usado diretamente ({n,m})Especifica intervalo de ocorrências.
|Necessita de escape (\|)Usado diretamente (|)Alternativa lógica (OR).
()Necessita de escape (\( \))Usado diretamente (( e ))Agrupa expressões.

Exemplos Práticos de POSIX BRE e ERE

  1. Usando POSIX BRE com Escape para Quantificadores

    Em POSIX BRE, para especificar que uma letra deve aparecer duas vezes consecutivas, você deve usar o escape \{2\}:

    1

    echo -e "aa\nab\naaa" | grep 'a\{2\}'

    Resultado:

    1
2

    aa
aaa

  2. Usando POSIX ERE para Simplificar Expressões

    Em POSIX ERE, o mesmo padrão pode ser escrito sem os escapes adicionais, facilitando a leitura e edição das expressões:

    1

    echo -e "aa\nab\naaa" | grep -E 'a{2}'

    Resultado:

    1
2

    aa
aaa

  3. Usando Alternativas (OR) em POSIX BRE e ERE

    Para buscar alternativas como “cão” ou “gato” com POSIX BRE, é necessário usar o escape \|. No POSIX ERE, basta usar | diretamente:

    • POSIX BRE:
      1

      echo -e "cão\ngato\npássaro" | grep 'cão\|gato'
    • POSIX ERE:
      1

      echo -e "cão\ngato\npássaro" | grep -E 'cão|gato'

    Resultado para ambos:

    1
2

    cão
gato

  4. Agrupamento com Parênteses em POSIX BRE e ERE

    Para agrupar partes de uma expressão em POSIX BRE, você precisa usar \( e \), enquanto em POSIX ERE basta usar ( e ):

    • POSIX BRE:
      1

      echo -e "aaa\nabc\naac" | grep 'a\(a\|b\)c'
    • POSIX ERE:
      1

      echo -e "aaa\nabc\naac" | grep -E 'a(a|b)c'

    Resultado para ambos:

    1
2

    abc
aac

Tabelas de Referência para POSIX BRE e ERE

Operadores POSIX BRE

OperadorFunçãoExemplo de Uso
\?Zero ou uma ocorrênciaa\?
\+Uma ou mais ocorrênciasa\+
\|Alternativa (OR)a\|b
\{n,m\}Intervalo de ocorrênciasa\{2,3\}
\( \)Agrupamento\(ab\)+

Operadores POSIX ERE

OperadorFunçãoExemplo de Uso
?Zero ou uma ocorrênciaa?
+Uma ou mais ocorrênciasa+
|Alternativa (OR)a|b
{n,m}Intervalo de ocorrênciasa{2,3}
( )Agrupamento(ab)+

Exercícios Práticos com POSIX BRE e ERE

  1. Buscar Palavras com Intervalos de Caracteres com POSIX BRE

    Use grep para encontrar palavras com exatamente duas letras “a” seguidas de “b”:

    1

    echo -e "ab\naab\naaab" | grep 'a\{2\}b'

  2. Usar Alternativas com POSIX ERE

    Com grep -E, busque por linhas que contenham “carro” ou “moto”:

    1

    echo -e "carro\nmoto\nbarco" | grep -E 'carro|moto'

  3. Agrupando e Usando Quantificadores com POSIX ERE

    Busque por linhas que contenham “ana” ou “maria” repetidos uma ou mais vezes:

    1

    echo -e "ana\nmaria\nanamaria" | grep -E '(ana|maria)+'

Dicas de Prática

  • Escolha o Tipo de Regex Certo: Em comandos como grep, usar grep -E para POSIX ERE pode simplificar a expressão regular e evitar o uso de escapes desnecessários.
  • Teste com Diferentes Comandos: Ferramentas como awk e sed suportam regex com POSIX ERE, o que pode ser útil em scripts e pipelines.

7. Usando o AWK com Expressões Regulares

Objetivo

Explorar o uso de expressões regulares no comando AWK para buscar, filtrar e manipular texto. AWK é uma linguagem de processamento de texto com recursos robustos que permitem criar filtros e transformar dados de maneira avançada.

O Que é AWK?

O AWK é uma linguagem de programação e uma ferramenta poderosa para manipulação de texto em sistemas Unix/Linux. Ele permite processar texto em linhas e colunas, oferecendo suporte a expressões regulares para realizar buscas e transformações complexas.

Sintaxe Básica de AWK

A sintaxe do AWK usa padrões regex para aplicar comandos em textos ou arquivos. A estrutura básica é:

1

awk '/padrão/ { ação }' arquivo.txt
  • /padrão/: O padrão de expressão regular a ser buscado.
  • { ação }: A ação a ser realizada quando o padrão for encontrado (ex.: imprimir, substituir, etc.).

Principais Funcionalidades de AWK com Regex

Comando AWKDescriçãoExemplo de Uso
/padrão/ { print $0 }Imprime linhas que correspondem ao padrão regex./erro/ { print $0 }
! /padrão/ { ação }Aplica a ação a linhas que não correspondem ao padrão.! /sucesso/ { print $0 }
/padrão1|padrão2/ { ação }Usa alternância para combinar dois padrões diferentes./erro|falha/ { print $0 }
$campo ~ /padrão/ { ação }Aplica a ação a linhas onde o campo especificado corresponde ao padrão.$3 ~ /OK/ { print $1, $3 }
$campo !~ /padrão/ { ação }Aplica a ação a linhas onde o campo especificado não corresponde ao padrão.$2 !~ /erro/ { print $0 }

Exemplos Práticos de Regex com AWK

  1. Imprimir Linhas que Contêm uma Palavra Específica

    Para imprimir todas as linhas que contêm a palavra “erro” em um arquivo log.txt:

    1

    awk '/erro/ { print $0 }' log.txt

    Resultado: Todas as linhas que contêm “erro” serão exibidas.

  2. Excluir Linhas com Determinado Padrão

    Para imprimir linhas que não contêm a palavra “sucesso”:

    1

    awk '! /sucesso/ { print $0 }' log.txt

  3. Usar Alternância para Combinar Padrões

    Você pode usar | para buscar várias palavras. No exemplo, buscamos por linhas que contêm “erro” ou “falha”:

    1

    awk '/erro|falha/ { print $0 }' log.txt

  4. Buscar em Campos Específicos com Regex

    Se você quiser verificar o terceiro campo de cada linha e buscar por um padrão específico, como “OK”, use $3 ~ /OK/:

    1

    awk '$3 ~ /OK/ { print $1, $3 }' log.txt

  5. Excluir Linhas com Padrão Específico em um Campo

    Para excluir linhas onde o segundo campo contém “erro”:

    1

    awk '$2 !~ /erro/ { print $0 }' log.txt

Manipulação Avançada de Texto com AWK

AWK permite realizar substituições e manipulações avançadas ao combinar regex com funções internas:

  • Substituir Texto em um Campo Específico

    Use a função gsub() para substituir um texto específico dentro de uma coluna. No exemplo abaixo, substituímos “ERRO” por “AVISO” no segundo campo:

    1

    awk '{ gsub(/ERRO/, "AVISO", $2); print $0 }' log.txt

  • Imprimir Apenas Linhas que Começam com um Padrão

    Para imprimir linhas que começam com “WARN”:

    1

    awk '/^WARN/ { print $0 }' log.txt

  • Imprimir Linhas que Terminam com um Padrão

    Para imprimir linhas que terminam com “OK”:

    1

    awk '/OK$/ { print $0 }' log.txt

Exercícios Práticos com AWK e Regex

  1. Imprimir Linhas com Palavras Específicas

    Use AWK para buscar linhas que contenham “erro” ou “falha” em relatorio.txt:

    1

    awk '/erro|falha/ { print $0 }' relatorio.txt

  2. Substituir uma Palavra em Linhas Selecionadas

    Substitua a palavra “pendente” por “em processo” no quarto campo, apenas em linhas que contêm “processo”:

    1

    awk '/processo/ { gsub(/pendente/, "em processo", $4); print $0 }' relatorio.txt

  3. Imprimir Linhas com Determinado Número de Dígitos em um Campo

    Para imprimir apenas as linhas onde o segundo campo contém um número de três dígitos:

    1

    awk '$2 ~ /^[0-9]{3}$/ { print $0 }' relatorio.txt

Dicas de Prática

  • Combine Regex e Campos: Usar regex em campos específicos ($campo ~ /padrão/) é uma ótima maneira de refinar as buscas.
  • Aproveite as Funções Internas do AWK: Funções como gsub() e sub() permitem manipulações adicionais de texto, tornando AWK ideal para tarefas avançadas.

8. Usando o SED com Expressões Regulares

Objetivo

Explorar como utilizar expressões regulares com o comando SED para realizar substituições e edições de texto de forma automática. O SED (Stream Editor) permite manipular texto em arquivos ou em fluxo de dados, sendo ideal para automatizar tarefas de busca e substituição.

O Que é o SED?

O SED é um editor de texto em linha de comando que aplica modificações e filtros de forma automatizada. Com o SED, é possível:

  • Buscar e substituir textos;
  • Deletar linhas que correspondam a um padrão específico;
  • Inserir e modificar conteúdos em fluxo, diretamente em arquivos ou comandos.

Sintaxe Básica do SED

A sintaxe básica para o comando SED é:

1

sed 's/padrão/substituição/opções' arquivo.txt
  • s: Indica o comando de substituição (substitute).
  • padrão: O padrão regex a ser buscado.
  • substituição: O texto que substituirá o padrão encontrado.
  • opções: Controla o comportamento da substituição (ex.: g para substituição global).

Principais Funcionalidades do SED com Regex

Comando SEDDescriçãoExemplo de Uso
s/padrão/substituição/gSubstitui todas as ocorrências de padrão por substituição em cada linha.s/erro/aviso/g
s/padrão/substituição/giSubstitui todas as ocorrências de padrão (ignorando maiúsculas/minúsculas) por substituição.s/teste/exemplo/gi
/padrão/dDeleta todas as linhas que correspondem ao padrão./erro/d
/^padrão/ s/antigo/novo/Substitui antigo por novo apenas em linhas que começam com padrão./^Log/ s/erro/aviso/
N; /padrão/ s/antigo/novo/gSubstitui antigo por novo em linhas pares ou ímpares (N representa o número da linha).1~2 s/erro/aviso/ para linhas ímpares

Exemplos Práticos de Regex com SED

  1. Substituir Todas as Ocorrências de uma Palavra em Cada Linha

    Para substituir todas as ocorrências de “erro” por “aviso” em log.txt:

    1

    sed 's/erro/aviso/g' log.txt

  2. Substituir Palavras com Maiúsculas e Minúsculas (Case Insensitive)

    Para substituir “Teste” ou “teste” por “Exemplo”, usando o modificador i para ignorar maiúsculas e minúsculas:

    1

    sed 's/teste/Exemplo/gi' texto.txt

  3. Deletar Linhas que Contêm um Padrão Específico

    Para remover linhas que contenham a palavra “falha” em um arquivo:

    1

    sed '/falha/d' log.txt

  4. Substituir Texto em Linhas que Começam com um Padrão

    Substitua “erro” por “aviso” apenas em linhas que começam com “Log”:

    1

    sed '/^Log/ s/erro/aviso/' log.txt

  5. Substituir Texto em Linhas Ímpares ou Pares

    Para substituir “pendente” por “completo” em linhas ímpares:

    1

    sed '1~2 s/pendente/completo/' status.txt

Tabelas de Comandos e Opções do SED

Comandos Mais Comuns do SED

ComandoDescrição
s/Substitui um padrão por outro
/dDeleta linhas que correspondem ao padrão
/pImprime apenas as linhas que correspondem ao padrão
/aAdiciona texto após a linha correspondente
/iInsere texto antes da linha correspondente

Opções Mais Usadas do SED

OpçãoDescrição
gGlobal, substitui todas as ocorrências em cada linha.
iIgnora maiúsculas/minúsculas na busca (insensitive).
nAplica a modificação apenas na n-ésima ocorrência do padrão em cada linha.
eInterpreta o resultado como uma expressão de comando (executa o comando após substituição).

Exercícios Práticos com SED e Regex

  1. Substituir Palavras em Linhas com Padrões Específicos

    Substitua “incompleto” por “finalizado” apenas nas linhas que contêm a palavra “processo”:

    1

    sed '/processo/ s/incompleto/finalizado/' arquivo.txt

  2. Deletar Linhas Vazias de um Arquivo

    Para remover todas as linhas vazias do arquivo documento.txt:

    1

    sed '/^$/d' documento.txt

  3. Inserir Texto Após Linhas com Padrão Específico

    Adicione a linha “Processo concluído” após linhas que contenham “ID:” no arquivo:

    1

    sed '/ID:/ a Processo concluído' relatorio.txt

  4. Transformar Texto em Maiúsculas nas Linhas Selecionadas

    Substitua palavras minúsculas por maiúsculas em linhas que contenham “ERRO”:

    1

    sed '/ERRO/ s/.*/\U&/' log.txt

Dicas de Prática

  • Use o SED para Modificar Arquivos em Lote: Com SED, você pode aplicar substituições em massa em múltiplos arquivos usando redirecionamento ou loops.
  • Combine SED com Outros Comandos: Ao combinar SED com grep ou awk, é possível filtrar e transformar texto de maneira extremamente precisa.

9. Usando o GREP, EGREP e FGREP com Expressões Regulares

Objetivo

Explorar o uso de expressões regulares com GREP, junto com suas variantes EGREP (Extended GREP) e FGREP (Fixed GREP), para realizar buscas avançadas em arquivos. Vamos entender as diferenças entre cada uma dessas ferramentas e ver exemplos práticos.

O Que São GREP, EGREP e FGREP?

Essas são variantes do comando grep:

  • GREP: A versão padrão que utiliza expressões regulares básicas (BRE).
  • EGREP: Versão estendida que utiliza expressões regulares estendidas (ERE), o que permite usar quantificadores e operadores sem escapes adicionais. Esse comando é equivalente a grep -E.
  • FGREP: Variante que realiza buscas sem expressões regulares (literalmente). Hoje, fgrep é equivalente a grep -F e é mais rápido quando precisamos buscar texto exato, sem regex.

Comparação entre GREP, EGREP e FGREP

VarianteDescriçãoExemplo de Uso
GREPUtiliza expressões regulares básicas (BRE), necessitando de escapes para operadores como +, ?, {}.grep 'a\{2\}' arquivo.txt
EGREPUsa expressões regulares estendidas (ERE), facilitando a escrita de regex complexos sem escapes adicionais.egrep 'a{2}' arquivo.txt ou grep -E
FGREPBusca texto literal, sem interpretar caracteres especiais como regex. Ideal para buscas rápidas e exatas.fgrep 'texto.exato' arquivo.txt ou grep -F

Principais Operadores e Suporte nas Variantes

OperadorGREP (BRE)EGREP (ERE)FGREP
.SimSimNão
*SimSimNão
+\+SimNão
{n,m}\{n,m\}SimNão
|\|SimNão
()\( \)SimNão

Exemplos Práticos de Uso do GREP, EGREP e FGREP

  1. Usando GREP para Expressões Regulares Básicas (BRE)

    Procurar por duas letras “a” seguidas em um arquivo com grep (usando escapes):

    1

    grep 'a\{2\}' texto.txt

  2. Usando EGREP para Regex Estendidas (ERE)

    Para realizar a mesma busca, mas sem a necessidade de escapes adicionais, use egrep ou grep -E:

    1
2
3

    egrep 'a{2}' texto.txt
# ou
grep -E 'a{2}' texto.txt

  3. Usando FGREP para Busca Literal

    Para buscar o termo a{2}, sem que ele seja interpretado como regex (busca literal):

    1
2
3

    fgrep 'a{2}' texto.txt
# ou
grep -F 'a{2}' texto.txt

  4. Combinação de Padrões com EGREP

    Com egrep, você pode buscar múltiplos padrões ao mesmo tempo usando |. No exemplo abaixo, procuramos “erro” ou “falha”:

    1
2
3

    egrep 'erro|falha' log.txt
# ou
grep -E 'erro|falha' log.txt

  5. Usando GREP para Buscar em Diversos Arquivos

    Para buscar um padrão em múltiplos arquivos .log no diretório atual, utilize o grep:

    1

    grep 'ERRO' *.log

Casos de Uso para Cada Variante

  • GREP: Ideal para buscas que utilizam expressões regulares básicas. Ele é útil para filtros mais simples e buscas diretas em arquivos grandes.
  • EGREP: Recomendado para regex mais complexas, onde operadores avançados, como {}, |, e +, são usados frequentemente. Ele simplifica a escrita de regex sem escapes extras.
  • FGREP: É a melhor escolha quando você precisa de uma busca rápida por texto exato (sem regex), pois processa caracteres especiais como texto literal, ideal para diretórios grandes.

Exercícios Práticos com GREP, EGREP e FGREP

  1. Buscar por um Padrão com Quantificador em GREP

    Use grep para encontrar todas as linhas em dados.txt com três dígitos seguidos:

    1

    grep '[0-9]\{3\}' dados.txt

  2. Combinar Padrões com EGREP

    Use egrep para localizar linhas que contenham “aviso” ou “erro” em relatorio.log:

    1

    egrep 'aviso|erro' relatorio.log

  3. Buscar por Textos Literais com FGREP

    Utilize fgrep para buscar o termo “a+b=c” em equacoes.txt, sem interpretação de regex:

    1

    fgrep 'a+b=c' equacoes.txt

  4. Buscar Linhas que Terminam com um Padrão

    Use grep para encontrar todas as linhas que terminam com “.com” em emails.txt:

    1

    grep '\.com$' emails.txt

Dicas de Prática

  • Escolha a Ferramenta Certa: Use grep para expressões regulares básicas, egrep para regex avançadas e fgrep para texto literal, aproveitando o melhor de cada comando.
  • Combine com Opções Adicionais: Opções como -i (case insensitive) e -v (invert match) podem ser usadas para tornar as buscas mais flexíveis.

10. Usando o FIND com Expressões Regulares

Objetivo

Nesta seção, vamos explorar como combinar o comando FIND com expressões regulares para buscar arquivos e diretórios no Linux. O find é uma ferramenta poderosa e flexível que permite localizar arquivos com base em critérios avançados, incluindo nomes, tamanhos, datas, permissões e, claro, padrões regex.

O Que é o FIND?

O comando FIND é usado para localizar arquivos e diretórios dentro de um sistema de arquivos, oferecendo várias opções para filtrar e refinar buscas. Com o find, você pode aplicar filtros para encontrar arquivos por nome, tipo, data de modificação e até mesmo por conteúdo.

Sintaxe Básica do FIND com Regex

No find, você pode utilizar a opção -regex para definir um padrão regex que será aplicado ao caminho completo dos arquivos e diretórios encontrados:

1

find /caminho -regex 'padrão'
  • /caminho: Diretório onde a busca será iniciada.
  • -regex: Indica que o padrão é uma expressão regular.
  • padrão: A regex que será aplicada para filtrar os arquivos.

Exemplos Práticos de Uso do FIND com Regex

  1. Buscar Arquivos que Correspondem a um Padrão Simples

    Para encontrar todos os arquivos que terminam com .log no diretório /var/log, use:

    1

    find /var/log -regex '.*\.log$'

  2. Buscar Arquivos com Nomes que Contêm Dígitos

    Para localizar arquivos que contenham números no nome dentro do diretório /home/usuario/docs:

    1

    find /home/usuario/docs -regex '.*[0-9]+.*'

  3. Buscar Arquivos com Extensões Específicas

    Se quiser buscar apenas arquivos com extensões .txt ou .md no diretório atual:

    1

    find . -regex '.*\.\(txt\|md\)$'

  4. Buscar Arquivos por Padrões Complexos

    Para localizar arquivos que comecem com “rel_” e terminem com quatro dígitos (ex.: rel_2022):

    1

    find . -regex '.*/rel_[0-9]{4}$'

  5. Buscar Diretórios que Começam com uma Letra Maiúscula

    Para listar apenas diretórios que começam com uma letra maiúscula dentro de /home/usuario:

    1

    find /home/usuario -type d -regex '.*/[A-Z].*'

Opções Úteis do FIND com Regex

OpçãoDescriçãoExemplo de Uso
-regexAplica uma regex ao caminho completo do arquivo ou diretório.find . -regex '.*\.log$'
-nameBusca por nome exato, sem regex.find . -name "*.log"
-inameBusca por nome, ignorando maiúsculas/minúsculas.find . -iname "*.txt"
-typeEspecifica o tipo (f para arquivos, d para diretórios).find . -type d -regex '.*Backup.*'
-execExecuta um comando em cada arquivo encontrado.find . -name "*.log" -exec rm {} \;

Exercícios Práticos com FIND e Regex

  1. Buscar Arquivos que Contenham Datas no Nome

    Use o find para localizar arquivos que contenham uma data no formato YYYY-MM-DD (ex.: 2023-11-01) no diretório /home/usuario/projetos:

    1

    find /home/usuario/projetos -regex '.*[0-9]{4}-[0-9]{2}-[0-9]{2}.*'

  2. Localizar Imagens com Extensões .jpg ou .png

    Para buscar arquivos de imagem com extensões .jpg ou .png:

    1

    find /imagens -regex '.*\.\(jpg\|png\)$'

  3. Buscar Diretórios que Contêm a Palavra “Backup”

    Encontre diretórios que tenham “Backup” no nome dentro de /var/arquivos:

    1

    find /var/arquivos -type d -regex '.*/Backup.*'

  4. Apagar Arquivos Temporários com Padrão Específico

    Localize e exclua arquivos que começam com “temp_” e terminam com .tmp:

    1

    find . -regex '.*temp_.*\.tmp$' -exec rm {} \;

Dicas de Prática

  • Teste as Regex com Cuidado: Use o find sem -exec inicialmente para garantir que apenas os arquivos desejados sejam listados antes de aplicar comandos de modificação ou remoção.
  • Use -name e -iname para Buscas Simples: Para buscas mais simples, -name e -iname podem ser suficientes, além de serem mais rápidas em alguns casos.

Conclusão

O domínio das expressões regulares abre inúmeras possibilidades para a manipulação de texto, tornando-se uma habilidade indispensável para usuários e administradores de sistemas Linux. Ao longo deste tutorial, você explorou as principais ferramentas que utilizam regex, com exemplos e dicas que demonstram sua flexibilidade e eficiência. Agora, é o momento de praticar o que foi aprendido! Experimente criar seus próprios padrões e aplique-os em arquivos e logs do sistema. A prática com regex permitirá que você automatize tarefas, resolva problemas rapidamente e manipule dados de forma muito mais precisa e eficaz no Linux.

Linux, Regex, Tutorial
Linux Regex grep sed awk find
This post is licensed under CC BY 4.0 by the author.