Linux bash shell scrip converte arquivo sobrescreve tags, metadata

#!/usr/bin/env bash

# teste_cv_lt_mp4_2_mkv.sh
# versão: 0.0.0 ForeverNow!
# autor: claytu_dinamitti_1000%
# email:
# site:
# data: 29-03-2020_16:27:19
# distro:
# exemplo de uso: ./teste_conv_lt_mp4_2_mkv.sh
# objetivo: converter lotes de mp4 para mkv
# variaveis: VAAR='qualquer_king'
# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção

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

clear

echo -e '\nSobrescrever metadata dos arquivos .mp4 primeiro. Comando:\n\nexiftool -all= -overwrite_original -ext mp4 .\n'

sleep 3

# sobreescreve metadata original (teste)

for i in *.mp4; do
exiftool -all= -overwrite_original -ext "$i" .
done

# sobreescrever metadata original (teste)

exiftool -all= -overwrite_original -ext mp4 .

## Ajusta os títulos? # LOOP FOR RM EXT MP4 NO PLAYER?

for i in *.mp4; do
exiftool "$i" -e info -s title="${i::-4}"
done

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

sleep 3

# Remove metadata?

for i in *.mp4; do
exiftool "$i" --tags all:
done

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

echo -e 'Pronto! Comando executado.\n'
sleep 2
echo -e '\nComando converte em lote mp4 para mkv:\n\nfor i in *.mp4; do ffmpeg -i "$i" -map_metadata -1 -c:v copy -c:a copy -map 0 "${i%.*}.mkv"; done\n'
sleep 4
echo -e 'Executando o comando em 3 segundos...\n'
sleep 3

# CONVERTENDO MP4 PARA MKV

for f in *.mp4; do
ffmpeg -i "$f" -map_metadata -1 -c:v copy -c:a copy -map 0 "${f%.*}.mkv"
done

# FUNCIONA

echo 'Listando arquivos...'
sleep 3
echo ''
ls -t | head
echo ''
sleep 3

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

echo -e '\nAgora corrigindo a extenção dos arquivos convertidos...\n'

# \\ Era para um erro no código acima que foi corrigido \\ #

sleep 3

for f in *.mp4.mkv; do
mv -- "$f" "${f%.mp4.mkv}.mkv"
done

ls -t *.mkv

sleep 4

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

# FUNCIONOU

echo -e 'Comando executado. \nUsando comando para verificar metadata do arquivo criado:\nexiftool *.mkv\n'
sleep 3

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

sleep 4
echo ""

exiftool *.mkv

echo ""

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

ls -tA

sleep 3

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

echo -e '\nSe quiser remover os arquivos originais, use o comando: rm -f *.mp4 \n\nOs arquivos convertidos podem ser renomeados, pois apesar de covertidos para mkv no final deles ficava assim:\n\n mp4.mkv \n\nIsto pode ser feito com o Gprename. \n\nAté Breve! \n\n'

sleep 3

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

echo -e '\nBom, já que a conversão foi testada algumas vezes e bem sucedida, resolvi neste script adicionar o comando de remover o arquivo original mp4 \n\nOBS: Cuidado! Este comando remove tudo que tiver extenção .mp4 \n\nÚltima Chamada: Se quiser cancelar a remoção aperte as teclas Ctrl+C \n\n'
sleep 4

echo '---3-->'
echo ''
sleep 2
echo '---2-->'
echo ''
sleep 2
echo '---1-->'

echo -e '\nRemovendo arquivo .mp4 com o comando:\nrm -rf *.mp4\n'
sleep 2

# remover arquivos mp4

for f in *.mp4; do
rm -rf "$f"
done

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

# LOOP FOR RM EXT MKV NO PLAYER

for f in *.mkv; do
mkvpropedit "$f" -e info -s title="${f::-4}"
done

# remover metadata de mkv

for f in *.mkv; do
mkvpropedit "$f" --tags all: # remove a metadata?
done

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

# remover metadata de mkv

mkvpropedit *.mkv --tags all:

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

# Loop mostra lista (ls -ltA) resultado final

for i in *.mkv; do
ls -ltA "$i" | head
done

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

# listar metadata para conferir

for f in *.mkv; do
echo ""
exiftool "$f"
echo ""
done

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

echo 'Feito!'

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

# fim do script

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

—

Saída condicional while loop com instrução break

—

COMO SAIR DO LOOP WHILE COM A INSTRUÇÃO BREAK?

Você pode sair antecipadamente com a instrução break dentro do loop while. Você pode sair de dentro de um WHILE usando break.

A declaração geral de interrupção dentro do loop while é a seguinte:

—

while [ condição ]
do
afirmações1 # Executado desde que a condição seja verdadeira
# e/ou até condição-desastre caso exista.
afirmações2
if (condição-desastre)
then
break # Abandone o loop while.
fi
afirmações3 # While bom e sem condição de desastre.
done

—

NESTE EXEMPLO ABAIXO, A instrução break ignorará o loop while se…
O usuário digitar -1, caso contrário, continuará adicionando dois números:

—

#!/usr/bin/env bash

while :
do
read -p “Digite dois números ( -1 para sair ) : ” d b
if [ $d -eq -1 ]
then
break
fi
ans=$(( d + b ))
echo $ans
done

# fim do script

—

CONTINUAÇÃO ANTECIPADA COM A INSTRUÇÃO CONTINUE

Para retomar a próxima iteração do loop WHILE anexo, use a instrução continue da seguinte maneira:

—

while [ condição ]
do
afirmações1
# Executado desde que a condição seja verdadeira
# e/ou até condição-desastre caso exista.
afirmações2
if (condição)
then
continue # Vá para a próxima iteração de I no loop e pule as instruções3
fi
instruções3
done

—

Shell do Linux Tipos de loop: Loop While, Loop For, Until Loop.

Instruções de controle usadas para iterar um conjunto de comandos em uma série de dados.

1) Afirmação loop for:

#!/usr/bin/env/bash

# titulo: af_loop_for.sh

for i in 1 2 3 4 5
do
sum=$(expr $sum + $i)
done
echo $sum

# fim do script

—

OBS:
Este programa adicionará 1 + 2 + 3 + 4 + 5 e o resultado será 15

—

Resultado:

~:$ af_loop_for.sh
15
~:$

—

2) afirmação loop while:

#!/usr/bin/env bash

# titulo: af_loop_while.sh

a=1
while [ $a -le 5 ]
do
echo “value of a=” $a
a=`expr $a + 1`
done

# fim do script

—

Este programa imprimirá o valor de ‘a’ cinco vezes, de 1 a 5.

—

Resultado:

~:$ af_loop_while.sh
“value of a=” 1
“value of a=” 2
“value of a=” 3
“value of a=” 4
“value of a=” 5
~:$

—

3) Afirmação loop until

#!/usr/bin/env bash

# titulo: af_loop_until.sh

a=1
until [ $a -ge 3 ]
do
echo “value of a=” $a
a=`expr $a + 1`
done

# fim do script

—

Este programa imprimirá o valor de ‘a’ duas vezes de 1 a 2.

—

Resultado:

~:$ af_loop_until.sh
valor de a= 1
valor de a= 2

—

Ao executar esses loops, pode ser necessário interromper o loop em alguma condição antes de concluir todas as iterações ou reiniciar o loop antes de concluir as instruções restantes. Isso pode ser alcançado com as instruções ‘break’ e ‘continue’.

—

Exemplo:

—

#!/usr/bin/env bash

# titulo: while_do_read_if_then_break_fi.sh

num=1
while [ $num -le 5 ]
do
read var
if [ $var -lt 0 ]
then
break
fi
num=$(expr $num + 1)
done
echo “O loop quebra para números negativos”

—

Resultado:

~:$ while_do_read_if_then_break_fi.sh
3
3
3
3
3
O loop quebra para números negativos

—

As funções permitem dividir a funcionalidade geral de um script em subseções lógicas menores, que podem ser chamadas para executar suas tarefas individuais quando necessário. O uso de funções para executar tarefas repetitivas é uma excelente maneira de criar a reutilização de código. Essa é uma parte importante dos princípios modernos de programação orientada a objetos. As funções do shell são semelhantes às sub-rotinas, procedimentos e funções em outras linguagens de programação. Criando funções. Para declarar uma função, basta usar a seguinte sintaxe:

nome_da_funcao () {
lista de comandos
}

—

Exemplo:

—

#!/usr/bin/env bash

listar () {
ls -lth ~
}

—

Em uma linha:

listar () { ls -lth ~; }

—

Resultado (declara depois chama):

~:$ listar () { ls -lth ~/; }
~:$ listar
total 148K
drwxr-xr-x 29 user user 80K mar 21 04:26 bin
drwxr-xr-x 4 user user 4,0K mar 20 16:47 Downloads
drwxr-xr-x 4 user user 4,0K mar 20 08:24 Música
drwxr-xr-x 7 user usert 4,0K mar 19 08:05 Documentos

—

As funções são as mais fáceis e extremamente úteis para acabar com o tédio das tarefas repetitivas. As possibilidades são muitas.

—

PODEMOS PASSAR PARÂMETROS A UMA FUNÇÃO

Você pode definir uma função que aceite parâmetros ao chamar a função.
Esses parâmetros seriam representados por $ 1, $ 2 e assim por diante.
A seguir, é apresentado um exemplo em que passamos dois parâmetros:

Bola Gol

Em seguida, capturamos e imprimimos esses parâmetros na função.

—

#!/usr/bin/env bash

# titulo: funcoes_parametros_bola.sh

# Defina sua função aqui
Hello () {
echo “Hello World $1 $2”
}

# Invoque a função Hello

Hello Bola Gol

# para $1 Bola para $2 Gol

—

Resultado:

~:$ funcoes_parametros_bola.sh
Hello World Bola Gol

—

Retornando valor da função – Como outras linguagens de programação, o Bash fornece uma declaração de retorno usando que podemos retornar valor ao chamador. Vamos entender isso com o exemplo:

#!/usr/bin/env bash

function func_retorna_valor () {
return 10
}

—

Em uma linha:

function func_retorna_valor () { return 10; } ; func_retorna_valor ; echo “O valor retornado pela função é: $?”

—

Resultado:

~:$ function func_retorna_valor () { return 10; } ; func_retorna_valor ; echo “O valor retornado pela função é: $?”
O valor retornado pela função é: 10

—

NOTA: No bash, temos que usar $? capturar o valor de retorno da função

—

RECEITAS DE FUNÇÕES:

Até agora, tivemos uma boa idéia sobre as funções do bash.
Agora vamos criar algumas funções úteis do bash que podem ser usadas para facilitar nossa vida.

—

Logger

Vamos criar a função de logger que imprimirá data e hora junto com a mensagem de log.

—

#!/usr/bin/env bash

# titulo: data_hora_log_mensagem.sh

function log_msg () {
echo “[`date ‘+ %F %T’` ]: $@”
}

# fim do script

—

EXECUTANDO A FUNÇÃO EM UMA LINHA:

function log_msg () { echo “[`date ‘+ %F %T’` ]: $@”; } ; log_msg “Este é um exemplo de mensagem log”

—

RESULTADO:

~:$ function log_msg () { echo “[`date ‘+ %F %T’` ]: $@”; } ; log_msg “Este é um exemplo de mensagem log”
[ 2020-03-21 05:10:04 ]: Este é um exemplo de mensagem log
~:$

