Linux grep dicas e truques para o dia a dia

GNU/Linux grep dicas e truques

---

Realmente depois de um tempo, o usuário Linux precisa muito do grep. Ele(a) tem anos de arquivos em backup, na nuvem, em HDs, anotados em dezenas de espécies de arquivos e diretórios diferentes que são mil, dois, três mil arquivos (pessoais), 800, 1000, 2000 scripts, 4, 8, 12, 60 mil linhas de código, 2000 aliases (alguns enormes) e mais trabalho chegando todo dia. Novas idéias que combinam bem com um trecho de código escrito 3 anos atrás e só se lembra de um pedacinho dele... Affff maria! Aí vem o grep para lhe salvar da mais profunda insanidade, porque quando tudo está lindo e fluindo bem, o ser humano sem querer tende a se perder na selva de coisas que criou. Fomos feitos para isto. Isto é tão normal.

---

SINTAXE DE COMANDO GREP:

1) grep 'palavra' nome_do_arquivo

2) grep 'string1 string2' nome_do_arquivo

3) cat outro_arquivo | grep 'algo'

4) comando | grep 'algo'

5) comando opção1 | grep 'informação'

6) grep --color 'info' nome_do_arquivo

---

Encontrando comandos em seu histórico. A maioria dos usuários fará algo assim:

history |grep

---

Conte e exiba os comandos mais usados em seu histórico.

history | awk 'BEGIN {FS="[ \t]+|\\|"} {print $3}' | sort | uniq

---

O primeiro desses truques permite criar uma lista de arquivos que contenham qualquer sequência que você esteja procurando.
Ele usa a opção -l (lista apenas os nomes dos arquivos, não o conteúdo correspondente) mais a opção -r para repetir através de subdiretórios.
Isso pode ajudá-lo a encontrar arquivos que você pode estar procurando, sem distraí-lo com todos os motivos pelos quais determinados arquivos corresponderam aos seus critérios de pesquisa.

Exemplo:

grep -rl "string que quer encontrar" *

---

Outro truque útil do grep no Linux permite que você especifique uma expressão regular Perl no seu termo de pesquisa. Neste exemplo, podemos dar ao grep uma expressão que permita que ele corresponda a várias seqüências de caracteres, como egrep. Pode ficar muito mais complicado que os exemplos mostrados, mas aqui está a sintaxe básica:

grep -P "enquanto|para" *

grep -P 'foto\.gif' *

---

Você também pode combinar o grep com os comandos find para obter algumas extrações úteis de texto dos arquivos de destino.

find . -name "*.r" -exec grep "rho" '{}' \; -print

---

Obviamente, um dos truques grep mais úteis que encontrei até agora é o que fornece algum contexto junto com a sua descoberta. Em vez de exibir apenas as linhas que contêm o texto específico que você estava procurando, você pode imprimir as linhas que aparecem antes e depois das linhas correspondentes - geralmente necessárias para determinar se "correspondência" é realmente o que você está procurando.

Você pode especificar quantas linhas deseja ver antes da sequência correspondente com a opção "B" (para "antes") e o número de linhas após a correspondência com a opção "A" (para "depois").

grep -B 2 -A 2 echo *

---

Usar grep para buscar arquivo?

grep boo /etc/passwd

grep -i "boo" /etc/passwd

---

Usar grep recursivamente?

grep -r "192.168.1.5" /etc/

---

Usar grep para buscar apenas palavras?

Quando você pesquisa boo, o grep corresponde a fooboo, boo123 etc. Você pode forçar o grep a selecionar apenas as linhas que contêm correspondências que formam palavras inteiras, ou seja, correspondem apenas à palavra boo:

grep -w "boo" /caminho/para/arquivo

---

Contar a linha quando as palavras forem correspondidas? O grep pode relatar o número de vezes que o padrão foi correspondido para cada arquivo usando a opção -c (count):

grep -c 'muu' /caminho/para/arquivo

Observe também que você pode usar a opção -n, que faz com que o grep preceda cada linha de saída com o número da linha no arquivo de texto do qual foi obtida:

grep -n 'foo' /caminho/para/arquivo

---

Grep partida invertida? Você pode usar a opção -v para imprimir inverte a correspondência; isto é, corresponde apenas às linhas que não contêm a palavra especificada. Por exemplo, imprima todas as linhas que não contêm a barra de palavras:

grep -v bar /caminho/para/arquivo

---

Pipes Linux e comando grep? Comando grep é frequentemente usado com pipes. Por exemplo, imprimir o nome dos dispositivos de disco rígido:

dmesg | egrep '(s|h)d[a-z]'

---

Modelo nome da cpu:

cat /proc/cpuinfo | grep -i 'Model'

---

O comando acima pode ser usado sem o shell pipe:

grep -i 'Model' /proc/cpuinfo

---

Como faço para listar apenas os nomes dos arquivos correspondentes? Use a opção -l para listar o nome do arquivo cujo conteúdo mencione main ():

