Heroana Blog

Então, agora vamos se aprofundar um pouquinho no grep e no sed.

Vamos mostrar coisas importantes desses programas:

Principais flags do grep:

zcat ftu.txt.gz | grep 'cat'     # Pega as linhas com a substring cat
zcat ftu.txt.gz | grep -v 'cat'  # Pega as linhas sem a substring cat
zcat ftu.txt.gz | grep -c 'cat'  # Pega a contagem das linhas com a substring cat
zcat ftu.txt.gz | grep -cv 'cat'  # Pega a contagem das linhas sem a substring cat
zcat ftu.txt.gz | grep 'c.t'  # Pega as linhas com uma substring que se enquadra em c(qualquer caractere)t
zcat ftu.txt.gz | grep -F 'c.t'  # Pega as linhas com a substring c.t (não vai mostrar nada)
zcat ftu.txt.gz | grep -E 'c[ua]?t'  # Pega as linhas com uma substring entre ct, cut e cat
zcat ftu.txt.gz | grep -n 'cat'  # Pega as linhas com uma substring cat e mostra os números das linhas
zcat ftu.txt.gz | grep -i 'CaT'  # Pega as linhas com uma substring CaT ignorando maiúsculas e minúsculas
zcat ftu.txt.gz | grep -Eo '[0-9]*sum' # Pega as linhas com um ou mais dígitos numéricos seguidos pelo termo sum e mostra somente os caracteres que batem na regexpr  

É importante treinar o uso do comando grep, pois é um dos mais importantes no gerenciamento de textos. Recomendo testar bastante essas flags e combinações delas.

Dito isso, vamos começar agora com o sed, ou Stream Editor. Essa é uma das ferramentas masi poderosas de longe dos comandos de manipulação de texto.

Vamos começar simulando um grep, com zcat ftu.txt.gz | sed -n /cat/p. O -n serve para impedir o sed de mostrar output que não seja explicitamente solicitado. o texto entre as barras é a expressão regular, como as do grep, e p é o comando print, para mostrar na tela o que couber na regexpr solicitada. Para realizar agora o equivalente ao grep -v, podemos fazer: zcat ftu.txt.gz | sed /cat/d, deletando todas as linhas que não contiverem aquela regexpr.

Agora, vamos começar para o mais interessante:

zcat ftu.txt.gz | sed 's/cat/dog/'  # Substitui a primeira aparição de cat por dog
zcat ftu.txt.gz | sed 's/cat/dog/g'  # Substitui todas as aparições de cat por dog
zcat ftu.txt.gz | sed '2d'  # Elimina a linha 2
zcat ftu.txt.gz | sed '2,7d'  # Elimina as linha 2 a 7
zcat ftu.txt.gz | sed '2,7d;11d'  # Elimina as linha 2 a 7 e a linha 11
zcat ftu.txt.gz | sed '2,7d;11d'  # Elimina as linha 2 a 7 e a linha 11
zcat ftu.txt.gz | sed '1d;/c[ua]t/d'  # Elimina a linha 1 e todas as linhas com a substring cut ou cat
zcat ftu.txt.gz | sed '1d;/c[ua]t/c REMOVED'  # Elimina a linha 1 e substitui todas as linhas com a substring cut ou cat por REMOVED
gunzip ftu.txt.gz
sed -i.backup 's/cat/dog/g' ftu.txt

Após executar cada um desses comandos, voltamos a não possuir o arquivo comprimidom e termos o arquivo original, salvo como ftu.txt.backup E uma versão alterada dele ftu.txt com dog no lugar de todos os cats.

Quando nós estamos manipulando dados, principalmente baixando dados da internet ou algo assim, é importante garantir que esses dados não foram alterados. Para isso usamos hashes. Um hash é aplicar uma fórmula matemática em um arquivo, que sempre gerará o mesmo resultado. Quando baixamos coisas da internet, é comum termos hashes dos arquivos baixados, para que possamos garantir que não houveram erros de Download ou coisas assim.

Vamos fazer isso nos nossos novos arquivos:

Para gerar o hash de ftu.txt (o arquivo com dog no lugar de cat), temos: sha256sum ftu.txt. Se redirecionarmos isso para um arquivo podemos fazer: sha256sum ftu.txt > sha256.txt. Podemos conferir esse hash com: sha256sum -c sha256.txt. Devemos receber um ok aqui. Isso significa que o arquivo ftu.txt não teve alterações desde a criação do sha256.txt. Agora, vamos restaurar o arquivo original: mv ftu.txt{.backup,}. Isso funcionará no bash, no zsh, mas não em todos os shells, logo, também pode ser feito com mv ftu.txt.backup ftu.txt. Esse comando renomeia o arquivo de backup para ftu.txt, sobrescrevendo o outro arquivo. Se tentar fazer o check do sha256sum agora, você encontrará um erro, pois os dados do arquivo foram alterados. Agora, podemos fazer om que passe de novo, fazendo os dados voltarem a ser o que eram: sed -i 's/cat/dog/g' ftu.txt. Agora o check deve passar de novo,

Podemos usar comandos como o od (octal dump) para poder inspecionar melhor arquivos e encontrar possíveis bugs.

Testemos com od ftu.txt. A primeira coluna de cada linha é o byte offset daquela linha (quantos bytes desde o início do arquivo se passaram). O resto são os dados do arquivo em octal. Podemos ver também em hexadecimal, com od -x ftu.txt

Podemos também ver os caracteres através de od -c ftu.txt.

Como pôde ser visto, o grep e o sed usam bastantes expressões regulares. Como elas funcionam?

O tipo mais simples de expressão regular é uma string que identifica a si mesma, como /cat/, uma regexpr que acerta qualquer string que contenha a substring cat, inclusive a própria string cat.

Cada caractere em uma regexpr se chama átomo. A maioria dos átomos representa a si mesmo, como c, a, t, etc. Contudo, alguns têm significados especiais:

• . Qualquer caractere Exemplo:
  • c.t => cut, cat, acatar, cútis, cicuta
  • a..ra => arara, lateral, cameras
• ^ O começo de uma linha Exemplo:
  • ^aba => abacaxi, abacate, abaco
  • ^.t. => atadura, etanol, pterodáctilo
• $ O final de uma linha Exemplo:
  • ada$ => fada, camada, pomadam laiada
  • ^.r.ta$ => prata, grata, brota, gruta
• * O caracter anterior é repetido 0 ou mais vezes Exemplo:
  • a.*a => aardvark, abaco, ambrosia
  • pre* => aprendiz, apreender praxis
• ? O caracter anterior aparece 0 ou 1 vez Exemplo:
  • xlsx? => dados.xlsx, dados.xls, camadas.xls
  • pree? => aprendiz, apreender
• + O caracter anterior aparece 1 ou mais vezes Exemplo:
  • pre+ => apreender, aprendiz
  • ^a.+e => aperto, antes
• \ Caractere de escape Escapa o próximo caractere Exemplo:
  • a\.t => casa.txt, loja.tmp
  • isso\?$ => "Você quer isso?", "Quem disso isso?"

Além dos átomos, contemos grupos de caracteres, com significados diferentes. Veremos seus tipos agora:

• Expressões de parênteses: Interpreta tudo o que está dentro como um átomo Exemplo:
  • (aba)? => abacaxi, pandice, malabarismo
  • ^(ar)+ => arara, arcada, armada

• Expressões de colchetes: Mostra escolhas possíveis de caracteres Exemplo:

  • c[ua]r?t => cut, cat, abacate, curtida, cartagena
  • [0-9]+sum$ => sha256sum, sha1sum, md5sum
  • [a-zA-Z]*[0-9]+ => 24530, Apache2, K3, 4, 98
  • [+-]?[:digit:]+ => 45, +89, -87, -3

  …

• Chaves: Um identificador de quantidade mais preciso. Exemplo:
  • (ar){2} => arara
  • [0-9]{3,} => 456, 456789, 987654321, 987
  • [:alpha:]{3,5} => casa, metas, pés, lixo

Podemos também fazer referências retroativas, de qualquer expressão dentro de parênteses (), através de \1, \2, etc.

Exemplo:

• '([a-z]{2})\1' => arara, batata