—

Exibir informações do sistema. Vamos criar uma função para exibir informações sobre o sistema GNU/Linux.

—

#!/usr/bin/env bash

# titulo: func_info_sistema.sh

function info_sistema () {
echo “### Informação do SO ###”
lsb_release -a

echo
echo “### Informação do processador ###”
processor=`grep -wc “processador” /proc/cpuinfo`
model=`grep -w “Nome do modelo” /proc/cpuinfo | awk -F: ‘{print $2}’`
echo “Processador = $processor”
echo “Modelo = $model”

echo
echo “### Informação da memória ###”
total=`grep -w “MemTotal” /proc/meminfo | awk ‘{print $2}’`
free=`grep -w “MemLivre” /proc/meminfo | awk ‘{print $2}’`
echo “Memória total: $total kB”
echo “Memória livre: $free kB”
}

# chamando a função

info_sistema

# fim do script

—

Conclusão:

Podemos criar funções com o grande comando find para buscar coisas que sempre precisamos. E podemos usar todos os comandos GNU/Linux.

—

Linux firefox pela linha de comando

—

1) Como executar o Firefox a partir da linha de comando?

2) Como executo o navegador Firefox a partir da linha de comando do Linux (prompt do shell)?

—

Você pode descobrir o caminho completo para o firefox com o seguinte comando de tipo:

type -a firefox

—

Para abrir o navegador, digite:

firefox

OU

/usr/bin/firefox

—

Firefox abre uma URL:

/usr/bin/firefox –new-window https://duckduckgo.com/

—

Abrir firefox em uma nova aba:

firefox –new-tab https://start.duckduckgo.com/

—

Realizar busca com o Firefox:

/usr/bin/firefox –search “linux top 10 comandos”

—

Abrir as preferências do Firefox:

/usr/bin/firefox –preferences

—

Configurar Firefox como browser principal:

/usr/bin/firefox –setDefaultBrowser

—

Linux adicionar data ao nome de um arquivo pelo terminal

—

Tem um arquivo txt. Tem sempre no caminho um arquivo txt. Sh tem um monte de arquivo .sh. Havia um arquivo .sh no caminho e existe 4 (quatro anos) de arquivo .sh.

O objetivo é adicionar data (dia, mês, ano) ao nome de um arquivo declaro uma variável no arquivo .bash_aliases que está na pasta pessoal. Para achar ele digito: cd && ls -a. Usando editor de texto abro o .bash_aliases ou .bashrc e lá no final dele declaro uma variável chamada DDT. Ela fica colorida. Esta variável armazenará um comando. Tudo junto fica assim:

DDT=`date +%d-%m-%Y`.txt

Salvo o arquivo alterado. Tenho que avisar que o arquivo foi alterado com o comando:

source .bash_aliases

Modo de usar é com o comando touch?

Comando:

touch nome_do_arquivo_$DDT

Resultado:

nome_do_arquivo_02-03-2020.txt

Funcionou. Agora, como fazer isto com centenas de arquivos .sh?

Até Breve!

🙂

---

Linux grep básico exemplos

semanickz

Linux uso básico do grep

---

O grep serve para procurar conteúdo em uma string de texto. Para aprender isto é criar um arquivo com strings de texto. Vamos fazer isto agora criando o arquivo texto-do-grep.txt com os comandos abaixo:


1. cd

2. cd ~/Documentos/

3. pwd

4. ls -ltC

5. mkdir EstudoLinux/ ; ls -ltC

6. cd EstudoLinux/

7. pwd

8. date

9. whoami

10. whatis grep


11. echo -e '\nLinux uso básico do grep \nLinux\nLinux e o mundo GNU. \nO GNU é parte do Linux\nAna \nANA \nAnA \nAno \nANO \nAnO \nAni \nbeeg \nboog \n# Comentário \nLuag \nluag \nSemanickz \nsemanickz \nSemanickzaine \nsemanickzaine \nbola \nSEMANICKZAINE \nSEMANICKZ \nbolo \nbole \nzazs \nzezs \nzizs \nzozs \nacunda \naconda \n# start Linux.\nleia \nleio \nleitor \nblog \nbleg \nblig \nboot \nBoot \n# comment\nTexto \ntexto \nTeeexto \nFim \nfom \nfunal do texto.\n# fim #\n' > texto-do-grep.txt


12. ls -AC

13. cat texto-do-grep.txt

14. clear



---

Agora já podemos começar!

Neste estudo, sempre antes de procurar uma string abro e ajeito na tela tres terminais. Todos eles abertos onde está o arquivo texto-do-grep.txt em um deles, uso o comando:

cat texto-do-grep.txt
---

Vejo o conteúdo e crio uma busca de string com o grep no outro terminal.

---

No segundo terminal, digito o comando:

man grep | less

E quando tiver alguma dúvida, uso as setas para cima e para baixo e dou uma olhada no manual de uso do grep. No final do extudo, para siar do comando executado, uso duas teclas. Aperto as teclas Ctrl+c e para fechar o terminal digito o comando exit.

---

No terceiro terminal, executo os comandos de busca usando o grep.

---

Linux Bash comando grep alguns poucos Exemplos para executar no terminal e ler com bastante atenção as saídas destes comandos para entender o que o comando fez, filtrou, incluiu, omitiu, etc:

---

grep semanickz texto-do-grep.txt
grep semanick* texto-do-grep*
grep start texto-do-grep.txt
grep "funal do texto" texto-do-grep.txt
grep -i semanickzaine texto-do-grep.txt
grep -i ana texto-do-grep.txt
grep -c semanickzaine texto-do-grep.txt
grep -ic semanickzaine texto-do-grep.txt
grep -v Ana texto-do-grep.txt
grep -iv Ana texto-do-grep.txt
grep -v Semanickzaine texto-do-grep.txt
grep -iv semanickzaine texto-do-grep.txt
grep Ana *
grep semanickzaine *


---

Procurando recursivamente por Ana em todos os diretórios existentes neste diretório em questão:

grep -r Ana *
grep -lr Ana *


---

Em que arquivo deste diretório está Ana?

grep -l Ana *


---

Usando a ferramenta grep junto com comando cat graças ao pipe. Execute os comandos abaixo:

clear
cat texto-do-grep.txt | grep acunda
clear
cat texto-do-grep.txt | grep -iv Ana


---

OBS:
Para usar comandos Linux o melhor é sempre obter o que precisa digitando o menos possível, mas em certos casos pode ser necessário digitar mais um pouco. Por isto, o Linux oferece ao usuário a criação de aliases. Aqui tem posts sobre como criar aliases. Aqui tem até listas de aliases que podem ser usados ou não por você. É só buscar aqui no blog.

---

Continuando...

---

O sinal -A significa after (depois). -A4 mostra 4 linhas depois da palavra indicada no comando. O sinal -B faz o oposto. Exemplo:

clear

grep -A4 beeg texto-do-grep.txt

grep -B4 beeg texto-do-grep.txt

---

Resultado:

EstudoLinux$ grep -A4
beeg texto-do-grep.txt
beeg
boog
# Comentário
Luag
luag


---

O comando acima é usado para analisar logs. Agora você pode saber o que vem antes e depois de uma string usando o grep.

---

OBS:
O fgrep não usa expressões regulares. O grep e o egrep usam. O melhor para expressões regulares neste momento, até ontem, é o egrep.

---

Tem muito mais a saber, mas isto aqui já dá para fazer bastante coisa e além disto, é um bom começo.

---

Até Breve!

🙂

---

Linux grep, egrep exemplos

semanickz

Linux comandos grep e egrep com exemplos

Linux-grep-egrep-exemplos

Qual é a diferença entre o Grep, o Egrep e o Fgrep no Linux?

Grep, Egrep e Fgrep são renomadas ferramentas de busca em sistemas Linux que podem ser usados ​​para procurar qualquer coisa, seja um arquivo, ou uma linha ou várias linhas no arquivo grep. Ele é muito vasto em funcionalidade, o que pode ser atribuído ao grande número de opções que ele suporta, como: pesquisar usando padrão de strings, ou reg-ex ou reg-ex com base em perl, etc.

Devido às suas diversas funcionalidades, ele possui muitas variantes, incluindo grep, egrep (GREP estendido), fgrep (GREP fixo), pgrep (GREP de processo), rgrep (GREP recursivo) etc. Mas essas variantes têm pequenas diferenças no grep original que as tornou popular e podem ser usado por vários programadores Linux para diferentes tarefas específicas.

A principal coisa que resta a ser investigada é quais são as diferenças entre as três variantes principais grep, egrep e fgrep do grep, que fazem com que os usuários do Linux escolham uma ou outra versão como por requisito.

Alguns Metacaracteres Especiais do grep:

+

Equivalente a uma ou mais ocorrências do caractere anterior.

?

Isso denota pelo menos 1 repetição do caractere anterior. Como a? Corresponderia a ou aa.

(

Início da expressão de alternância.

)

Fim da expressão de alternância.

|

Correspondência da expressão separada por |. Como: (a|b)cde corresponderia a abcde ou bbcde.

{

Este metacaractere indica o início do especificador de intervalo. Como: um {2} corresponde aa no arquivo a 2 vezes.

}

Esse metacaractere indica o especificador de fim de intervalo.

O mais usado deles neste momento para mim talvez seja o egrep. Ele é bom para usar com expressões regulares. Neste momento, só ele me interessa. Mas o egrep vem do grep então o que é grep?

grep ou Global Regular Expression Print é o principal programa de busca em sistemas Linux (Unix-like) que pode procurar qualquer tipo de string em qualquer arquivo ou lista de arquivos ou até mesmo a saída de qualquer comando.

Ele usa expressões regulares básicas, além das strings normais, como um padrão de pesquisa. Em Basic Regular Expressions (BRE), meta-caracteres como:

'{','}','(',')','|','+','?'

Perde o significado e são tratados como caracteres normais de string e precisam ser escapados se forem tratados como caracteres especiais.

grep usa o algoritmo Boyer-Moore para pesquisar rapidamente qualquer string ou expressão regular.

Exemplos:

grep -C 0 '(f|g)ile' check_file
grep -C 0 '\(f\|g\)ile' check_file

Quando o comando é executado sem escapar, ele procura pela string completa no arquivo. Mas quando os caracteres especiais foram escapados, em vez de tratá-los como parte da string, grep os tratou como metacaracteres e buscou por palavras arquivo ou urquivo no arquivo.

Comando Egrep. egrep ou grep -e é outra versão do grep ou do grep estendido. Esta versão do grep é eficiente e rápida quando se trata de procurar um padrão de expressão regular, uma vez que trata meta-caracteres como é e não os substitui como strings como no grep, e, portanto, você está livre do fardo de escapar deles no grep. Ele usa o ERE ou o conjunto de expressões regulares estendidas.

No caso do egrep, mesmo que você não escape dos meta-caracteres, ele os trataria como caracteres especiais e os substituiria por seu significado especial, em vez de tratá-los como parte da string.

Exemplos:

egrep -C 0 '(f|g)ile' check_file
egrep -C 0 '\(f\|g\)ile' check_file

Como aqui, egrep procurou por:

“file”