grep -l 'main' *.c

Finally, you can force grep to display output in colors:

grep --color vivek /etc/passwd

---

Grep é usado principalmente para filtrar a saída de um comando para restringir o que o usuário está procurando.

grep "dark" rgb.txt

---

Encontre uma instância de uma palavra com um número depois dela.

ls | grep "ppm[0-9]"

---

Exclua todos os arquivos mkv em um diretório usando grep e xargs. Você deve ter cuidado com este comando, isso não solicitará antes de excluir arquivos.

ls | grep "mkv" | xargs rm

---

Como retornar os nomes dos arquivos que não contêm uma determinada sequência de pesquisa.

grep -L "linux" *.txt

---

Imprima uma lista alfabética classificada de todos os arquivos que correspondem a uma determinada string ou palavra.

ls | grep by | sort | uniq -c | sort -n

---

Contar a quantidade de arquivos com um certo nome:

ls | grep log | wc -l

---

Linux grep e egrep expressões regulares teoria e prática? Hmm…

Expressões regulares – uma expressão regular é um padrão que descreve um conjunto de strings. Expressões regulares são construídas analogamente às expressões aritméticas, usando vários operadores para combinar expressões menores. O Grep entende duas versões diferentes da sintaxe da expressão regular: “básico” e “estendido”. No GNU grep, não há diferença na funcionalidade disponível usando a sintaxe. Em outras implementações, expressões regulares básicas são menos poderosas. A descrição a seguir se aplica a expressões regulares estendidas, usadas no egrep; as diferenças para expressões regulares básicas são resumidas posteriormente. Os blocos de construção fundamentais são as expressões regulares que correspondem a um único caractere. A maioria dos caracteres, incluindo todas as letras e dígitos, são expressões regulares correspondentes. Qualquer metacaractere com significado especial pode ser citado precedendo-o com uma barra invertida. Uma expressão entre colchetes é uma lista de caracteres entre [e]. Corresponde a qualquer caractere único nessa lista; se o primeiro caractere da lista for o sinal de intercalação ^, ele corresponderá a qualquer caractere que não esteja na lista. Por exemplo, a expressão regular [0123456789] corresponde a qualquer dígito único. Dentro de uma expressão entre colchetes, uma expressão de intervalo consiste em dois caracteres separados por um hífen (“-“). Corresponde a qualquer caractere único que classifique entre os dois caracteres, inclusive, usando a sequência de intercalação e o conjunto de caracteres da localidade. Por exemplo, no código de idioma C padrão, [a-d] é equivalente a [abcd]. Muitos códigos de idioma ordenam caracteres na ordem do dicionário e, nesses locais, [a-d] geralmente não é equivalente a [abcd]; pode ser equivalente a [aBbCcDd], por exemplo. Para obter a interpretação tradicional das expressões entre colchetes, você pode usar o código de idioma C configurando a variável de ambiente LC_ALL para o valor C. Por fim, determinadas classes de caracteres nomeadas são predefinidas nas expressões entre colchetes, da seguinte maneira. Seus nomes são auto-explicativos e são [: alnum:], [: alpha:], [: cntrl:], [: digit:], [: graph:], [: lower:], [: print:] , [: punct:], [: space:], [: upper:] e [: xdigit:]. Por exemplo, [[: alnum:]] significa [0-9A-Za-z], exceto que a última forma depende da localidade C e da codificação de caracteres ASCII, enquanto a anterior é independente da localidade e do conjunto de caracteres. (Observe que os colchetes nesses nomes de classe fazem parte dos nomes simbólicos e devem ser incluídos além dos colchetes que delimitam a lista de colchetes.) A maioria dos metacaracteres perde seu significado especial nas listas. Para incluir um literal], coloque-o primeiro na lista. Da mesma forma, para incluir um literal, coloque-o em qualquer lugar, exceto primeiro. Finalmente, para incluir um literal – coloque-o por último. O período . corresponde a qualquer caractere único. O símbolo w é sinônimo de [[: alnum:]] e W é sinônimo de [^ [: alnum]]. O sinal de intercalação ^ e o cifrão (“$”) são metacaracteres que correspondem respectivamente à sequência vazia no início e no final de uma linha. Os símbolos correspondem respectivamente à sequência vazia no início e no final de uma palavra. O símbolo b corresponde à sequência vazia na extremidade de uma palavra e B corresponde à sequência vazia, desde que não esteja na extremidade de uma palavra. Uma expressão regular pode ser seguida por um dos vários operadores de repetição:

Uma expressão regular pode ser seguida por um dos vários operadores de repetição:

? O item anterior é opcional e corresponde ao máximo uma vez.
* O item anterior corresponderá a zero ou mais vezes.
+ O item anterior será correspondido uma ou mais vezes.
{n} O item anterior corresponde exatamente n vezes.
{n,} O item anterior corresponde a n ou mais vezes.
{n, m} O item anterior corresponde a pelo menos n vezes, mas não mais que m vezes.

