Linux criar diretórios usando REGEX


Alguém pode me dizer como criar diretórios usando expressão regular? Digamos que eu preciso criar diretórios test01, test02, test03 …. test10. Isso pode ser feito usando qualquer expressão regular?


Crio uma pasta TESTES_01 para executar o comando com regex. Comando:

mkdir -v $(printf “TESTES%02d ” {1..1})


TESTES:$ mkdir -v $(printf “TESTES_%02d ” {1..1})
mkdir: foi criado o diretório ‘TESTES_01’


Vou para ele com o comando cd.

cd TESTES_01/


Agora vou criar diretórios test01, test02, test03 …. test10. Isto pode ser feito com o comando abaixo:

mkdir -v $(printf “test%02d ” {1..10})


Resultado:

TESTES_01:$ mkdir $(printf “test%02d ” {1..10})
mkdir: foi criado o diretório ‘test01’
mkdir: foi criado o diretório ‘test02’
mkdir: foi criado o diretório ‘test03’
mkdir: foi criado o diretório ‘test04’
mkdir: foi criado o diretório ‘test05’
mkdir: foi criado o diretório ‘test06’
mkdir: foi criado o diretório ‘test07’
mkdir: foi criado o diretório ‘test08’
mkdir: foi criado o diretório ‘test09’
mkdir: foi criado o diretório ‘test10’
TESTES_01:$


Posso criar diretórios usando outro comando também:

mkdir -v Test{01..10}

O comando acima vem do zsh


Resultado:

TESTES_01:$ mkdir -v Test{01..10}
mkdir: foi criado o diretório ‘Test01’
mkdir: foi criado o diretório ‘Test02’
mkdir: foi criado o diretório ‘Test03’
mkdir: foi criado o diretório ‘Test04’
mkdir: foi criado o diretório ‘Test05’
mkdir: foi criado o diretório ‘Test06’
mkdir: foi criado o diretório ‘Test07’
mkdir: foi criado o diretório ‘Test08’
mkdir: foi criado o diretório ‘Test09’
mkdir: foi criado o diretório ‘Test10’


Poderia criar diretórios de A até J.

mkdir -v Test_{A..J}


Resultado:

TESTES_01:$ mkdir -v Test_{A..J}
mkdir: foi criado o diretório ‘Test_A’
mkdir: foi criado o diretório ‘Test_B’
mkdir: foi criado o diretório ‘Test_C’
mkdir: foi criado o diretório ‘Test_D’
mkdir: foi criado o diretório ‘Test_E’
mkdir: foi criado o diretório ‘Test_F’
mkdir: foi criado o diretório ‘Test_G’
mkdir: foi criado o diretório ‘Test_H’
mkdir: foi criado o diretório ‘Test_I’
mkdir: foi criado o diretório ‘Test_J’


Para remover todas estes diretórios testes vazios? Uso:

rmdir [tT]*


Se houvesse conteúdo em um dos diretórios:

rm -r [tT]*


Resultado:

TESTES_01:$ rm -r [tT]*
rm: remover diretório ‘Test_A’? y
rm: remover diretório ‘Test_B’? y
rm: remover diretório ‘Test_C’? y
rm: remover diretório ‘Test_D’? y
rm: remover diretório ‘Test_E’? y
rm: remover diretório ‘Test_F’? y
rm: remover diretório ‘Test_G’? y
rm: remover diretório ‘Test_H’? y
rm: remover diretório ‘Test_I’? y
rm: remover diretório ‘Test_J’? y


Podemos criar arquivos de texto usando o regex também.

Exemplo:

TESTES_03:$ touch texto_test_{0..11}.txt
TESTES_03:$ ls
texto_test_0.txt texto_test_1.txt texto_test_4.txt texto_test_7.txt
texto_test_10.txt texto_test_2.txt texto_test_5.txt texto_test_8.txt
texto_test_11.txt texto_test_3.txt texto_test_6.txt texto_test_9.txt

Antes de aplicar algum comando podemos usar o comando echo para testar:

echo {aa,bb,cc,dd,ee} ; echo {0..12} ; echo {a..z}


Exemplo:

$ echo {1..3} {a..c} {1..3}-{a,c}
1 2 3 a b c 1-a 1-c 2-a 2-c 3-a 3-c


E você pode aninhar, usar para instalar/desinstalar ({, des} instalar :)) pacotes. Exemplo:

aptitude install package{,-{dev,doc}}

Que expande para:

aptitude install package package-dev package-doc


Conclusão:

As chaves são uma expansão de shell, pode usá-las com qualquer comando. Para registro, não precisa ser … e não precisa ser letras. Os números funcionam com um intervalo, você pode usar vírgulas para valores independentes e pode misturá-lo com tokens regulares ou outras expansões:


Brincando com REGEX no Linux OS

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

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

grep [OPÇÕES] expressão_regular arquivo

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

Expressão Regular = texto/strings

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

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

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

TESTES:$ cat ~/TESTES/passwd

23/03/2020

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

Exemplos

Procura a palavra user no arquivo ~/TESTES/passwd

~:$ grep user ~/TESTES/passwd

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

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

Procura todas as linhas terminadas pela palavra false no arquivo:

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

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

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

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

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

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

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

Comando para encontrar linhas em branco:

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

Encontrar e contar linhas em branco:

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

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

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

Encontrar 27 sequência ^ de 27 caracteres:

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

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

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

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