string quando os meta-caracteres não foram escapados como isso significaria pelo significado desses caracteres. Mas, quando esses caracteres foram escapados, egrep os tratou como parte da string e pesquisou por string completa no arquivo.:

“(f|g)ile”

Exemplo para encontrar apenas arquivos .mp3:

O grep pode ser muito útil para filtrar a partir do stdout.

find . –name “*.mp3” | grep –i nome-do-artista | grep –vi “nome-parcial-da-faixa-que-procuro”

Para saber melhor visite.

Linux REGEX básico bash comandos exemplos

semanickz

Comandos Bash aprenda REGEX Básico

Bash Scripting: Aprenda a usar o REGEX (Básico)

Expressões regulares ou REGEX são basicamente cadeias de caracteres que definem um padrão de pesquisa, elas podem ser usadas para executar operações de 'Pesquisa' ou 'Pesquisa e Substituição', bem como podem ser usadas para validar uma condição como política de senha etc.
É uma ferramenta muito poderosa que está à nossa disposição e a melhor coisa sobre o uso do REGEX é que ele pode ser usados ​​em quase todas as linguagens de computador. Então, se você é do Bash Scripting ou cria um programa em Python, pode usar.
Ou também pode escrever uma consulta de busca em uma única linha.
Existe uma grande possibilidade de talvez num futuro próximo os melhores lugares (seja lá o que isto signifique), estarem destinados as pessoas que tem pelo menos alguma noção de código e me parece neste momento, que o REGEX é importante sob a ótica desta suposição. Não esquecendo que em certos países neste momento, crianças já começam a vida estudantil tendo algo diretamente ligado a código em suas disciplinas.

Podemos usá-los no Bash usando o 'egrep', mas se você quiser usá-los em outros idiomas, como python ou C, você pode usar a parte regex. Começo mostrando um exemplo de regex. REGEX BASH Exemplo:
---
/t[aeiou]l/
---
Mas o que isso significa? Isso significa que o regex mencionado procurará uma palavra que comece com "t", tenha uma das letras "a e o o" no meio e a letra "l" como a última palavra. Pode ser "tel" "tal" ou "til" / Match pode ser uma palavra separada ou parte de outra palavra como "tilt", "brutal" ou "telefone". A sintaxe para usar regex com grep é:
---
egrep “termo-de-busca-REGEX” local-onde-está-o-arquivo

Não se preocupe se estiver parecendo esquisito agora, este foi apenas um exemplo para mostrar o que pode ser alcançado com o REGEX e acredite, este foi o mais simples dos exemplos. Podemos conseguir muito mais a partir dele. Vamos agora começar com o básico.

Noções básicas de Regex:
Agora vamos começar a aprender sobre alguns caracteres especiais que são conhecidos como metacaractéres. Eles nos ajudam a criar um termo de pesquisa mais complexo. A seguir, veja a lista de metacaractéres básicos.

---
. O Ponto
[] Colchetes.
[^] Colchetes e o chapéu do vovô.
* O asterisco.
+ O sinal de mais.
? O ponto de interrogação.
{n,} As chaves que irão encontrar ´n´ números ou itens precedentes.
{,m} Vai encontrar igual ou menos que m números de ítens.
\ A barra invertida que é um caractere de escape usado para incluir um metacaractere que você está procurando em um código, texto, string.

---
"Exemplos:"

Abro pelo menu do sistema, um editor de texto gráfico parecido por exemplo com o editor de texto leafpad e escrevo palavras, frases uma em baixo da outra sem espaços entre elas. Por exemplo as palavras:

bana
bena
bina
bona
buna
Linux
GNU/Linux
mundo linux
Mundo Linux
Estudos Linux
estudos_linux
dog
TaK
Linux
Shane é um pouco para jogar bola
diga
Stdaemon
Subapul
Semprol
Std
Std1
Std8
StdB
Stdstulaktilbaibtemp
digo
dgrub
dgrab
dgrib
Non
Nen
Nin
Nnn
nanan
taeil
tall
lake
lak
laaakkk
Study
Study1
Artorv
arterv
artirv
estudantes
estuudarrte
Study2
Study3
baeb
baib
baoba
estudo
St1234d
Stntfd
Tempk
Termik
Estudo
Laka
lala
tilt
tel
laek
tool
estudo2

---

E salvo o arquivo com o nome de:
Arquivo-estudo-Regex.txt

Aí abro o terminal pelo menú do sistema no diretório onde está este arquivo e executo comandos Linux Bash REGEX. Assim é que a gente aprende.

grep “d.g” Arquivo-estudo-Regex.txt
---
Este regex significa que estamos procurando por uma palavra que comece com d, termine com g e possa ter qualquer caractere no meio do arquivo. Da mesma forma, podemos usar o caractere de ponto qualquer número de vezes para o nosso padrão de pesquisa, como T......H
---
grep “N[oen]n” Arquivo-estudo-Regex.txt
---
Aqui, estamos procurando uma palavra que começa com N, termina com n e só pode ter ou o ou e ou n no meio. Podemos mencionar de um único para qualquer número de caracteres dentro das chaves quadradas (colchetes).
---
grep “St[^1-9]d” Arquivo-estudo-Regex.txt
---
Isso significa que podemos ter todas as palavras que começam com "St", terminam com a letra "d" e não podem conter números de 1 a 9.
---
grep “lak*” Arquivo-estudo-Regex.txt
---
isso significa que podemos combinar com 'lake' ou 'la' ou 'lakkkkk'.
---
grep “lak+” Arquivo-estudo-Regex.txt
---
Aqui, k deve ocorrer pelo menos uma vez em nossa busca, então nossos resultados podem ser 'lake' ou 'lakkkkk' mas não 'la'.
---
grep “ba?b” Arquivo-estudo-Regex.txt
---
A string bb ou bab como com '?' multiplicador podemos ter uma ou zero ocorrência do caractere.
---
OBS:
É muito importante ao usar multiplicadores ficar atento ao exemplo abaixo. Suponha que tenhamos um regex:
---
grep “S.*l” Arquivo-estudo-Regex.txt
---
Neste caso obtemos resultados pequenos, bobos e também temos talvez 'Shane é um pouco para jogar bola'. Mas por que nós pegamos 'Shane é um pouco para jogar bola', nós só estávamos procurando as palavras de nossa busca, então por que nós pegamos esta frase completa na nossa saída?
---
grep “S.*?l” Arquivo-estudo-Regex.txt
---
Isto irá corrigir o comportamento do nosso regex:
---
grep “S.*\.” Arquivo-estudo-Regex.txt
---
E irá procurar e combinar todas as palavras que terminam com um caractere de ponto.
---
"Para saber melhor visite a fonte no final deste post."
---
fonte
---
Aprendendo REGEX Linux Bash
---
Crio um arquivo de texto simples em um editor de texto tipo o leafpad. O nome do arquivo é:
---
mysampledata.txt
---
Colo neste arquivo o mysampledata.txt as linhas abaixo.
---
Fred apples 20
Susy oranges 5
Mark watermellons 12
Robert pears 4
Terry oranges 9
Lisa peaches 7
Susy oranges 12
Mark grapes 39
Anne mangoes 7
Greg pineapples 3
Oliver rockmellons 2
Betty limes 14

---
Abro o terminal onde está o arquivo de texto.
---
Digamos que desejamos identificar todas as linhas que continham a string mellon.
---
egrep 'mellon' mysampledata.txt
---
O comportamento básico do egrep é que ele imprimirá toda a linha para cada linha que contiver uma sequência de caracteres que corresponda ao padrão fornecido. É importante notar que não estamos procurando uma palavra, mas uma sequência de caracteres. Observe também que incluímos o padrão entre aspas. Isso nem sempre é necessário, mas é mais seguro adquirir o hábito de usá-los sempre. Eles são necessários se o padrão contiver caracteres que tenham um significado especial na linha de comando. Às vezes, queremos saber não apenas quais linhas correspondem, mas também o número da linha delas.
---
egrep -n 'mellon' mysampledata.txt
---
Ou talvez não tenhamos interesse em ver as linhas correspondentes, mas queremos saber quantas linhas corresponderam.
---
egrep -c 'mellon' mysampledata.txt
---
REVISANDO: Aprendendo Expressões Regulares. A melhor maneira de aprender expressões regulares é experimentar os exemplos e modificá-los um pouco para testar sua compreensão. É comum cometer erros em seus padrões enquanto você está aprendendo. Quando isso acontece, normalmente cada linha será correspondida ou nenhuma linha será correspondida ou algum conjunto obscuro. Não se preocupe se isso acontecer você não fez nenhum dano e pode facilmente voltar e tentar outra vez. Lembre-se de que você pode pressionar a seta para cima no seu teclado para obter os comandos recentes e modificá-los para não precisar redigitar o comando inteiro a cada vez.
---
Se você não está obtendo o resultado que deseja, aqui estão algumas estratégias básicas. Primeiro, verifique se há erros de digitação. Se você é como eu, então você está propenso a fazê-las. Leia o conteúdo aqui. Talvez o que você pensou que um operador em particular tenha feito seja ligeiramente diferente do que ele realmente faz e lê novamente, você notará um ponto que pode ter perdido na primeira vez.
---
Divida seu padrão em componentes individuais e teste cada um deles individualmente. Isso ajudará você a ter uma ideia de quais partes do padrão estão corretas e de quais partes você precisa ajustar.
---
Examine sua saída. Seu padrão atual pode não ter funcionado como você quer, mas ainda podemos aprender com ele. Observar o que realmente fizemos e usá-lo para ajudar a entender o que realmente aconteceu nos ajudará a descobrir o que devemos tentar mudar para nos aproximarmos do que realmente queremos.
---
As expressões regulares para usar no estudo do REGEX:
---
. (ponto) um único caractere.
? (interrogação) O caractere precedente corresponde a 0 ou 1 somente.
* (asterisco) o caractere anterior corresponde a 0 ou mais vezes.
+ (mais) o caractere anterior corresponde a 1 ou mais vezes.
{n} (n entre chaves) o caractere precedente corresponde exatamente a n vezes.
{n,m} (n vírgula m entre chaves) o caractere precedente corresponde a pelo menos n vezes e não mais que m vezes.
[agd] (agd entre colchetes) "the character is one of those included within the square brackets."
[^agd] - o caractere é um daqueles incluídos entre os colchetes.
[c-f] (c traço f entre colchetes) o traço dentro dos colchetes funciona como um intervalo. Neste caso, significa as letras c, d, e ou f.
() - nos permite agrupar vários caracteres para se comportar como um.
| (pipe) a operação OR lógica.
^ (circunflexo) tem que estar no início da linha.
$ (cifrão) corresponde ao início da linha.

---
Vamos começar.
---
egrep '[aeiou]{2,}' mysampledata.txt
egrep '2.+' mysampledata.txt
egrep '2$' mysampledata.txt
egrep 'or|is|go' mysampledata.txt
egrep '^[A-K]' mysampledata.txt
---
Para saber melhor visite a fonte:
Fonte
---
Até Breve! 🙂
---


Linux whatch exemplos

Linux comando whatch com exemplos