Duas expressões regulares podem ser concatenadas; a expressão regular resultante corresponde a qualquer sequência formada concatenando duas substrings que correspondem respectivamente às subexpressões concatenadas. Duas expressões regulares podem ser unidas pelo operador infix |; a expressão regular resultante corresponde a qualquer sequência que corresponda a qualquer subexpressão. A repetição tem precedência sobre a concatenação, que por sua vez tem precedência sobre a alternância. Uma subexpressão inteira pode ser colocada entre parênteses para substituir essas regras de precedência. A referência anterior n, onde n é um dígito único, corresponde à substring correspondida anteriormente pela n-ésima subexpressão entre parênteses da expressão regular. Nas expressões regulares básicas, os metacaracteres?, +, {, |, (, E) perdem seu significado especial; em vez disso, use as versões com barra invertida?, +, {, |, (, e). O egrep tradicional não suportava o {metacaractere, e algumas implementações do egrep suportam {em vez disso, portanto, os scripts portáteis devem evitar {nos padrões do egrep e devem usar [{] para corresponder a um literal {. O GNU egrep tenta dar suporte ao uso tradicional assumindo que {não é especial se for o início de uma especificação de intervalo inválida. Por exemplo, o comando shell egrep ‘{1’ pesquisa a cadeia de dois caracteres {1 em vez de relatar um erro de sintaxe na expressão regular. O POSIX.2 permite esse comportamento como uma extensão, mas os scripts portáteis devem evitá-lo. Variáveis de ambiente – O comportamento do Grep é afetado pelas seguintes variáveis de ambiente: Um código de idioma LC_foo é especificado examinando as três variáveis de ambiente LC_ALL, LC_foo, LANG, nessa ordem. A primeira dessas variáveis configuradas especifica o código do idioma. Por exemplo, se LC_ALL não estiver definido, mas LC_MESSAGES estiver definido como pt_BR, o português do Brasil será usado para o código de idioma LC_MESSAGES. O código de idioma C é usado se nenhuma dessas variáveis de ambiente estiver definida, ou se o catálogo de códigos de idioma não estiver instalado, ou se o grep não tiver sido compilado com o NLS (National Language Support). GREP_OPTIONS – Esta variável especifica opções padrão a serem colocadas na frente de qualquer opção explícita. Por exemplo, se GREP_OPTIONS for ‘- arquivos binários u003d sem correspondência – diretórios u003d ignorar’, grep se comportará como se as duas opções – arquivos binários u003d sem correspondência e – diretórios u003d ignor fossem especificadas antes de qualquer opções explícitas. As especificações das opções são separadas por espaços em branco. Uma barra invertida escapa ao próximo caractere, portanto, pode ser usada para especificar uma opção que contenha espaço em branco ou uma barra invertida. GREP_COLOR – especifica o marcador para realçar. LC_ALL, LC_COLLATE, LANG. Essas variáveis especificam o código de idioma LC_COLLATE, que determina a sequência de intercalação usada para interpretar expressões de intervalo como [a-z]. LC_ALL, LC_CTYPE, LANG – Essas variáveis u200bu200bespecificam a localidade LC_CTYPE, que determina o tipo de caracteres, por exemplo, quais caracteres estão em branco. LC_ALL, LC_MESSAGES, LANG – Essas variáveis especificam o código do idioma LC_MESSAGES, que determina o idioma que o grep usa para mensagens. A localidade C padrão usa mensagens em inglês americano. POSIXLY_CORRECT – Se definido, o grep se comporta conforme requer o POSIX.2; caso contrário, o grep se comportará mais como outros programas GNU. O POSIX.2 requer que as opções que seguem os nomes dos arquivos sejam tratadas como nomes de arquivo; por padrão, essas opções são permutadas para a frente da lista de operandos e são tratadas como opções. Além disso, o POSIX.2 exige que as opções não reconhecidas sejam diagnosticadas como “ilegais”, mas como elas não são realmente contrárias à lei, o padrão é diagnosticá-las como “inválidas”. POSIXLY_CORRECT também desativa _N_GNU_nonoption_argv_flags_, descrito abaixo. _N_GNU_nonoption_argv_flags_ (Aqui N é o ID numérico do processo do grep.) Se o i-ésimo caractere do valor dessa variável de ambiente for 1, não considere o i-ésimo operando do grep como uma opção, mesmo que pareça ser um. Um shell pode colocar essa variável no ambiente para cada comando executado, especificando quais operandos são os resultados da expansão de curinga do nome do arquivo e, portanto, não devem ser tratados como opções. Esse comportamento está disponível apenas na biblioteca GNU C e somente quando POSIXLY_CORRECT não está definido. Exemplos:

Procure padrões de ajuda de suporte e janelas no arquivo myfile.txt. Faça a correspondência de quaisquer linhas no myfile.txt que iniciem uma linha com uma palavra alfabética que também termine a linha. Faça a correspondência de quaisquer linhas no myfile.txt que iniciem uma linha com uma palavra alfabética que também termine a linha.

Crio um diretório e um arquivo para testes.

1) mkdir -pv ~/TESTES/TESTES_grep

2) cd ~/TESTES/TESTES_grep

3) touch myfile.txt

4) echo -e “support\nhelp \n58 \n01 ball \n10 hands \n99 \nwindows \nbegin \nLinux \nend \nUnix \nSupport \nEnd \nfight \nHelp \nJoe \njone \n1 Fight \n8 Windows \nZulu \n77 \nLIFE \n0 init \n9 conf \nAlpha\n” > myfile.txt

Com o diretório eo arquivo criados podemos testar alguns comandos nele:

egrep “support|help|windows” myfile.txt

Resultado:

~/TESTES/TESTES_grep:$ egrep “support|help|windows” myfile.txt
support
help
windows
~/TESTES/TESTES_grep:$

Também podemos especificar caracteres do alfabeto com [a-z] para caracteres em minúsculas e [A-Z] para caracteres em maiúsculas. Neste exemplo, corresponderemos caracteres maiúsculos.

egrep ‘^[a-zA-Z]+$’ myfile.txt

Resultado:

~/TESTES/TESTES_grep:$ egrep ‘^[a-zA-Z]+$’ myfile.txt
support
Alpha
~/TESTES/TESTES_grep:$

egrep -c ‘^begin|end$’ myfile.txt

Resultado:

~/TESTES/TESTES_grep:$ grep -c ‘^begin|end$’ myfile.txt
0

cat /etc/passwd/

egrep systemd /etc/passwd

Resultado:

~:$ egrep systemd /etc/passwd
systemd-resolve:x:988:988:systemd Resolver:/:/sbin/nologin
systemd-timesync:x:987:987:systemd Time Synchronization:/:/sbin/nologin
systemd-coredump:x:986:986:systemd Core Dumper:/:/sbin/nologin

Comandos:

egrep ‘[0-9]’ myfile.txt

Resultado:

~/TESTES/TESTES_grep:$ egrep ‘[0-9]’ myfile.txt
58
01 ball
10 hands
99
1 Fight
8 Windows
77
0 init
9 conf
~/TESTES/TESTES_grep:$

Executo os comandos abaixo:

egrep ‘[A-Z]’ myfile.txt

egrep ‘^[a-Z]’ myfile.txt

egrep ‘[0-9]$’ myfile.txt

egrep -i ‘alpha’ myfile.txt

Linux shell script usando egrep

Linux shell script usando egrep

---

Neste teste crio um diretório e dentro dele um arquivo com strings para o script
Realizar a busca. Executo os comandos abaixo:

1) mkdir -pv ~/TESTES/TESTES_grep/

2) cd ~/TESTES/TESTES_grep/

3) touch texto_testes_grep_egrep.txt

4) echo -e "caminho\nCaminho \ncaminhos \nLuz \nluz \nSol \nsolar\nTempo\nvirus\n" > texto_testes_grep_egrep.txt

5) cat texto_testes_grep_egrep.txt

---

Crio bash shell script em um arquivo de texto no diretório TESTES_grep/ (dou permissão de execução chmod +x ) este bash shell script abaixo:

#!/usr/bin/env bash

# titulo: egrep_script_test_1.sh
# autor:
# email:
# site:
# data: 28-03-2020_10:09:59
# distro:
# exemplo de uso: . ./egrep_script_test_1.sh
# objetivo:
# variaveis:
# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção

echo -e "\n\e[1;32mVou buscar uma string em algum arquivo.\e[0m\n"
read -p "Digite o termo de busca: " busca
echo -e "\n\e[1;32mVocê digitou $busca\e[0m\n"

# -------------------- #

read -p "Digite o caminho/nome do arquivo: " arquivo
echo -e "\n\e[1;32mVocê digitou $arquivo\e[0m\n"
read -p "tecle Enter para iniciar a busca: "
egrep -i "$busca" "$arquivo"

# fim do script

---

Agora vou testar o script criado.

---

~/TESTES/TESTES_grep:$ ls -CF
egrep_script_test_1.sh* texto_testes_grep_egrep.txt
~/TESTES/TESTES_grep:$ . ./egrep_script_test_1.sh

Vou buscar uma string em algum arquivo.

Digite o termo de busca: caminho

Você digitou caminho

Digite o caminho/nome do arquivo: texto_testes_grep_egrep.txt

Você digitou texto_testes_grep_egrep.txt

tecle Enter para iniciar a busca:
caminho
Caminho
caminhos
~/TESTES/TESTES_grep:$

---

Lista de comandos grep e afins

PARÂMETROS PARA grep -E, egrep e suas funções:

-c Conta quantas vezes apareceu a string que esta pesquisando
-v Mostra na tela “tudo” menos onde houver a ocorrência da string pesquisada
-i Realiza uma busca pela string ignorando o case, sendo case-insensitive
-o Ira mostrar na tela apenas as ocorrências da string pesquisada ignorando o resto
-n Ira mostrar na tela na primeira coluna a linha onde encontrou a string pesquisada
-B Numero de linhas a serem impressas antes da linha que contem a string pesquisada [BEFORE]
-A Numero de linhas a serem impressas na tela depois da encontrar a linha com a string [AFTER]
-C Quantidade de linhas antes e depois da linha que contem a string [CONTEXT]
-q Ira procurar pela string informada, porém estará em modo silencioso, nada sera impresso na tela, porém caso encontre o comando encerra com 0, caso não encontre nada será 1
-E Extende o uso de Regex no padrão e combinação, usando logica AND e OR por exemplo
-f Um arquivo com combinações de padrões com Regex, podendo usar varias combinações
-l Mostra somente o nome do arquivo onde foi encontrado a string pesquisada
-L Semelhante ao -v, porque mostra apenas os arquivo que não contem a string informada
-h Pesquisa varias arquivos, diretórios se com -r mas não mostra o nome dos arquivos
-r Ira realizar uma pesquisa recursiva em todos os diretórios a partir do informado
–color Deve-se passar o parâmetro ‘never’ caso não queira que a saída marque com cor a string ou ‘auto’ e ‘always’ para operar conforme necessite. Pode mudar a cor alterando GREP_COLOR, GREP_COLORS no environment

Nota: O comando egrep foi usado principalmente devido ao fato de ser mais rápido que o comando grep.
O comando egrep trata os meta-caracteres como eles são e não precisam ser escapados, como é o caso do grep.
Isso permite reduzir a sobrecarga de substituir esses caracteres.
A correspondência de padrões torna o egrep mais rápido que o grep ou o fgrep.

PARÂMETROS MAIS USADOS:

-L: imprime apenas os nomes dos arquivos que não possuem o padrão. Em frente à bandeira -l.
-e: Permite usar um sinal de ‘-‘ no início do padrão. Se não mencionado, o shell tenta executar o padrão como uma opção e retorna um erro.
-w: imprime apenas as linhas que contêm as palavras inteiras. Os caracteres constituintes da palavra são letras, dígitos e sublinhado. A substring correspondente deve ser separada por caracteres constituintes que não sejam palavras.
-x: imprime apenas as linhas que correspondem a uma linha inteira do arquivo.
-m NÚMERO: Continue a procurar correspondências até que a contagem atinja NÚMERO mencionado como argumento.
-o: imprime apenas as partes correspondentes da linha e não a linha inteira para cada correspondência.
-n: imprime cada linha correspondente junto com os respectivos números de linha. Para vários arquivos, imprime os nomes dos arquivos junto com os números das linhas.
-r: pesquisa recursivamente o padrão em todos os arquivos do diretório. O último argumento é o diretório a ser verificado. ‘.’ (Ponto) representa o diretório atual. O egrep é igual a grep -E.

Crie um diretório TESTES e dentro dele um texto_teste.txt. Copie e cole o texto abaixo em um editor de texto e salve com o nome: texto_teste.txt. Abra o terminal na pasta TESTE e execute os comandos egrep ou grep -E.

serie 6 A
amor
casa 9
Unix
Hello
arduino
amora
Casa
erduino
unix
Rapapi 2
CASA
duduino
Hello
coronavirus
Linux
RaspberryPI
casaca 8
linux
Raspberry PI
Pipopi
Coronavirus
rossperrypi B PI
Raspberry B PI
Papapu
hello
return 0
ressperi PIT A
Arduino
ardoendo 7
Bibope
return 0;
arduino
ARDUINO
Unix é o melhor
hello
IDEArduino
IDEpython
Linux é o poder
Eu não programo Python e você?
Arduino
Barduino
Eu não programo em C++ e você?

COMANDOS:

egrep Hello texto_teste.txt

grep -E -c Hello texto_teste.txt

egrep -v Hello texto_teste.txt

grep -E -i Hello texto_teste.txt

egrep -l Hello texto_teste.txt

egrep -L Hello texto_teste.txt

egrep -e -Hello texto_teste.txt

egrep -w Hello texto_teste.txt

egrep -x ‘return 0;’ texto_teste.txt

egrep -m Hello texto_teste.txt

egrep -o Hello texto_teste.txt

egrep -n Hello texto_teste.txt

egrep -r -i ‘hel*’ .

grep -c “Raspberry” texto_teste.txt

grep “arduino” texto_teste.txt

grep -i “arduino” texto_teste.txt

grep -o “arduino” texto_teste.txt

grep -oi “arduino” texto_teste.txt

grep -n “duino” texto_teste.txt

grep -n “Arduino” texto_teste.txt

grep “arduino” -B 2 texto_teste.txt

grep “arduino” -A 2 texto_teste.txt

grep “arduino” -C 2 texto_teste.txt

grep -q “arduino” texto_teste.txt

echo $?

grep -q “baladas” texto_teste.txt

echo $?

OBS revisando opções:

A maioria das opções para este comando é igual ao grep.

-c: Usado para contar e imprimir o número de linhas que correspondem ao padrão e não as linhas.
-v: imprime as linhas que não correspondem ao padrão.
-i: ignora o caso do padrão durante a correspondência.
-l: imprime apenas os nomes dos arquivos correspondentes. Ele não menciona os números de linha correspondentes ou qualquer outra informação.

OUTROS AFINS:

Qual é o comando para exibir a lista de arquivos em um diretório?

ls -lrt | grep ^-

Escreva um script de shell para exibir o último arquivo atualizado ou o arquivo mais recente em um diretório?

#!/bin/bash

ls -lrt | grep ^- | awk ‘END{print $NF}’

Escreva um script de shell para obter a data, hora, nome de usuário e diretório de trabalho atuais.

#!/usr/bin/env bash

echo “Olá, $LOGNAME”
echo “Data atual é: ‘date'”
echo “O usuário é: ‘whoami'”
echo “Diretório atual é: ‘pwd'”

# fim do script

Escreva um shell script que adicione uma extensão “.new” a todos os arquivos em um diretório.

#!/bin/bash
dir=$1
for file in `ls $1/*`
do
mv $file $file.new
done

Escreva um script de shell para imprimir um número na ordem inversa. Ele deve suportar os seguintes requisitos. O script deve aceitar a entrada da linha de comando. Se você não inserir nenhum dado, exiba uma mensagem de erro para executar o script corretamente. Resposta: Primeiro, anote as etapas envolvidas no script de teste.
1. Suponha que o número de entrada seja n.
2. Defina o dígito reverso e único como 0 (ou seja, rev u003d 0, sd u003d 0).
3. A expressão (n% 10) fornecerá o dígito mais à esquerda, ou seja, sd.
4. Para reverter o número, use esta expressão .
5. Diminua o número de entrada (n) em 1.
6. Se n for maior que 0, vá para o passo não. 3. Caso contrário, execute a etapa no. 7.
7. Imprima o resultado. O código do script é o seguinte:

#!/bin/bash

if [ $# -ne 1 ]
then
echo “Please provide the correct input in the below format.”
echo “Usage: $0 number”
echo ” This script will reverse the given number.”
echo ” For eg. $0 1234, will print 4321″
exit 1
fi

n=$1
rev=0
sd=0

while [ $n -gt 0 ]
do
sd=`expr $n % 10`
rev=`expr $rev \* 10 + $sd`
n=`expr $n / 10`
done
echo “Reverse number is $rev”

Linux grep encontrar string em pasta dir

grep -rnw ‘/caminho/para/pasta/’ -e ‘palavras que procura’

grep -rnw “/home/user/bin/” -e “Digite”

Execute o seguinte:

grep -rnw ‘/caminho/para/pasta/’ -e ‘palavras que procura’

-r or -R é recursivo,
-n número da linha, e
-w busca pela palavra toda.
-l (minúsculas L) pode ser adicionado para fornecer apenas o nome do arquivo correspondente.

Junto com as bandeiras, –exclude, –include, –exclude-dir pode melhorar a busca usando asterisco (global) e chaves (global).

Abaixo a busca só será realizada nos arquivos que tiverem a extensão especificada:

grep –include=\*.{c,h} -rnw ‘/caminho/para/pasta/’ -e “palavras que procura”

grep –include=\*.{sh,c} -rnw ‘/caminho/para/pasta/’ -e “palavras que procura”

grep –include=*.sh -rnw “/home/user/bin/” -e “ogg”

grep –include=*.sh -rnw “/home/user/bin/” -e “eu só entendo”

grep -E –include=*.sh -rnw “/home/user/bin/” -e “eu só entendo”

Isso excluirá a pesquisa de todos os arquivos que terminam com a extensão .o:

grep –exclude=*.o -rnw ‘/caminho/para/pasta/’ -e “palavras que procura”

Para diretórios, é possível excluir um diretório específico através do parâmetro –exclude-dir. Por exemplo, isso excluirá os dirs dir1/, dir2/ e todos eles correspondentes *.dst/:

grep –exclude-dir={dir1,dir2,*.dst} -rnw ‘/caminho/para/pasta/’ -e “palavras que procura”

Para saber mais leia man grep.

Brincando com REGEX no Linux OS

Linux expressoes regulares mais exemplos. Vou usar grep e grep -E.

grep é um utilitário de linha de comando para procurar conjuntos de dados de texto simples para as linhas que correspondem a uma expressão regular.

grep [OPÇÕES] expressão_regular arquivo

grep -E [OPÇÕES] expressão_regular arquivo

Expressão Regular = texto/strings

Caracter Descrição REGEX
. Qualquer letra
^ início da linha
$ final da linha
[xyz] Qualquer das letras dentro dos colchetes
[^xyz] Qualquer letra fora as dentro dos colchetes
[t-z] Qualquer das letras entre t e z
z* Letra z zero ou mais vezes
z+ Letra z uma ou mais vezes
?{0,1} Pode aparecer ou não (opcional)
*{0,} Pode aparecer em qualquer quantidade
+{1,} Deve aparecer no mínimo uma vez
a{2} Casa a letra ‘a’ duas vezes
a{2,4} Casa a letra ‘a’ de duas a quatro vezes
a{2,} Casa a letra ‘a’ no mínimo duas vezes
.* Casa qualquer coisa, é o tudo e o nada
^ início da linha
$ final da linha
[abc] casa com os caracteres a, b e c
[a-c] casa com os caracteres a, b e c
[^abd] não casa com os caracteres a, b e d
(um|dois) casa com as palavras um e dois
Repetições
a{2} casa com a letra “a” duas vezes
a{2,5} casa com a letra “a” duas a cinco vezes
a{2,} casa com a letra “a” duas vezes ou mais
a? casa com “a” letra a zero vezes ou uma
a* casa com a letra “a” zeros vezes ou mais
a+ casa com a letra “a” uma vez ou mais

Curingas/Coringas – Arquivo/Pasta
. casa com qualquer caracter uma vez
.* casa com qualquer caracter várias vezes
(esse|aquele) Casa as palavras ‘esse’ ou ‘aquele’

Eu criei uma pasta chamada TESTES e nela um arquivo de texto chamado passwd. Leio o que tem nele:

TESTES:$ cat ~/TESTES/passwd

23/03/2020

user:dodo:6625:false
baba Shell:sese:shell
user:bash:shell:5959:bash
ipopi:bash:mumu:bash
bobob:bash:pepe:shell
lelel:shell:dede:bash
ododo:shell:Wewe:bash
lolol:Bash:dodo:shell
aveve:bash:Pepe:bash
ioio:bash:7694:false:bash
kekek:Shell:5813:false:bash
Aveve:bash:Pepe:4906:bash
user:false:popi:opepe:bash
dede:yuyu:popo:shell
vivi:55288:eionc:shell
linux:dada:ngng:8592:shell:bash
unix:drtdrt:bgfbgf:3856:shell
a1:eses:1524:uiop:bash
b2:rere:5143:poiu:shell
e3:wewe:2431:uiop:linux
r5:aeae:5134:poiu:bash
h4:gege:2435:uiop:unix
User:false:popi:opepe:bash

Exemplos

Procura a palavra user no arquivo ~/TESTES/passwd

~:$ grep user ~/TESTES/passwd

Procura todas as linhas começadas pela letra u no arquivo:

~:$ grep ‘^u’ ~/TESTES/passwd

Procura todas as linhas terminadas pela palavra false no arquivo:

~:$ grep ‘false$’ ~/TESTES/passwd

Procura todas as linhas começadas pelas vogais no arquivo:

~:$ grep ‘^[aeiou]’ ~/TESTES/passwd

Procura todas as linhas começadas por qualquer caracter e segundo caracter seja qualquer vogal no arquivo:

~:$ grep ‘^.[aeiou]’ ~/TESTES/passwd

Procura todas as linhas que contenham uma sequência de 4 números consecutivos:

~:$ grep ‘[0-9][0-9][0-9][0-9]’ ~/TESTES/passwd

Comando para encontrar linhas em branco:

~:$ grep ‘^$’ ~/TESTES/passwd

Encontrar e contar linhas em branco:

~:$ grep ‘^$’ ~/TESTES/passwd | wc -l

Encontrar mesmo nome, porém com letra inicial minúscula e maiúscula:

grep ‘[Uu]ser’ ~/TESTES/passwd

Encontrar 27 sequência ^ de 27 caracteres:

~:$ grep -E ‘^.{27}$’ ~/TESTES/passwd

Note que foi usado o grep -E e não o grep. É porque as chaves fazem parte de um conjunto avançado de Expressões Regulares (“extended”), então o grep -E lida melhor com elas. Se fosse para usar o grep normal, teria que “escapar” as chaves.

~:$ grep ‘^.\{27\}$’ ~/TESTES/’Linux shell script tomar decisoes.txt’

~:$ grep -E ‘^.{20,40}$’ ~/TESTES/passwd

Para obter as linhas que possuem 40 caracteres ou mais:

~:$ grep -E ‘^.{40,}$’ ~/TESTES/passwd

Econtrar números com 3 dígitos (de 0 a 9) ou mais:

grep -E ‘[0123456789]{3,}’ ~/TESTES/passwd

~:$ grep -E ‘[0123456789]{3,}’ ~/TESTES/passwd

Econtrar linhas que começam com ‘vogal minúscula’ e terminam com a palavra ‘bash’, usa−se o curinga “.*” para significar “qualquer coisa”(não confunda com “qualquer caracterer” somente “.”):

TESTES:$ grep -E ‘^[aeiou].*bash$’ ~/TESTES/passwd
ipopi bash:mumu bash
ododo shell:wewe bash
aveve bash:pepe bash

Procura linhas que comecem com a palavra ‘e3’ ou ‘vivi’ ou ‘user’:

grep -E ‘^(e3|vivi|user)’ ~/TESTES/passwd

Procura todas as linhas que NÃO comecem com a letra minúscula ‘m’

grep -E ‘^[^mumu]’ ~/TESTES/passwd

Continuo a brincar alterando exemplos.

Cola comandos:

Linux comando grep exemplos simples

O comando Grep no Unix/Linux é uma ferramenta poderosa que procura combinar uma expressão regular com o texto em um arquivo, vários arquivos ou um fluxo de entrada. Ele procura o padrão de texto que você especifica na linha de comando e imprime a saída para você. Além disso, três programas variantes egrep, fgrep e rgrep estão disponíveis.

1) egrep é o mesmo que grep -E
2) fgrep é o mesmo que grep -F
3) rgrep é o mesmo que grep -r