Para obter as linhas que possuem 40 caracteres ou mais:

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

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

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

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

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

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

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

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

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

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

Continuo a brincar alterando exemplos.

Cola comandos:

Linux expressões regulares REGEX fácil

O jeito fácil de aprender REGEX

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 todas as linhas serão correspondidas ou nenhuma linha será correspondida ou algum conjunto obscuro. Não se preocupe se isso acontecer, você não causou nenhum dano e pode facilmente voltar e tentar outra vez. Lembre-se de que você pode pressionar a seta para cima no teclado para obter seus comandos recentes e também modificá-los para que você não precise digitar novamente o comando todo o tempo.

Se você não está obtendo o resultado desejado, 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ê-los. Leia novamente o conteúdo aqui. Talvez o que você pensou que um operador em particular fez tenha sido ligeiramente diferente do que realmente faz e, ao ler, 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 idéia de quais partes do padrão estão corretas e quais partes você precisa ajustar.

VISÃO GERAL DA EXPRESSÃO REGULAR

. (ponto) – um único caractere.

? – o caractere anterior corresponde apenas a 0 ou 1 vezes.

* – o caractere anterior corresponde a 0 ou mais vezes.

+ – o caractere anterior corresponde 1 ou mais vezes.

{n} – o caractere anterior corresponde exatamente n vezes.

{n, m} – o caractere anterior corresponde pelo menos n vezes e não mais que m vezes.

[agd] – o caractere é um daqueles incluídos entre colchetes.

[^ agd] – o caractere não é um daqueles incluídos entre colchetes.

[c-f] – o traço entre colchetes funciona como um intervalo. Nesse caso, significa as letras c, d, e ou f.

() – permite agrupar vários caracteres para se comportar como um.

| (símbolo do tubo/pipe) – a operação lógica OR.

^ – corresponde ao início da linha.

$ – corresponde ao final da linha.

Crio uma TESTES e dentro dela um texto-teste.txt. O texto-teste.txt vai conter:

Lago seco 4
Rua Berta 7
Ana Mabra 7
Greg Sila 3
# Bom Dia!
# Boa Tarde!
# Boa Noite!
# Usuário Linux
1- Ele usa Linux
2- Ela usa Linux
3- Nós usamos Linux
1 – Vita:1508:TESTE1:Novo1
2 – Vita:1509:TESTE2:Novo2
3 – Vita:1509:TESTE3:Novo3
Vitas:1518:TESTE1:Novo:1
Vitas:1529:TESTE2:Novo:2
Vitas:1539:TESTE3:Novo:3
Plutão Marte Saturno
Pera Uva Maçã Banana
Bala Bela Bila Bola Bula
Fala Fela Fila Fola Fula

Comece com algo simples. Digamos que desejamos identificar qualquer linha com duas ou mais vogais seguidas. No exemplo abaixo, o multiplicador {2,} se aplica ao item anterior, que é o intervalo.

egrep ‘[aeiou]{2,}’ texto-teste.txt

grep -E ‘[aeiou]{2,}’ texto-teste.txt

Resultado:

TESTES:$ grep -E ‘[aeiou]{2,}’ texto-teste.txt
Rua Berta 7
# Bom Dia!
# Boa Tarde!
# Boa Noite!
# Usuário Linux
TESTES:$

egrep ‘2.+’ texto-teste.txt

grep -E ‘2.+’ texto-teste.txt

Resultado:

TESTES:$ egrep ‘2.+’ texto-teste.txt
2- Ela usa Linux
2 – Vita:1509:TESTE2:Novo2
Vitas:1529:TESTE2:Novo:2

egrep ‘2$’ texto-teste.txt

grep -E ‘2$’ texto-teste.txt

Resultado:
ff
TESTES:$ grep -E ‘2$’ texto-teste.txt
2 – Vita:1509:TESTE2:Novo2
Vitas:1529:TESTE2:Novo:2
TESTES:$

egrep ‘na|ia|no’ texto-teste.txt

grep -E ‘na|ia|no’ texto-teste.txt

Resultados:

TESTES:$ egrep ‘na|ia|no’ texto-teste.txt
Ana Mabra 7
# Bom Dia!
Plutão Marte Saturno
Pera Uva Maçã Banana

TESTES:$ grep -E ‘na|ia|no’ texto-teste.txt
Ana Mabra 7
# Bom Dia!
Plutão Marte Saturno
Pera Uva Maçã Banana
TESTES:$

egrep ‘^[A-K]’ texto-teste.txt

grep -E ‘^[A-K]’ texto-teste.txt

Resultado:

TESTES:$ grep -E ‘^[A-K]’ texto-teste.txt
Ana Mabra 7
Greg Sila 3
Bala Bela Bila Bola Bula
Fala Fela Fila Fola Fula

TESTES:$ egrep ‘^[A-K]’ texto-teste.txt
Ana Mabra 7
Greg Sila 3
Bala Bela Bila Bola Bula
Fala Fela Fila Fola Fula

Agora é criar um arquivo similar e ir brincando reformulando os exemplos.

Dar uma lida na man page do grep e do egrep e usar o que leu.

Praticar sempre que puder diariamente por uma ou duas semanas.

Tenha sempre ao seu lado a VISÃO GERAL DA EXPRESSÃO REGULAR

Assim é que aprende. Praticando todos os dias, em 15 dias (no máximo) provavelmente, já vai saber o suficiente para brincar com o REGEX usando os comandos sed e awk.