---
Comando watch do Linux - o utilitário watch permite executar um comando repetidamente. A seguir está a sintaxe deste comando:
---
watch [options] command
---
watch executa o comando repetidamente, exibindo sua saída e erros (a primeira tela cheia).
---
Isso permite que você observe a saída do programa mudar ao longo do tempo.
---
Por padrão, o programa é executado a cada 2 segundos. Por padrão, o relógio será executado até ser interrompido. Para interromper aperto duas teclas, as teclas Ctrl+c. A seguir estão alguns exemplos estilizados que devem dar uma boa idéia de como o comando watch funciona.
---
Como funciona o comando watch? O uso básico do watch é muito fácil - tudo o que você precisa fazer é executar a ferramenta com um nome de comando como entrada. Por exemplo:
watch date
---
Como funciona o comando watch? A primeira linha da saída informa que a saída do comando 'date' está sendo atualizada a cada 2 segundos (esse é o intervalo de tempo padrão), seguida pela data / hora atual do sistema. A segunda linha é a saída real do comando 'date' que é atualizada após alguns segundos.
---
Como fazer o relógio destacar a diferença entre as atualizações? Como já explicado na seção anterior, a saída do comando que está sendo rastreado é atualizada regularmente (após 2 segundos, por padrão). Caso você queira, você também pode fazer 'assistir' destacar a parte da saída que está mudando entre as atualizações. Isso você pode fazer usando a opção de linha de comando -d. Por exemplo:
watch -d date
---
Como já explicado, a saída do comando que está sendo rastreado é atualizada regularmente (após 2 segundos, por padrão). Caso você queira, você também pode fazer 'assistir' destacar a parte da saída que está mudando entre as atualizações. Isso você pode fazer usando a opção de linha de comando -d. Por exemplo:
watch -n 5 date
---
Este comando garantirá que a saída seja atualizada a cada 5 segundos. Por favor, note que intervalos inferiores a 0,1 segundos não são permitidos. Nota: Para garantir que o intervalo entre intervalos seja respeitado com muita precisão, use a opção de linha de comando -p.
---
Faça o watch tentar executar o comando a cada intervalo de segundos. Experimente com ntptime e observe como os segundos fracionários ficam quase) o mesmo, ao contrário do modo normal, onde eles aumentam continuamente.
---
Como desligar o cabeçalho na saída? Se desejar, você também pode pedir 'watch' para desativar o cabeçalho, mostrando o intervalo, o comando e a hora atual na parte superior da tela, bem como a seguinte linha em branco. Isso pode ser feito usando a opção de linha de comando -t. Por exemplo:
watch -t date
---
Como fazer o relógio sair quando a saída muda? Se você quiser que o comando 'watch' seja encerrado após a detecção de uma alteração na saída, use a opção de linha de comando -g. Por exemplo:
watch -g free
---
Assim, sempre que o consumo de memória no sistema for alterado, o comando watch será encerrado.
---
Para saber mais visite:
fonte
---
Até breve! 🙂
---

Me zipa, me unzipa!





Linux comandos para compactar diretórios e arquivos

---

OBS:

Sem enrola VPN Gratis

---

O Zip é uma ferramenta de compactação que está disponível na maioria dos sistemas operacionais até ontem.

---

Vamos ver como instalar, usar e dicas sobre o comando zip.

---

Instalação:

Instalar zip e unzip pela central de programas da sua Distro Linux.

---

Tutorial começa

Abra o terminal onde está/estão o(s) arquivo/diretório(s) a ser(em) compactado/descompactado(s) em zip.

---

Zipando arquivos individualmente:

zip -r nome-para-o-arquivo.zip arquivo-a-ser-zipado1 arquivo-a-ser-zipado2 diretório-a-ser-zipado

---

OBS:

Será criado um arquivo zip chamado de nome-para-o-arquivo.zip.

O -r do zip -r é usado para o caso de existirem sub-diretórios dentro do diretório a ser compactado e nesta anotação aqui, estou usando -r em tudo pois, se for apenas um arquivo acredito faz o serviço do mesmo jeito.

---

Para descompactar:

unzip nome-para-o-arquivo.zip

---

OBS:

Se está em outro lugar do sistema acho que dá para descompactar por exemplo:

unzip ~/Downloads/nome-para-o-arquivo.zip

---

Zipando um diretório:

zip -r nome-para-o-diretório-a-ser-zipado.zip ~/caminho/para/o/diretório/

---

Veja só isto abaixo

---

Exemplo terminal aberto onde está o arquivo a ser zipado e então zipando diretório ~/bin/ da home do usuário:

zip -r bin-zipado-2018.zip ~/bin/

---

OBS: Será criado um pacote chamado de bin-zipado-2018.zip.

---

Para descompactar o pacote bin-zipado-2018.zip:

unzip bin-zipado-2018.zip

---

Pode saber informações sobre os pacotes criados com o comando:

ls -lC nome-do-arquivo.zip

ls -lhC caminho/para/o/pacote/zip/nome-do-arquivo.zip

---

Zipar um diretório para um local diferente no sistema?

---

Veja só este exemplo aqui.

Criar um arquivo zip de um PDF que está ~/Documentos/ e se chama fulano.pdf para o diretório ~/Imagens e estou em ~/Vídeos/

---

Exemplo abaixo.

---

1) Criar arquivo fulano.pdf em Documentos com o comando:

touch ~/Documentos/fulano.pdf

2) Ir para o diretório Vídeo:

cd ~/Vídeos/

3) Do diretório Vídeo criar pacote fulano.zip em Imagens sendo que o arquivo está em Documentos:

zip -r ~/Imagens/fulano.zip ~/Documentos/fulano.pdf

---

Conferindo arquivos e pacotes pelo terminal:

1) ls -tlC ~/Imagens/ | head

2) ls -tlC ~/Documentos/ | head

3) ls -tlC ~/Vídeos/ | head

4) pwd

---

OBS:

Abra o seu gerenciador de arquivos e confere se está tudo certo. Para mim funcionou direitinho. Este conhecimento é útil para fazer coisas muitíssimo importantes.

---

Leia o conteúdo de um arquivo compactado sem extrair o arquivo

---

Como posso ler o conteúdo de um determinado arquivo em um arquivo sem extrair o arquivo .zip em que ele está contido?

---

Listar o conteúdo de um arquivo ZIP para saber o que tem dentro dele:

unzip -l nome-do-arquivo.zip

---

Use a opção -c para gravar o conteúdo dos arquivos nomeados na stdout (tela) sem precisar descompactar todo o arquivo. Canalize a saída para menos, caso contrário, todo o arquivo irá para a tela antes que você possa lê-lo.

---

unzip -c nome-do-arquivo.zip | less

unzip -c nome-do-arquivo.zip | head

unzip -c nome-do-arquivo.zip | tail

---

Para saber melhor:

Visite

---

Até Breve!

---

Dicas, críticas e comentários positivos são muito bem-vindos!

🙂

---

fonte

---

Post do semanickz (apenas um "average joe")

---

Quem precisar entrar em contato comigo, por favor, siga o procedimento abaixo por sua própria conta e risco (Kkkkk):

Contate-me!

Tranquilo(a)!




Linux – senha usuário admin root alterar

semanickz

---

Linux – Mudar senha usuário admin root

---

Acho que é mais ou menos assim:

1) Abro terminal pelo menu do sistema.
2) Digito: sudo su
3) Digito: minha senha atual
4) Digito: passwd
5) Teclo Enter
6) Digito a nova senha, Teclo Enter, Digito a nova senha de novo.
7) Digito: passwd nome-meu-usuário-whoami
8) Digito a nova senha, Teclo Enter, Digito a nova senha de novo.
9) Digito: exit e teclo Enter.
10) Reinicio a máquina pelo menu do sistema.

---

Dicas e sugestões são muito bem vindas.

Até Breve!

🙂

Fonte

---

Linux chmod 755, 700, 644

---

Executar o comando chmod apenas nas suas coisas. Apenas na sua home. Apenas nos seus arquivos. Não alterar permissões estabelecidas pelos desenvolvedores do sistema para nada que não seja seu, nada que você mesmo não tenha criado/gravado/armazenado. Pode brincar com seus pendrives, HDs externos, e todos os arquivos que forem seus e nada relacionado ao funcionamento da Distro. Isto pode ser talvez uma coisa esperta de fazer.

---

Se você quiser que todos possam ler (e, portanto, copiar) uma pasta sua, incluindo todas as subpastas, a pasta em questão deve ter 755, bem como todas as subpastas. Normalmente, os arquivos devem ser 644, exceto os executáveis, que devem ser 755

---

chmod -R 755 irá definir isso como permissões para todos os arquivos e pastas na árvore. Mas por que diabos você iria querer isto? Pode fazer sentido para os diretórios, mas por que definir o bit de execução em todos os arquivos?

---

Eu suspeito que o que você realmente quer fazer é configurar os seus diretórios para 755 e deixar os arquivos sozinhos ou configurá-los para 644.

---

Pode ser que seja interessante mudar todos os seus diretórios home para 700 e talvez se você quiser pode mudar todos os seus arquivos para 644.

---

Que tal tentar:

cd /home/
ls -l
sudo chmod -R 700 dir-nome-do-user

Navegar até uma pasta antes do pendrive ou HD externo

ls -l
sudo chmod -R 700 nome-pendrive
sudo chmod -R 700 nome-HD-Externo

Se achar que alguma coisa ficou esquisita, use os mesmos comando acima mas em vez de 700 substitui por 755.
No caso de pendrives, caso ache estranho qualquer coisa pode navegar até uma pasta antes do pendrive ou HD externo e:

ls -l
sudo chmod -R 666 nome-pendrive
sudo chmod -R 666 nome-HD-Externo

Pelo menos é o que eu quase acho que tenho certeza no dia de hoje.

Dicas e sugestões são muito bem vindas.

Até Breve!

🙂

Fonte

Linux qual é a diferença entre chmod 766, 764 e 755?


semanickz

Linux qual é a diferença entre chmod 766, 764 e 755?

---

Primeiro saber valores para calcular permissões e umas outras coisinhas:

---

1. (U) owner - root - As permissões do Proprietário aplicam-se apenas ao proprietário do arquivo ou diretório, elas não afetarão as ações de outros usuários.
2. (G) group - grupo - As permissões do grupo se aplicam somente ao grupo que foi atribuído ao arquivo ou diretório, elas não afetarão as ações de outros usuários.
3. (O) other - todos os outros - As permissões de Todos os usuários se aplicam a todos os outros usuários no sistema. Esse é o grupo de permissões que você mais deseja assistir.

---

1) read - A permissão de leitura refere-se à capacidade do usuário de ler e copiar o conteúdo do arquivo.

2) write - As permissões Write referem-se à capacidade do usuário de gravar ou modificar um arquivo ou diretório.

3) execute - A permissão Executar afeta a capacidade de um usuário de executar um arquivo ou visualizar o conteúdo de um diretório.

OBS:

Os grupos de permissão utilizados são:

(u) Proprietário - (g) Grupo - (o) Outros - (a) Todos os usuários

Diretório home - Os diretórios home dos usuários são importantes porque você não deseja que outros usuários visualizem e modifiquem os arquivos em documentos de outros usuários do desktop. Para remediar isso, você desejará que o diretório tenha as permissões 700, portanto, digamos que queremos impor as permissões corretas no diretório inicial do usuário user, que pode ser feito emitindo o comando chmod 700:

sudo chmod -R 700 user