A chamada direta do egrep ou do fgrep foi descontinuada, mas é fornecida para permitir que aplicativos históricos que dependem deles sejam executados sem modificação.

Exemplo de comando grep no Unix/Linux: digamos se você deseja pesquisar rapidamente a string linux nos arquivos .html da sua máquina? Aqui, nossa string PATTERN é “linux” e nosso FILE é index.html

Procure uma string “linux” em um arquivo usando o comando grep. Este é o uso básico do comando grep. Ele procura a sequência especificada no arquivo especificado.

grep “linux” index.html

Pesquisa de caso insensível com grep -i. O comando grep abaixo procura por palavras como “LINUX”, “Linux”, “linux” maiúsculas e minúsculas.

grep -i “linux” index.html

Procurando por uma sequência em vários arquivos. Este comando procurará a string “linux” em vários arquivos ao mesmo tempo. Ele pesquisa em todos os arquivos com file1.txt, file2.txt e em diferentes extensões, como file1.html, file2.php e assim por diante.

grep “linux” file*.*

Especificando a sequência de pesquisa como um padrão de expressão regular. É um recurso muito poderoso e pode ser usado como uma expressão regular com muita eficácia. No exemplo abaixo, ele procura por todo o padrão que começa com “fast” e termina com “host” com qualquer coisa intermediária. ou seja, para pesquisar “rapidamente [qualquer coisa no meio] host” no arquivo index.html.