Arquivos de configuração do sistema e daemon - É muito importante restringir os direitos aos arquivos de configuração do sistema e daemon para impedir que os usuários editem o conteúdo, pode não ser aconselhável restringir as permissões de leitura, mas restringir as permissões de gravação é uma obrigação. Nestes casos, pode ser melhor modificar os direitos para 644.

Scripts de firewall - Pode nem sempre ser necessário impedir que todos os usuários leiam o arquivo de firewall, mas é aconselhável restringir a gravação dos usuários no arquivo. Neste caso, o script de firewall é executado pelo usuário root automaticamente na inicialização, portanto, todos os outros usuários não precisam de direitos, portanto, você pode atribuir as permissões 700.

---

O que significa -rwx-?

---

O - (traço) ANTES de r significa que é um arquivo e não diretório.

---

r = 4, w = 2, x = 1, - = 0

---

1) r vale 4 e significa ler, leitura

2) w vale 2 e significa gravar, escrever (mudar o nome de um arquivo é gravar/escrever. Copiar um arquivo para outra pasta é gravar/escrever.)

3) x vale 1 e significa executar

4) - vale 0 e significa sem permissões

---

Chmod 766 (-rwxrw-rw-)

(chmod a+rwx,g-x,o-x) define permissões para que, o "usuário dono root (U)" possa ler, possa gravar e possa executar. (G) o grupo pode ler, escrever/gravar e não pode executar. (O) todo mundo pode ler, escrever/gravar e não pode executar por exemplo, se baixar um arquivo da internet todo mundo poderá ler, escrever (o arquivo que você baixou da internet se for um software também poderá ler e escrever em seu sistema? Acho que talvez possa, mas como não tem permissão de executar nada ele não pode alterar em nada o seu sistema).

---

Uso do Comando CHMOD octal:

chmod -R 766 nome_diretório

---

Permissões Chmod para chmod 766 (-rwxrw-rw-)

Proprietário Chmod

Proprietário pode ler

Proprietário pode escrever/gravar

Proprietário pode executar

Grupo Chmod

Grupo pode ler

Grupo pode escrever/gravar

Grupo NÃO PODE executar

Chmod other (Public)

Outros podem ler

Outros podem escrever/gravar

Outros NÃO PODEM executar

---

Chmod 764 (-rwxrw-r--)

Chmod 764 (chmod a+rwx,g-x,o-wx) define permissões para que, "usuário dono root" possa ler, possa escrever e possa executar. (G) O grupo pode ler, escrever e NÃO PODE executar. (O) todo mundo pode ler, NÃO PODEM escrever/gravar e NÃO PODEM executar.Se você baixar um arquivo software da internet em um diretório com chmod 764 você do grupo pode ler e gravar ele como usuário comum, mas só pode executar o arquivo se for root porque ele veio lá de "outros" "de fora do seu sistema" o software em si não tem permissão de se auto-executar, executar, nem escrever/gravar nada; mas pode ler e ser lido compreende? Pelo menos é o que eu acho.

Uso do comando CHMOD octal:

chmod -R 764 nome-da-pasta

---

Permissões Chmod para chmod 764 (-rwxrw-r--)

Proprietário Chmod

Proprietário pode ler

Proprietário pode escrever/gravar

Proprietário pode executar

Grupo Chmod

Grupo pode ler

Grupo pode escrever/gravar

Grupo não pode executar

Chmod other

Outros podem ler

---

Comandos Populares do CHMOD:

chmod 766 (-rwxrw-rw-)

chmod 764 (-rwxrw-r--)

chmod 760 (-rwxrw----)

chmod 755 (-rwxr-xr-x)

chmod 744 (-rwxr--r--)

chmod 700 (-rwx------)

chmod 666 (-rw-rw-rw-)

chmod 664 (-rw-rw-r--)

chmod 660 (-rw-rw----)

chmod 655 (-rw-r-xr-x)

chmod 644 (-rw-r--r--)

chmod 600 (-rw-------)

chmod 777 (-rwxrwxrwx)

chmod 755 (-rwxr-xr-x)

chmod 775 (-rwxrwxr-x)

chmod 644 (-rw-r--r--)

chmod 400 (-r--------)

chmod 0777 (-rwxrwxrwx)

chmod 664 (-rw-rw-r--)

chmod 744 (-rwxr--r--)

chmod 770 (-rwxrwx---)

chmod 0755 (-rwxr-xr-x)

chmod 444 (-r--r--r--)

chmod 555 (-r-xr-xr-x)

chmod 4755 (-rwsr-xr-x)

chmod 0600 (-rw-------)

chmod 7777 (-rwsrwsrwt)

chmod 2770 (-rwxrws---)

chmod 2755 (-rwxr-sr-x)

---

Chmod 755 (-rwxr-xr-x)

Chmod 755 (chmod a+rwx,g-w,o-w) define permissões para que, o "usuário dono root" possa ler, possa escrever/gravar e possa executar. (G) O grupo pode ler, não pode escrever e pode executar. (O) todo mundo não pode ler, não podem escrever/gravar e podem executar. Vai poder executar pouca coisa pois para alterar o sistema, tem que ter ser root, acho eu... E se eu um dia baixar um software não oficial de origem duvidosa da internet em um diretório chmod 755 e o software me pedir senha eu não dou e excluo ele na hora aterrorizado(a).

Uso do comando CHMOD octal:

chmod -R 755 folder_name

---

Permissões Chmod para chmod 755 (-rwxr-xr-x)

Proprietário Chmod

Proprietário pode ler

Proprietário pode escrever/gravar

Proprietário pode executar

Grupo Chmod

Grupo pode ler

Grupo NÃO PODE escrever/gravar

Grupo pode executar

Chmod other (Public)

Outros podem ler

Outros NÃO PODEM escrever/gravar

Outros podem executar

Como chmod 755 aparece na listagem de arquivos?

---

Para arquivos:

Depois de alterar o modo de um arquivo para 755, o modo do arquivo será exibido no arquivo de estilo Unix, como:

-rwxr-xr-x

---

Para pastas:

Depois de alterar o modo de diretório para 755, o modo da pasta será exibido no arquivo de estilo Unix, como:

drwxr-xr-x

---

Dicas e sugestões são muito bem vindas.

Até Breve!

 

🙂

Fonte

Linux listinha chmod

semanickz

---

1. (r) = 4 É para Leitura (read) (r) = 4
2. (w) = 2 É para Escrever/Gravar (write) (w) = 2
3. (x) = 1 É para Executar (execute) (x) = 1
4. (-) = 0 Não pode fazer nada (-) = 0

---

1 Usuário Root - 2 Grupo - 3 Outros (public)

---

Permissões:

1) 7 = 4+2+1 (Leitura+Escrita+Execução)

2) 6 = 4+2 (Ler+Escrever)

3) 5 = 4+1 (Leitura+Execução)

4) 4 = 4 (Ler)

5) 3 = 2+1 (Escrever+Executar)

6) 2 = 2 (Gravação)

7) 1 = 1 (Executar)

---

Exemplo:

1) Usuário (root): Ler e escrever (-rw)

2) Grupo: ler e escrever (rw-)

3) Outros (Público): ler (r--)

---

Exemplo de permissões:

1) -rw-rw-r--

2) 664

---

Exemplo para alterar permissões:

1) sudo chmod 664 nome-do-arquivo

2) sudo chmod -R 664 nome-do-diretório

---

Exemplo:

1) Usuário Root:

rwx (7 = 4+2+1 -> Usuário Root) 4+2+1 = 7

2) Grupo:

r-x (6 = 4+0+2 -> Grupo do Usuário) 4+0+2 = 6

3) Outros - Public:

r-- (4 = 4+0+0 -> Outros - Public) 4+0+0 = 4

---

Execução exemplos comandos:

1) lsblk

2) sudo chmod 760 nome-do-arquivo

3) sudo chmod -R 764 nome-do-diretório

4) sudo chmod 666 caminho-para-o-pendrive

5) sudo chmod -R 766 caminho-para-o-driver

6) sudo umount /caminho/HD/Externo

7) sudo chmod -R 0777 /caminho/HD/Externo

8) sudo mount /caminho/HD/Externo

Dicas e sugestões são muito bem vindas.

Até Breve!

🙂

Fonte

Linux alterar permissões de leitura e gravação


semanickz




Como posso alterar as permissões de leitura e gravação em um drive USB no Linux?

---

Alterando permissões de arquivo

---

O comando linux chmod pode ser usado para alterar a permissão de um arquivo ou diretório. A sintaxe básica do comando "chmod" é a seguinte.

---

chmod [option] OCTAL-MODE filename

---

O valor de "OCTAL-MODE" é basicamente um número de 3 dígitos onde o primeiro dígito se refere às permissões para o 'usuário (root)', o segundo dígito refere-se às permissões para o 'grupo' e o terceiro dígito refere-se às permissões para 'outros' usuários e grupos) '. Cada dígito pode ser calculado usando a tabela a seguir:

---

(Read) (r) vale 4
(write) (w) vale 2
(executar) (x) vale 1
(no permission) (-) vale 0

---

Exemplo:
Se você quiser definir a permissão de um arquivo para que o usuário root possa ler, escrever e executar o arquivo sendo que o grupo pode ler e executar e os outros (public) devem apenas poder ler arquivos, a permissão deve ser como
‘-rwxr-xr--’.
Agora podemos encontrar o MODO-OCTAL. Ele precisa ser usado para definir as permissões ‘-rwxr-xr--’.

---

Para parte do usuário (root) -> rwx = 4+2+1 = 7, Para o grupo -> r-x = 4+0+1 = 5, Para os outros -> r-- = 4+0+0 = 4.

---

Portanto, acho que o comando deve ser:

---

chmod 754 filename

Para dar esta permissão apenas para um arquivo penso que pode ser assim:

sudo chmod 754 nome-do-arquivo

Já se for um diretório, acho que pode ser desta forma:

sudo chmod -R 754 nome-do-diretório

Uma coisa interessante das permissões é que dependendo da permissão que você quiser dar, apenas o root pode acessar a pasta que criou em seu sistema. Isto quer dizer que só quem tiver a senha de administrador da máquina tem acesso e poder de fazer o que quiser em determinado arquivo ou diretório. Se não souberem a sua senha não podem fazer nada negativo, nem positivo naquele determinado arquivo ou diretório. Por isto no Linux, manter sua senha segura, é questão de vida ou morte.

Para alguns isto pode parecer um exagero, mas neste momento tem muita gente no mundo que depende totalmente do trabalho armazenado em computador para poder comer o pão de cada dia e elas tem poucos recursos. Milhões não tem dinheiro suficiente para comprar as proteções necessárias para esta vida online extremanente agressiva do dia de hoje. Então é questão de vida ou morte mesmo. Os desenvolvedores que projetam um distribuição Linux decente, os que desenvolvem software open source que funcionam bem; de fato estão salvando vidas.

---

Exemplo:

Se você quiser definir a permissão de um arquivo (-), ou diretório (d) de modo que o usuário possa ler e gravar o arquivo, o grupo possa ler o arquivo e outros não devem ter acesso ao arquivo, a permissão deve ser como ‘-rw-r-----‘.

1) Usuário root do arquivo: -rw-
2) Grupo: r--
3) Outros (Public): ---

OBS: O primeiro traço antes de rw diz que é um arquivo. Se fosse um diretório, em vez de um traço, haveria a letra d. Continuando...

Para usuário -> rw- = 4+2 = 6

Para o grupo -> r-- = 4+0+0 =4

Para os outros -> --- = 0+0+0 =0

Por isso, o comando talvez deva ser:

chmod 640 nome-do-arquivo
OU:
sudo chmod 640 nome-do-arquivo

Se fose um diretório com sub diretórios:

chmod -R 640 nome-do-diretório
OU:
sudo chmod -R 640 nome-do-diretório

---

No Linux e em outros sistemas operacionais semelhantes ao Unix, há um conjunto de regras para cada arquivo que define quem pode acessar esse arquivo e como ele pode acessá-lo. Essas regras são chamadas de permissões de arquivo ou modos de arquivo. O nome do comando chmod significa "modo de mudança" e é usado para definir a maneira como um arquivo pode ser acessado.

---

Em geral, imagino que os comandos chmod assumem o formato:

chmod + opção + número-da-permissão + nome-do-arquivo

---

Digamos que você seja o proprietário de um arquivo chamado myfile e deseje definir suas permissões para que:


1) o usuário possa ler, escrever e executar
2) os membros do seu grupo possam ler e escrever
3) outros só possam ler.

---

Este comando talvez seja útil:

sudo chmod u=rwx,g=rx,o=r nome-do-arquivo

sudo chmod u=rwx,g=rx,o=r caminho-para-o-dispositivo

Acima um usuário pode ler (r) escrever (w) x (executar). O grupo pode ler (r) e executar (x). Outros só podem ler (r)

---

Então...
4 - Indica permissão de leitura (r)
2 - Permissão de escrita (x)
1 - Indica permissão de execução (w)
0 - Indica sem permissões (-)

---

O dono pode ter até três tipos de permissões. Ler (r), escrever (w), executar (x) ou seja: (-rwx) se for aquivo ou (drwx) se for diretório.
O grupo pode ter até três tipos de permissões (rwx)
Os outros podem ter até três tipos de permissões (rwx)
Se só eu uso o notebook, talvez seria mais seguro se tudo que fosse possível só eu pudesse ler, escrever e executar.

---

Tipo de permissão Octal para o dono do arquivo ler e executar, o grupo ler e os outros nada:

Agora é somar e ditar as permissões:

4 + 2 = 6 (permissão de rw-)
4 = 4 (permissão r--)
0 = 0 (permissão ---)

A permissão 640 indica que o arquivo tem permissão:

6 para dono do arquivo
4 para grupo e
0 para outros ou seja:

Ou seja: -rw-r-----

sudo chmod 640 nome-do-arquivo
OU:
sudo chmod -R 640 nome-do-diretório

---

Como alterar as permissões em um pen drive?

---

Precisa saber o que está montado. Para isto o comando abaixo pode ser bastante útil:

lsblk

OU:

sudo fdisk -l

Vai te dizer o que está montado. Então execute:

sudo chmod u=rwx,g=rx,o=r /dev/sdY

OU:

sudo chmod 666 /dev/sdY

Onde sdY é a atribuição do dispositivo para a sua unidade USB. Isso permitirá que você leia e escreva.

---

Concluindo esta anotação, existem sites onde a gente pode obter o chmod do que precisar. Sites que calculam as permissões que você desejar, é só clicar em pequenas caixinhas. Um destes por exemplo, é o chmod-calculator

---

Dicas e sugestões são muito bem vindas.

Até Breve!

🙂

Fonte

Fonte2

Linux pesquisar e localizar

No Linux o comando find é um dos comandos mais importantes e mais usados.

---

O comando é usado para pesquisar e localizar a listar/encontrar arquivos e diretórios com base nas condições especificadas para arquivos que correspondem aos argumentos.

---

O find pode ser usado em várias condições. Você pode encontrar arquivos de permissões de usuários, grupos, tipo de arquivo, data, tamanho e outros vários critérios.

Como encontrar arquivos e pastas no Linux usando a linha de comando?

A maioria das pessoas usa um gerenciador de arquivos gráfico para encontrar arquivos no Linux.

---

No entanto, existem várias maneiras de usar a linha de comando para achar arquivos no Linux, independentemente do gerenciador de área de trabalho que você usa.

---

Usando o comando Find

O comando “find” permite procurar por arquivos que você conhece os nomes aproximados.


---

A forma mais simples do comando procura por arquivos no diretório atual e recursivamente por meio de seus subdiretórios que correspondem aos critérios de pesquisa fornecidos.

---

Você pode procurar arquivos por nome, proprietário, grupo, tipo, permissões, data e outros critérios.

---

Digite o seguinte comando no prompt lista todos os arquivos encontrados no diretório atual. O ponto depois de “find” indica o diretório atual.

find .

O comando find é padronizado para diferenciar maiúsculas e minúsculas. Se você quiser que a busca por uma palavra ou frase seja insensível a maiúsculas e minúsculas, use a opção -iname com o comando find.

---

É a versão insensível do comando -name. Se o "find -iname" não localizar nenhum arquivo que corresponda a seus critérios, ela não produzirá saída.

---

O comando find tem muitas opções disponíveis para refinar a pesquisa.

---

Para obter mais informações sobre o comando find, execute man find em uma janela Terminal e pressione Enter.

Para encontrar arquivos que correspondam a um padrão específico, use o argumento -name. Você pode usar metacaracteres de nome de arquivo (como *), mas deve colocar um caractere de escape (\) na frente de cada um deles ou colocá-los entre aspas. Por exemplo, se quisermos encontrar todos os arquivos que começam com “pro” no diretório Documentos, usaríamos o comando cd Documentos/ para ir ao diretório Documentos e digitaremos o seguinte comando (todos os arquivos no diretório atual começando com “pro” são listados.

find . -name pro\*

Usando o comando Localizar (locate) - O comando locate é mais rápido que o comando find, porque usa um banco de dados previamente construído, enquanto o comando find procura no sistema real, através de todos os diretórios e arquivos reais.

O comando locate retorna uma lista de todos os nomes de caminho que contêm o grupo de caracteres especificado. O banco de dados é atualizado periodicamente do cron, mas você também pode atualizá-lo a qualquer momento para obter resultados atualizados. Para fazer isso, digite o seguinte comando no prompt (digite sua senha quando solicitado):

---

sudo updatedb

---

A forma básica do comando locate localiza todos os arquivos no sistema de arquivos, começando na raiz, que contêm toda ou qualquer parte dos critérios de pesquisa.

locate mydata

Por exemplo, o comando acima encontrou dois arquivos contendo “mydata” e um arquivo contendo “data”. Se você quiser localizar todos os arquivos ou diretórios que contenham exatamente e somente os critérios de pesquisa, use a opção -b com o comando locate, conforme a seguir.

locate -b ‘\mydata’

A barra invertida no comando acima é um "caractere globbing", que fornece uma maneira de expandir os caracteres curinga em um nome de arquivo não específico em um conjunto de nomes de arquivos específicos.

---

Um curinga é um símbolo que pode ser substituído por um ou mais caracteres quando a expressão é avaliada. Os símbolos curinga mais comuns são o ponto de interrogação (?), Que representa um único caractere e o asterisco (*), que representa uma cadeia de caracteres contígua. No exemplo supracitado, a barra invertida desativa a substituição implícita de "mydata" por "*mydata *", por isso você acaba apenas com resultados contendo "mydata".

---

Usando o Comando Which - O comando “which” retorna o caminho absoluto do executável que é chamado quando um comando é emitido. Isso é útil para encontrar o local de um executável para criar um atalho para o programa na área de trabalho, em um painel ou em outro local no gerenciador da área de trabalho. Por exemplo:

which firefox

Por padrão, o comando which exibe apenas o primeiro executável correspondente. Para exibir todos os executáveis correspondentes, use a opção -a com o comando:

which -a firefox

Você pode procurar múltiplos executáveis usando ao mesmo tempo, conforme mostrado na imagem a seguir. Apenas os caminhos para executáveis encontrados são exibidos.

which ps touch sh

NOTA: O comando which pesquisa apenas a variável PATH do usuário atual. Se você procurar por um executável que esteja disponível apenas para o usuário root como usuário normal, nenhum resultado será exibido.

---

Para obter mais informações sobre o comando which, digite “man which” (sem as aspas) no prompt de comando em uma janela do Terminal e pressione Enter.

Até Breve!

 

🙂

Fonte

Mais antigo que o Linux

semanickz

O comando grep é uma das ferramentas mais antigas para o Linux e outras plataformas. Na verdade, é mais antigo que o próprio Linux. Foi escrito por Ken Thompson há mais de 45 anos! O nome grep significa “impressão de expressão globalmente regular”. Esse nome vem de seu predecessor ed e do modo específico em que você procuraria globalmente, usando uma expressão regular, e imprimiria a saída. O comando relacionado era "g/re/p".

O grep pode ser usado em muitas atividades relacionadas ao trabalho ou pessoais. É comum usá-lo para verificar arquivos de configuração e pesquisar arquivos de log. Use o grep para ações simples, ele não precisa de muito para começar a fazer o trabalho.

- A sintaxe do grep consiste em quatro partes:

---

1) comando: grep
2) opcional: opção (s)
3) string para pesquisar
4) arquivo, arquivos ou caminho a ser pesquisado

---

As opções que o grep usa normalmente têm um formato longo e curto. O formato longo tem dois traços, seguidos por uma palavra ou palavras. Use o formato longo em scripts, para que fique óbvio o que o comando grep está fazendo. Use a notação curta em suas tarefas diárias e na linha de comando para economizar na digitação e acelerar o seu trabalho.

Se você quiser de encontrar o usuário root em seu arquivo /etc/passwd, apenas informe o grep para procurar por 'root' e pelo próprio nome do arquivo. Neste caso, nenhuma opção é necessária.

Exemplo(s):
grep root /etc/passwd

---

IGNORAR MAIÚSCULAS E MINÚSCULAS - Agora que executamos um comando grep básico, podemos começar a mudar seu comportamento. Muitas vezes já conhecemos a palavra ou palavras que estamos procurando. O que nem sempre sabemos é se uma ou mais ocorrências da palavra são capitalizadas. Por padrão, o comando grep fará distinção entre maiúsculas e minúsculas. Portanto, apenas a correspondência correta será exibida. Podemos dizer ao grep para ignorar buscas sensíveis a maiúsculas e minúsculas com a opção -i.

Exemplo(s):
grep -i root /etc/passwd

---

MOSTRAR NÚMEROS DE LINHA - Dependendo da sua pesquisa, você pode ter muitas ocorrências do texto que estava procurando. Use a opção -n para que o grep mostre os números de linha relacionados.

Exemplo(s):
grep -n root /etc/passwd/code>

---

EXCLUINDO PALAVRAS - Para excluir palavras ou linhas específicas, use a opção -invert-match. Use grep -v como uma alternativa mais curta. Exclua várias palavras com o grep adicionando -E e use um pipe (|) para definir as palavras específicas. Opcionalmente, torne-o insensível ao -i, conforme listado acima.

Exemplo(s):
grep -i -v -E 'banana|monkey' zoo.txt

---