grep “fast.*host” index.html

Procurar no diretório atual somente por arquivos .mp3

find . –name “*.mp3” | grep –i artista | grep –vi “love”

Exibindo os números de linha. Você pode usar este comando grep para exibir o número da linha que contém a sequência correspondente em um arquivo usando a opção -n.

grep -n “palavra*” file.txt

Destacando a pesquisa usando grep. Se usarmos a opção –color, nossas correspondências bem-sucedidas serão destacadas para nós.

grep –color “linux” index.html

Imprima a linha excluindo o padrão usando a opção -v. Liste todas as linhas do arquivo /etc/passwd que não contêm a palavra específica “string”.

grep -v linux /etc/passwd

Remover todas as linhas comentadas? Bem, você pode! Basta executar o seguinte:

grep -v “#” ~/.bashrc

grep -v “#” ~/bin/meu_velho_script.sh

PODE MANDAR A SAÍDA PARA UM ARQUIVO:

grep -v “#” ~/.bashrc > arq_bashrc_sem_coments.txt

grep -v “#” ~/bin/meu_velho_script.sh > velho_script_sem_coment.txt

Exiba todas as linhas que começam com o padrão especificado usando o símbolo ^. O Bash shell trata o símbolo da cenoura (^) como um caractere especial que é tratado como o início da linha. Vamos exibir as linhas que começam com a palavra “raiz” no arquivo /etc/passwd.

grep ^root /etc/passwd

Exiba todas as linhas que terminam com o padrão especificado usando o símbolo $. Liste todas as linhas de /etc/passwd que terminam com a palavra “bash”.

grep bash$ /etc/passwd

Pesquise o padrão recursivamente usando a opção -r. O comando abaixo pesquisará o linux no diretório “/etc” recursivamente.

grep -r linux /etc/

Contando as linhas quando as palavras coincidem. Este comando grep pode relatar o número de vezes que o padrão corresponde a cada arquivo usando a opção -c (count).

grep -c ‘test’ ~/TESTE/test.txt

Conclusão:

Você já foi confrontado com a tarefa de procurar uma determinada sequência ou padrão em um arquivo, mas não tem idéia por onde começar a procurar? Bem, então, aqui está grep para o resgate! Já dá para ter uma idéia do uso básico do comando grep com diferentes padrões de busca. O comando grep é bem útil para quem tem/trabalha com servidor(es) Linux. Mas pode ser útil até mesmo em casa no seu dia-dia.