CONTAGEM DE CORRESPONDÊNCIA - Pode ser útil saber o número de ocorrências da sua palavra especificada. Essa contagem é exibida ao usar grep -c ou grep -c -v para mostrar o número de linhas não correspondentes.

Exemplo(s):
grep -c monkey zoo.txt

---

PESQUISA RECURSIVA ATRAVÉS DE DIRETÓRIOS E ARQUIVOS - Para pesquisar em um diretório, existem as opções -r e -R para conseguir isso. Dependendo do alvo e da existência de links simbólicos, você pode querer usar o primeiro caso não queira segui-lo. Use a opção maiúscula, grep -R, se você quiser incluir qualquer arquivo com link simbólico a ser pesquisado também. Isso pode levar muito mais tempo e resultar em outros sistemas de arquivos a serem pesquisados também. Se você não quiser os nomes dos arquivos na saída, adicione a opção -h.

Exemplo(s):
grep -r password /etc

---

MOSTRAR ARQUIVOS DE CORRESPONDÊNCIA SOMENTE - Às vezes, você só quer ver os arquivos que correspondem a uma determinada seqüência de texto. Existe o comando grep -l para fazer isso. Para mostrar todos os arquivos que não correspondem ao seu destino, use a versão em maiúscula: grep -L.

Exemplo(s):
grep -l -R password /etc

---

USANDO EXPRESSÕES REGULARES - O utilitário grep é uma ferramenta poderosa e pode usar expressões regulares. Expressões regulares podem ser consideradas "regras lógicas" para correspondência de strings de texto. Pense em algo como "Eu sei que a palavra deve começar com a letra 'a', e depois dela tudo está bem". Ao usar uma expressão regular, podemos expressar isso em notação curta (por exemplo, "a.*").

ENCONTRAR apenas palavras específicas - Você pode estar procurando por uma palavra muito curta, mas específica. Nesse caso, o grep retornará muitos resultados. Usando instruções mais específicas, podemos limitar a saída. O \b diz ao grep para usar limites de palavras.

Exemplo(s):
grep "\bbin\b" /etc/passwd

Embora você possa usar espaços para pesquisar uma palavra completa, isso geralmente não gera o resultado correto. Ele retornará alguns hits, enquanto pode estar faltando alguns também. Por exemplo, quaisquer ocorrências no início ou no final do arquivo. Também não haverá correspondência se algum caractere especial for seguido por ele ou até mesmo um caractere simples como uma vírgula. A opção -w faz o mesmo que esta expressão regular e é mais fácil de lembrar.

---

ENCONTRE LINHAS COMANDO COM UMA CADEIA ESPECÍFICA - Com o circunflexo (^), podemos ativar uma expressão regular que define que a linha deve começar com uma parte específica do texto.

Exemplo(s):
grep "^systemd" /etc/passwd

---

ENCONTRAR LINHAS COM UMA CADEIA ESPECÍFICA - Como o símbolo circunflexo (^), podemos usar o cifrão ($) para marcar o fim. Somente as linhas que correspondem a essa, serão retornadas. Uma ótima maneira de encontrar todas as contas que possuem um shell específico configurado.

Exemplo(s):
grep "bin/bash$" /etc/passwd

---

PESQUISA DE MÚLTIPLAS PALAVRAS - Às vezes você quer combinar várias palavras. Usando parênteses, você pode dizer ao grep para procurar uma palavra ou outra. Cada correspondência possível é dividida por um sinal de cano. Use a opção -E para ativar expressões regulares estendidas. Sem isso, o comando não dará nenhum resultado.

Exemplo(s):
grep -E "^(backup|root|syslog)" /etc/passwd

---

COMBINANDO GREP COM OUTRAS FERRAMENTAS - Código de saída - Usar o grep em seus scripts de shell pode ser muito útil. Por exemplo, você pode usá-lo para determinar se um certo arquivo tem a configuração correta e, em seguida, executar uma ação com base nisso. Outra é ver se existe um usuário em particular no seu arquivo / etc / passwd.

Exemplo(s):
grep -q unknown /etc/passwd

OBS: Grep não exibirá nada, mas terminará com um código de saída. Este código de saída será armazenado em uma variável especial com o nome $?. Se você quiser vê-lo na linha de comando, use-o com o echo.

Exemplo(s):
echo $?

Códigos de saída:
0 = correspondência encontrada
1 = nenhuma correspondência encontrada
2 = erro

---

Exemplo de sintaxe para usar o grep em um script de shell:

if $(grep -q unknown /etc/passwd); then echo "unknown está no arquivo passwd"; else echo "unknown não está no arquivo passwd"; fi

---

USANDO PIPES (CANOS) - O comando grep é um ótimo utilitário para usar em combinação e filtrar a saída de outros comandos. Desta forma, a tela mostra apenas os dados que você está interessado. Para conseguir isso, usamos o sinal pipe (|) para dizer ao shell para enviar qualquer saída para o próximo comando na linha. É comum aplicar vários comandos do grep unindo-os. Ao usar arquivos de dados grandes, tente limitar o número de canais para aumentar o desempenho. Você também pode procurar soluções alternativas quando as estiver repetindo com frequência.

Por exemplo, pesquisa na saída do dmesg.

O comando dmesg fornece várias linhas como saída. Se estamos apenas interessados em informações sobre o nosso armazenamento, podemos fazer facilmente pesquisando por "sd".

Exemplo(s):
dmesg | grep sd

Se apenas quiséssemos encontrar eventos relacionados ao AppArmor, faria sentido ignorar o caso devido às maiúsculas no nome. Ao combinar as ferramentas certas, podemos formar um poderoso filtro de dados.

Exemplo(s):
dmesg | grep -i apparmor

Até Breve!

🙂

Fonte

Linux correspondência de padrões

semanickz

Linux anotação linguagens

Anotação expressões regulares

Expressões regulares

Expressões regulares têm suas raízes na teoria da linguagem computacional. A maioria dos estudantes de ciência da computação aprende que as linguagens que podem ser denotadas por expressões regulares são precisamente as mesmas que são aceitas por autômatos finitos. As expressões regulares ... são capazes de expressar mais complexidade e, portanto, não são as mesmas que você pode ter aprendido nas aulas de informática, embora a herança seja clara.
-- Ian Shields

Expressões regulares são um meio poderoso de correspondência de padrões e análise de cadeia de caracteres que podem ser aplicadas em muitas instâncias. Com esta incrível ferramenta você pode:

• Validar entrada de texto
• Pesquisar (e substituir) o texto em um arquivo
• Renomear arquivos em lote
• Realize buscas incrivelmente poderosas por arquivos
• Interaja com servidores como o Apache
• Padrões de teste dentro de seqüências de caracteres
• E muito mais

A coisa sobre expressões regulares é que elas são confusas. Para o usuário Linux, as expressões regulares parecem uma outra língua e na real, elas são mesmo outra língua. Mas não é a linguagem mais difícil do mundo. Depois de uma quatro ou cinco horas de estudo uma pessoa comum já consegue buscar uma string em um arquivo.

Exemplo(s):

egrep -n 'limpeza' texto-teste.txt

Então considerando o poder que essa ferramenta oferece, quem gosta de usar o Bash devia aprender. Não precisa ser apenas admin. O usuário final é de certa forma, o administrador do sistema operacional que instalou em seu hardware. Todavia demore um pouco para dominar as expressões regulares, será um tempo muito bem gasto.

O que compõe as expressões regulares?

Existem dois tipos de caracteres a serem encontrados nas expressões regulares:

• caracteres literais
• metacaracteres

Caracteres literais são caracteres padrão que compõem as strings que você criou. Cada caractere nesta tal frase é um caractere literal. Você poderia usar uma expressão regular para procurar por cada caractere literal nessas strings.

Metacaracteres são completamente diferentes; eles são o que dão às expressões regulares o seu poder. Com metacaracteres, você pode fazer muito mais do que procurar por um único caractere. Metacaracteres permitem pesquisar combinações de strings e muito mais. A lista de metacaracteres de expressões regulares é mais ou menos assim:

\
Indica que o próximo caractere é um caractere especial, um literal, uma referência de referência ou um escape octal

^
Indica o início de uma string de entrada

$
Indica o final da string de entrada

*
Indica que a subexpressão precedente deve ser correspondida zero ou mais vezes

+
Indica que a subexpressão precedente deve ser correspondida uma ou mais vezes

?
Indica que a subexpressão precedente deve ser correspondida como zero ou uma vez

{n}
Corresponde exatamente n vezes (em que n é um inteiro não negativo)

{n,}
Corresponder pelo menos n vezes (em que n é um inteiro não negativo)

{n, m}
Corresponde pelo menos n e no máximo m vezes (onde m e n são inteiros não negativos e n <= m)

.
Corresponde a qualquer caractere único, exceto "n"

[xyz]
Corresponder a qualquer um dos caracteres incluídos

x | y
Corresponder x ou y

[^ xyz]
Corresponder a qualquer caractere não fechado

[a-z]/
Corresponde a qualquer caractere no intervalo especificado.

[^ a-z]
Corresponde a qualquer caractere que não esteja no intervalo especificado

b
Corresponde a um limite de palavra (a posição entre uma palavra e um espaço)

B
Corresponde a um limite nonword (exemplo: 'uxB' corresponde ao 'ux' em "tuxedo" mas não o 'ux' em "Linux"

d
Corresponde a um caractere de dígito

D
Corresponde a um caractere não dígito

f
Corresponde a um caractere de feed de formulário

n
Corresponde a um caractere de nova linha

r
Corresponde a um caractere de retorno de carro

s
Corresponde a qualquer caractere de espaço em branco (incluindo espaço, tabulação, feed de formulário, etc.)

S
Corresponde a qualquer caractere que não seja espaço em branco

t
Corresponde a um caractere de tabulação

v
Corresponde a um caractere de tabulação vertical

w
Corresponde a qualquer caractere de palavra, incluindo sublinhado

W
Corresponde a qualquer caractere não pertencente à palavra

un
Corresponde n, em que n é um caractere Unicode expresso como quatro dígitos hexadecimais (como, por exemplo, u0026 para o símbolo "e" comercial)

---

Como usar metacaracteres?

Simples. Digamos que você queira corresponder a string 1 + 2 = 3.

Embora 1 + 2 = 3 seja uma expressão regular válida, se você tentou procurar essa sequência sem metacaracteres, a correspondência falharia.

Em vez disso, você teria que usar o caractere de barra invertida assim:

1\+2=3

---

Por que estamos usando apenas a barra invertida antes do + e não do =? Volte para a lista de metacaracteres e você verá que + está listado e = não está.

O metacaractere + indica que o precedente deve ser correspondido uma ou mais vezes, então 1 + 2 significaria que 1 é repetido mais duas vezes, como em 111.

Se fôssemos ficar sem \ nessa cadeia, não corresponderia a 1 + 2 = 3, corresponderia a 111 = 2 em 123 + 111 = 234.

---

Alguns exemplos fáceis

Dois outros metacaracteres muito úteis são o ^ (indica o início de uma string de entrada) e $ (indica o final de uma string de entrada). Digamos, por exemplo, que você quisesse pesquisar um longo arquivo de nomes de clientes para todos os clientes cujo sobrenome começasse com W (assumindo que todos os nomes estão listados como sobrenome, primeiro nome no arquivo). Você pode usar expressões regulares com o comando egrep da seguinte forma:

clientes.txt egrep '^W'

O comando resultante listaria todos os clientes cujo sobrenome começou com "W"

---

E se quisermos executar a mesma pesquisa, só que desta vez queremos (por qualquer motivo) listar todos os clientes cujo primeiro nome termina com “n”. Com expressões regulares, podemos fazer isso da seguinte maneira:

egrep ‘n$’ clients.txt

Naturalmente, isso só funcionará se o primeiro nome for a última cadeia de caracteres em cada linha. Se você quisesse listar todos os clientes cujo sobrenome começasse com “N” ou “W”, você poderia fazer uso dos metacaracteres ^ e [] da seguinte forma:

egrep ‘^[NW]’ clients.txt

O comando acima listaria todos os clientes cujo sobrenome começasse com “N” ou “W”

---

E se, no entanto, você quisesse listar clientes cujo primeiro e / ou último nome continha “N” ou “W” (já que isso faz distinção entre maiúsculas e minúsculas, supomos que uma letra maiúscula começará um nome de cliente)? Isso é simples; Adicionamos o metacaractere “|” (juntamente com o metacaractere “^”), que conteria a pesquisa para os primeiros caracteres, assim:

---

egrep ‘^[N|W]’ clients.txt

Também poderíamos remover o metacaractere e executar o comando da seguinte forma:

egrep ‘[NW]’ clients.txt

A saída resultante listaria todos os nomes contendo “N” ou “W”, não limitando a pesquisa aos caracteres iniciais dentro de uma string.

---

Você poderia usar um comando semelhante para procurar por quaisquer caracteres dentro de um nome (como egrep '[en]' clients.txt), que listaria todas as cadeias que continham a letra “e” ou “n”.

E se, no entanto, você quisesse combinar todas as entradas que incluíam o primeiro nome Jack e o primeiro nome Walt? Você pode fazer isso também com a ajuda do metacaractere “|” (que corresponde a x ou y. A seguinte expressão regular ilustra seu uso:

egrep ‘Walt|Jack’ clients.txt

A saída do comando deve ser exatamente como você esperava

---

Um exemplo final ilustrará como você pode usar expressões regulares para pesquisar strings de um tamanho específico. Isso é feito com o que é chamado de conjunto de caracteres. Diga (por qualquer motivo) que você deseja procurar na listagem de clientes por entradas que começam com a letra W e têm apenas seis caracteres. Para isso você usaria o metacaractere “.” Assim:

egrep ‘^[W].....,’ clients.txt

---

Como todos os nomes em nosso arquivo clients.txt são seguidos por um ",", podemos fazer isso facilmente e os resultados exibirão apenas os nomes com seis caracteres e começando com a letra "W"

Isto é apenas a superfície das expressões regulares. Para mais informações sobre esta incrível ferramenta, confira as páginas de manual regex (3) e regex (7). Expressões regulares são definitivamente um elemento da administração do Linux que você vai querer dominar. Aproveite o tempo para se educar mais com essa ferramenta e você terá um poder considerável ao alcance dos seus dedos.

---

Procure a string dada em um único arquivo

O uso básico do comando grep é procurar uma string específica no arquivo especificado, conforme mostrado abaixo.

Sintaxe:

grep "string-literal" nome-do-arquivo

Exemplo(s):

grep "palavra-busca" texto-teste.txt (A "palavra-busca" desejada, está dentro do arquivo texto-teste.txt)

---

Verificando a string dada em vários arquivos.

Sintaxe:

grep "string" padrão-arquivo

---

Este é um uso básico do comando grep. Para este exemplo, vamos copiar texto-teste.txt para texto-teste.txt (cp texto-teste.txt texto-teste1.txt). A saída do grep também incluirá o nome do arquivo na frente da linha que correspondeu ao padrão específico, conforme mostrado abaixo. Quando o shell do Linux vê o meta-caractere, ele faz a expansão e fornece todos os arquivos como entrada para o grep.

grep "palavra-busca" texto*

---

Pesquisa insensível a maiúsculas e minúsculas usando grep -i

Sintaxe:

grep -i "string" ARQUIVO

---

Este também é um outro uso básico do grep. Procura por corda (string) / padrão fornecida insensivelmente (não liga se a letra é maiúscula ou minúscula). Por isso, combina todas as palavras como "o", "O" e "O" caso insensivelmente como mostrado abaixo.

grep -i "palavra-busca" texto-teste.txt

---

Para saber mais, visito: Mais info sobre grep

---

E também nixCraft

Dicas e sugestões são muito bem vindas.

Fonte

Até Breve!

🙂

Linux encontrando arquivos

semanickz

Linux encontrando certo tipo de arquivos

Encontrar somente os arquivos .mp3 em uma pasta cheia de arquivos variados.

O grep pode ser muito útil para filtrar a partir da saída padrão standart do terminal Linux o Bash. Por exemplo, digamos que você tenha uma pasta inteira cheia de arquivos de música em vários formatos diferentes. Você quer encontrar todos os arquivos *.mp3 do artista "unknown" sem aspas, mas você não quer nenhuma das faixas remixadas.

Usar um comando find com alguns canos (pipes) grep fará o desejado.

Exemplo(s):

find . -name “*.mp3” | grep -i unknown | grep –vi “remix”

Neste exemplo acima, estamos usando find para imprimir todos os arquivos com uma extensão *.mp3, colocando-o no grep -i para filtrar e imprimir todos os arquivos com o nome “unknown” e depois outro pipe para grep -vi que filtra e não imprime todos os nomes de arquivos com a string "remix".

Podemos exibir número de linhas antes ou depois da string de uma pesquisa.

Outras duas opções são as opções -A e -B, que exibem a linha correspondente e o número de linhas que vêm antes ou depois da string de pesquisa.

Lembre as opções como -B = antes e -A = depois.

Exemplo(s):

ifconfig | grep -A 4 eth0

ifconfig | grep -B 2 UP

Imprimir o número de linhas relacionadas a correspondência

A opção -C do grep é semelhante, mas em vez de imprimir as linhas que vêm antes ou depois da string, ela imprime as linhas em qualquer direção.

Exemplo(s):

ifconfig | grep -C 2 lo

Contar Número de Correspondências

O comando wc conta palavras, o grep pode fazer o mesmo usando a opção -c.

Exemplo(s):

ifconfig | grep -c inet6

Pesquisar em arquivos por determinada string

A opção –n para o grep é muito útil ao depurar arquivos durante erros de compilação. Ele exibe o número da linha no arquivo da string de pesquisa fornecida.

Exemplo(s):

grep –n “main” setup..py

Pesquisar uma string recursivamente em todos os diretórios

Se você quiser procurar uma string no diretório atual junto com todos os subdiretórios, você pode especificar a opção -r para pesquisar recursivamente.

Exemplo(s):

grep -r “function” *

Procura por todo o padrão

Passar a opção -w para o grep, procura o padrão inteiro que está na string. Confere abaixo.

Exemplo(s):

ifconfig | grep -w “RUNNING”

Vai imprimir a linha que contém o padrão entre aspas.

Por outro lado, você pode tentar:

Exemplo(s):

ifconfig | grep -w “RUN”

Corresponder expressão regular em arquivos

O egrep é outro derivativo que significa “Extended Global Regular Expression”. Reconhece meta-caracteres de expressão adicionais como em +? | e ()

O egrep é muito útil para pesquisar arquivos-fonte e outros trechos de código, caso seja necessário. Pode ser invocado a partir do grep normal, especificando a opção -E.

Exemplo(s):

"grep -E" é igual a "egrep"

 

Dicas e sugestões são muito bem vindas.

Fonte

Até Breve!

 

🙂

 

 

Linux exemplo expressão regular básica

semanickz

Linux expressões regulares exemplos

Bash algumas expressões regulares com exemplos explicados:

Para melhor compreensão expressões regulares são basicamente divididas em 3 tipos:

1) Expressões regulares básicas

2) Expressões regulares com intervalo (usam a opção -E para grep e -r para sed)

3) Expressões regulares estendidas (usam a opção -E para grep e -r para sed)

O que é uma expressão regular?

Uma expressão regular é um conceito de correspondência de um padrão em uma determinada string.

Quais comandos/linguagens de programação suportam expressões regulares?

vi, tr, rename, grep, sed, awk, perl, python etc.

Expressões regulares básicas são um conjunto muito elementar de expressões regulares que não requerem nenhuma opção para executar. Este conjunto de expressões regulares foi desenvolvido há muito tempo atrás.

1) ^ (Símbolo acento circumflexo/Power para buscar coincidências no início da linha.)

2) $ (Para corresponder ao fim da linha.)

3) * (Zero ou mais ocorrência do caractere anterior.)

4) . (Para combinar com qualquer caractere.)

5) [] (Faixa de caráteres.)

6) [^ char] (Nega a ocorrência de um conjunto de caracteres.)

7) (Procura de palavras reais.)

8) (Caracteres de escape.)

Expressão Regular ^

ls -l | grep ^-

O primeiro caractere na saída ls -l, é para arquivos regulares e d para diretórios em uma determinada pasta. O que ^ - indica? O símbolo ^ é para alinhar o começo da linha, ^ - indica as linhas que começam com -, e só exibe estas. No Linux isto indica um arquivo comum, regular.

Para encontrar todos os diretórios em uma pasta, usa a opção grep ^d junto com ls -l . Exemplo abaixo:

ls -l | grep ^d

E o que fazer com caracteres de arquivos e arquivos de bloco?

ls -l | grep ^c

ls -l | grep ^b

Podemos até encontrar as linhas que são comentadas usando ^ operator com o exemplo abaixo:

grep '^#' filename

Que tal encontrar linhas em um arquivo que começa com 'abc'?

grep '^abc' filename

Podemos ter vários exemplos com essa opção.

^.grep '^abc' filename

A expressão regular $

Exemplo de expressão regular $ que corresponde a todos os arquivos terminados em sh:

ls -l | grep sh$ (este comando listará todos os arquivos cujos nomes terminam com sh)

$ indica o fim da linha.

Como encontrar linhas em um arquivo que termina com dead?

grep 'dead$' filename

Que tal encontrar linhas vazias em um arquivo?

grep '^$' filename

Expressão regular *

A expressão regular * corresponde a todos os arquivos que tenham uma palavra twt, twet, tweet etc no nome do arquivo.

ls -l | grep 'twe*t'

Que tal procurar por abble palavra que foi escrita errado em um determinado arquivo onde abble é incorreta como ale, able, abbble, abbbble, abbbbble etc. Para encontrar todos os padrões usa-se a expressão regular:

grep 'ab*le' filename

Expressão regular . (ponto)

A expressão regular . filtra um arquivo que contenha qualquer caractere único entre t e t em um nome de arquivo:

ls -l | grep 't.t'

Aqui . irá corresponder a qualquer caractere único. Pode combinar tat, t3t, t.t, t & t, etc...

Qualquer caractere único entre as letras t e t. Que tal encontrar todos os nomes de arquivos que começam com a e terminam com x usando expressões regulares?

ls -l | grep 'a.*x'

.* (indica qualquer número de caracteres)

OBS: A combinação .* indica qualquer caractere (*) e repetido 0 ou mais vezes.

Até Breve!

🙂

Fonte