Linux traduz texto no terminal

No Linux tem um programa muito útil chamado translate shell que roda no terminal. Decidi escrever um shell script que use este programa. Um script que armazenasse um bloco de texto e usa-se o programa para traduzir o bloco inteiro. Ai cria-se um alias de 3 letras que chama o script então é só digitar/colar o bloco de texto. Isto não é reinventar a roda, é um exercício basico que ensina muitas coisas em muitos aspectos. Confere o script abaixo:

#!/usr/bin/env bash

###################

# titulo: pt_trans_test.sh
# autor: semanickzaine
# site:
# para: traduzir textos longos
# uso: ./pt_trans_test.sh
# versao: 0.1
# data: 14-03-2020
# obs: este script precisa do programa
# Translate Shell
# alias:
# alias tdr=”~/bin/./pt_trans_test.sh”
# teste exemplo:
#
# ~:$ tdr
# Digite o texto a traduzir: I wrote a simpe bash script to demonstrate the next flag. First take a look at the output.
# Showing translation for: (use -no-auto to disable autocorrect)
# Eu escrevi um script bash simples para demonstrar a próxima flag. Primeiro, dê uma olhada na saída.
# Showing translation for: (use -no-auto to disable autocorrect)
# I wrote a simple bash script to demonstrate the next flag. First take a look at the output.
#
#E o serviço tá feito!

###################
# variaveis: variavel padrão do comando read
###################
# Conhecimento é poder?
# O comando read no Linux é uma maneira de os usuários interagirem com as
# entradas retiradas do teclado, que você pode chamar de stdin (entrada padrão)
# ou outras descrições semelhantes. se você quiser que seu script bash receba
# informações do usuário, será necessário usar o comando read.
# read [options] variable_name
# Comando de leitura sem opções – Quando você digita ler sem nenhuma opção
# adicional, é necessário pressionar Enter para iniciar a captura.
# O sistema capturará a entrada até você pressionar enter novamente.
# Por padrão, essas informações serão armazenadas em uma variável chamada:
# $REPLY
# comando:
# read
# hello world
# echo $REPLY
# hello world
# Prompt option -p
# Se você está escrevendo um script e deseja capturar a entrada do usuário,
# existe uma opção de leitura para criar um prompt que pode simplificar seu
# código. Codificar é tudo sobre eficiência, certo? Em vez de usar linhas
# adicionais e comandos de eco, você pode simplesmente usar o sinalizador de
# opção -p. O texto digitado entre aspas será exibido como pretendido e o
# usuário não precisará pressionar Enter para começar a capturar as entradas.
# Então, em vez de escrever duas linhas de código como esta:
# echo “What is your desired username? ”
# read username
# You can use the -p option with read command like this:
# read -p “What is your desired username? ” username
# The input will be saved to the variable $username.
# —————————— #

read -p “Digite o texto a traduzir: ”
for i in REPLY
do
trans -b :pt+eng “$REPLY”
done
echo -e “\nE o serviço tá feito!\n”

# —————————— #

Automatizar tarefas programando com scripts de shell Linux

Dizem que só se aprende shell script escrevendo shell script. Dizem que só se começa a aprender a usar Linux de verdade, quando para de ficar pulando de uma Distro Linux para outra. Dizem que é mais fácil aprender shell script em uma distro amigável para iniciantes. Creio que isto é correto mas, primeiro antes de tudo, todo mundo devia tentar instalar na unha a Distro Arch Linux, mesmo sendo mal sucedido(a) na instalação do Arch Linux, esta prática afia a mente do usuário Linux. Digo estas coisas por experiência própria.

Os scripts de shell foram projetados para serem executados na linha de comandos em sistemas baseados em UNIX. Eles incluem comandos e instruções para executar tarefas específicas. Os scripts de shell são uma maneira eficaz de criar programas pequenos, mas eficientes, para executar e automatizar tarefas do SO.

A programação no UNIX sempre foi um verdadeiro prazer, pois é realmente amigável ao programador em comparação com outros sistemas operacionais. O tratamento se torna melhor com alguns programas compostos por comandos e instruções, que são usados para automatizar muitas das tarefas neste sistema operacional. Mas há certas condições que precisam ser atendidas para obter algo ótimo.

Nesse caso, há muito software e muitos aplicativos que precisam ser ajustados e otimizados para serem executados no UNIX. Isso, no entanto, torna-se extremamente fácil com scripts de shell. Vamos dar uma breve olhada neste formato de codificação.

Basicamente, um shell script é um programa que inclui diferentes comandos e instruções. Esses comandos e as instruções executam tarefas, uma por uma, quando executadas individualmente.

Existem certas coisas que fazemos, para as quais precisamos escrever comandos com muita frequência. Isso é realmente demorado; portanto, escrevemos um programa para executar coletivamente esses comandos e automatizar tarefas.

Outra coisa importante sobre esses programas é que, diferentemente de outros, eles não são compilados, mas interpretados. Isso significa que, ao executar o programa, um shell filho é criado. Todas as operações são executadas nesse shell e esse shell filho termina automaticamente após a conclusão de todas as tarefas no programa.

Para personalizar um script de shell, primeiro precisamos criá-lo da seguinte forma: Para armazenar um programa de texto, precisamos criar um arquivo de texto, Escolha um shell para escrever o script, adicione os comandos necessários ao arquivo, Salve o arquivo, Altere suas permissões para tornar o arquivo executável, execute o programa shell.

Para padronização e portabilidade, usamos o shell Bourne (sh). Para uma personalização adicional, existem diferentes tipos de comandos que abordam quase todos os aspectos do script personalizado. Esses são comandos do sistema de arquivos executáveis do programa, aliases do Linux, funções shell do Linux, palavras reservadas do shell do Linux e comandos internos.

Aqui estão alguns pontos a serem considerados ao escrever um script de shell:

Escreva comentários no código sempre que necessário. Isso ajuda outras pessoas também a entender o mecanismo de trabalho do código com muito mais facilidade. Sair do script assim que houver algum erro nele, pois mesmo o menor erro pode causar danos ao seu sistema. USE AS FUNÇÕES QUE VOCÊ PODE ESCREVER SOZINHO NO SCRIPT, pois é muito mais fácil chamá-lo e depurá-lo. É RECOMENDÁVEL USAR O SINAL $, NO LUGAR DE ASPAS SIMPLES (”), pois nos ajuda a diferenciar entre o processo de substituição e a declaração de comandos.

Dicas e truques da linha de comando?

1) Comando Histórico: Isso nos ajuda a verificar o histórico antigo de quase todos os comandos disparados pelo usuário desde o início.
2) Múltiplos comandos em uma única linha: podemos escrever vários comandos em uma única linha inserindo o operador terminador ‘;’ ou o operador AND ‘&&’ após cada comando e, portanto, executar várias linhas por vez.
3) Ler log: usando o comando ‘tail’, podemos ler os logs de qualquer arquivo em tempo real.
4) Ler arquivos Zip: o comando ‘z’ nos ajuda a ler também arquivos Zip de todos os formatos, mesmo sem extrair os dados reais.
Comandos Alias e Grep: estes são comandos básicos do Linux/UNIX que podem ajudar a ler e editar arquivos e sintaxes facilmente.

As vantagens? Uma característica especial é que o usuário pode executar facilmente vários comandos juntos em um único comando de linha. Os comandos são fáceis de escrever e executar e são usados bem em muitos sistemas automatizados. Operações executadas anteriormente também podem ser rebobinadas e as funções e comandos podem ser executados automaticamente. Suporta quase todos os sistemas que possuem uma arquitetura baseada em UNIX e, portanto, são portáteis de um sistema para outro.

Por exemplo, converter de ogg para mp3. Como fazer isto em um shell script para conveter todos os arquivos .ogg de uma pasta?

Nestes casos de conversão a opção mais fácil e usada, pode procurar por aí, é loop for.

Escrever vários pequenos scripts bobos usando o loop for é um ótimo exercício para aprender a automatizar algumas tarefas no Linux. Com o loop for podemos até criar nossos próprios comandos.

Tento este bash schell script abaixo para exercitar o uso do loop for:

#!/usr/bin/env bash

##################

# titulo: conv_ogg_para_mp3.sh
# uso: ./conv_ogg_para_mp3.sh

##################

clear

# ————– #

echo -e ‘\nRemover metadata dos arquivos .ogg primeiro\n’
sleep 2

# ————– #

echo -e “Removendo metadata…”
sleep 2

# ————– #

# loop for remove metadata
# tenha exiftool instalado

for i in *.ogg; do
exiftool -all= -overwrite_original -ext “$i” .
done

sleep 2
# ————– #

echo -e “\nConvertendo de ogg para mp3…\n”
sleep 3

# ————– #

# loop for converte ogg para mp3
# tenha ffmpeg instalado

for i in *.ogg ; do
ffmpeg -i “$i” -acodec libmp3lame “$(basename “${i/.ogg}”).mp3″
sleep 30
done

# ————– #

echo -e “\nListando arquivos…\n”
sleep 2

# ————– #

ls -tlA
sleep 2

# ————– #

# loop for para conferir metadata mp3

for i in *.mp3; do
exiftool “$i”
done

sleep 2

# ————– #

# loop for para listar mp3 em um arquivo txt

for i in *.mp3; do
ls -t “$i” > lista_mp3_1.txt
done

# ————– #

# loop for para listar ogg em um arquivo txt

for i in *.ogg; do
ls -t “$i” >> lista_ogg_2.txt
done

# ————– #

# loop for remove todos *.ogg do diretorio

echo “————————”
sleep 1
echo “————————”
sleep 1
echo “————————”
sleep 2
echo -e “\n#— revomendo ogg para cancelar tecle [Ctrl+C] —#\n”
sleep 3
echo -e “\n— revomendo em 3 —\n”
sleep 2
echo -e “\n— revomendo em 2 —\n”
sleep 2
echo -e “\n— revomendo em 1 —\n”
sleep 2

for i in *.ogg; do
rm -f “$i”
done

echo -e ‘\nPronto! Comando executado.\n\nTudo resolvido!\n’
sleep 2

# Loop for lista arquivos mp3 do diretorio

for i in *.mp3; do
ls -lth “$i”
done

# fim do shell script

Conclusão:

E por que não tentar usar/melhorar este script acima para fazer o contrário? Usar para converter de mp3 para ogg? Seria um bom exercício. Existe muito arquivo de áudio gratúito legalmente falando, novos artistas que querem divulgar sua arte por exemplo.

Até Breve!

🙂

Dicas e sugestões são bem-vindas!

Linux – aprenda a usar o comando case

Linux - aprenda a usar o comando case

.

Creio que o comando “case” (instrução condicional case) é usado para executar um bloco de código de acordo com o valor de uma variável.

O comando “case” me chama a atenção pois, pode definir diversas opções diferentes sem usar uma estrutura com diversos comandos “if”, “elif” e “else”.

Então devo tentar aprender o uso da instrução case.

Quais serão os: conceitos, sintaxe e prática do case?

---------------

Case é para quando tenho um valor (variável) e vários padrões possíveis para este valor ou vários valores possíveis para uma variável.

Usa-se o case para evitar ficar usando muito o if, else, elif.

O padrão pode ser uma string (corda), número, expressão regular

---------------

Depois do case vem uma variável e depois a palavra in, então vem o padrão. Atendendo o padrão, pode ser realizado uma série de comandos e depois dos comandos fecha com ;; finalizando cada padrão. No final de tudo mesmo, usa-se o asterisco (é como se fosse um else) que é executado se nenhum dos padrões definidos foram encontrados. O fechamento do case é esac (case ao contrário)

---------------

A estrutura do comando case no shell script, serve como se fosse um selector onde eu escolho qual opção desejo para prosseguir.

Digo que estou em um lugar que pede pra fazer certas escolhas. Opção 1 , opção 2 , opção 3...

Cada uma dessas opções irá me levar a um outro lugar ou executa uma determinada ação.

O case é assim. Cria uma lista de opções e eu escolho a opção desejada.

---------------

EXEMPLO:

---------------

case $VARIAVEL in
padrão1)
comandos
;;
padrão2)
comandos
;;
*)
comandos
;;
esac

---------------

USA-SE MUITO O CASE PARA FAZER MENÚ.

---------------

EXEMPLO:

---------------

case $opcao in
1)
echo "Opção Incluir"
;;
2)
echo "Opção Remover"
;;
*)
echo "Opção Inexistente"
;;
esac

---------------

Case - usando expressão regular

---------------

case $caractere in
[0-9])
echo "O caractere informado é um número"
;;
[A-Z])
echo "O caractere informado é uma letra maiúscula"
;;
[a-z])
echo "O caractere informado é uma letra minúscula"
;;
esac

---------------

Executo:

---------------

mkdir -vp caseDIR/subCASE

cd caseDIR/subCASE

touch CasE_scr.sh

chmod +x CasE_scr.sh

pwd

ls -lih

vi CasE_scr.sh

(Aperto Esc, digito i, copio e colo o texto abaixo com o mouse no vi.)

#!/bin/bash

case "$1" in #Uso o parâmetro cifrão 1
[0-9]) #Se for de 0 a 9
echo "O parâmetro é um número"
;;
[A-Z]) #Se for de A a Z
echo "O parâmetro é uma letra maiúscula"
;;
[a-z]) #Se for de a A z
echo "O parâmetro é uma letra minúscula"
;;
*) #Se não for nenhum dos parâmtros acima...
echo "O parâmetro é um caractere especial"
esac

---------------

(Aperto Esc, seguro Shift e digito ZZ)

---------------

Executo:

./CasE_scr.sh

sh CasE_scr.sh A

source CasE_scr.sh a

bash CasE_scr.sh 3

sh CasE_scr.sh @

.

Até Breve

🙂

.

Linux aprenda a usar if, then, else e fi

-----------------------

Linux - Aprenda a usar if, then, else e fi

-----------------------

No GNU/Linux "instruções condicionais" são instruções utilizadas para a "execução condicional" de comandos.

GNU/Linux - Instruções condicionais: Instruções usadas em shell script para executar uma serie de comandos com base em uma condição.

ENTÃO:

Se acontece ISTO uma série de comandos é executada. Se não acontece ISTO, uma OUTRA série de comandos é executada.

Caso aconteça ISTO uma série de comandos é executada. Caso não aconteça ISTO, outra série de comandos é executada.

-----------------------

No shell script para fazer "ISTO", usa-se:

1) if
2) case

-----------------------

Primeira sintaxe - if:

-----------------------

if #começa com "if" mais um "comando-condição" e se for verdadeiro...

then #Então
comando1 #Execute este comando ou esta lista de comandos.
comando2
comando3

fi #Fecha a instrução condicional usando o if ao contrário

-----------------------

Segunda sintaxe - if:

if #Se isto for verdadeiro

then # Então
comando1 #Verdadeiro este comando é executado

else # Se não...
comando2 #Este outro comando é executado

fi #Fecha a instrução condicional o if ao contrário

-----------------------

Terceira sintaxe - if:

-----------------------

Exemplo1:

-----------------------

if #Se isto for verdadeiro
then # Então
comando1 #Execute este comando ou lista de comandos

elif #elif = else if, se não, se acontecer isto...
then #Então
comando2 #Execute este outro comando

else #Se não for verdadeiro...
comando3 #Execute então este outro comando
fi

-----------------------

Exemplo2:

-----------------------

A terceira sintaxe é ou já foi usada dentro dos scripts de inicialização do GNU/Linux. A forma comum acho que é (era):

-----------------------

if [ condição ];
then
comando-instrução1;
comando-instrução2;
comando-instrução3;

...
elif [ condição ];
comando-instrução4;
comando-instrução5;
comando-instrução6;

...
else
comando-instrução7;
comando-instrução8;
comando-instrução9;

...
fi.

-----------------------

Exemplo3:

-----------------------

if [ condição ];

then

comando-instrução1

elif [ condição ];

then

comando-instrução1

else

comando-instrução2

fi

-----------------------

OBS:
O if do shell script tem um comando e verifica se o comando foi executado com sucesso ele cai como verdadeiro tendo código de retorno zero. Se for falso (maior que zero), cai no else ou sai do if.

-----------------------

Tem um comando que faz uma condição. O comando test. O comando test é usado para criar uma condição. A sintaxe é:

test

-----------------------

O comando test tem várias expressões. As mais usadas são do um ao 6.

-----------------------

-eq (equal), -ne (not equal), -gt (greater than), -ge (greater equal), -lt (lower than), -le (lower equal)

-----------------------

1) -eq - é igual a - if [ "$a" -eq "$b" ]

2) -ne - é diferente - if [ "$a" -ne "$b" ]

3) -gt - é maior que - if [ "$a" -gt "$b" ]

4) -ge - é maior ou igual que - if [ "$a" -ge "$b" ]

5) -lt - é menos que - if [ "$a" -lt "$b" ]

6) -le - é menos que ou igual que - if [ "$a" -le "$b" ]

7) < - é menos que - (("$a" = - é maior ou igual que - (("$a" >= "$b"))

-----------------------

Strings podem ser comparadas:

1) = (Uma string igual a outra)

2) != (Uma string diferente da outra)

3) -n (String não nula)

4) -Z (String nula)

-----------------------

Arquivos podem ser testados:

1) -f (É um arquivo)

2) -d (É um diretório/pasta)

3) -r (Tem permissão de leitura)

4) -W (Tem permissão de escrita)

5) -X (Tem permissão de execução)

6) -S (Possui tamanho maior que zero)

-----------------------

EXEMPLOS:

-----------------------

test 25 -gt 50

(25 é maior que 50? Não. O código de saída será 1.)

test "$VALOR1" -eq 15

(O valor da variável VALOR1 é igual a 12? Se for o exit code será zero.)

test -f /tmp/testes

(O arquivo tmp/testes existe? Se existir o exit code será zero. Se não existir será 1)

test "$VALOR1" = "$VALOR2"

(A corda da variável VALOR1 é igual a string da variável VALOR2?)

-----------------------

OBS-IMPORTANTE:

EM VEZ DE ESCREVER A PALAVRA TEST USA-SE COLCHETES COM ESPAÇO

-----------------------

EXEMPLOS:

-----------------------

[ 25 -gt 50 ]

(25 é maior que 50? Não. O código de saída será 1.)

[ "$VALOR1" -eq 15 ]

(O valor da variável VALOR1 é igual a 12? Se for o exit code será zero.)

[ -f /tmp/testes ]

(O arquivo tmp/testes existe? Se existir o exit code será zero. Se não existir será 1)

[ "$VALOR1" = "$VALOR2" ]

(A corda da variável VALOR1 é igual a string da variável VALOR2?)

-----------------------

A FORMA MAIS USADA É COM COLCHETES E ESPAÇO.

-----------------------

OUTRO EXEMPLO:

-----------------------

VALOR1=15
if [ ! "$$VALOR1" -gt 12 ]

# (Negação "!" inverte não entra no fluxo)

# (É dado como falso não entra em lugar nenhum.)

then
echo sucesso
fi

-----------------------

MAIS UM EXEMPLO:

-----------------------

VALOR1=15

if [ "$VALOR1" -gt 12 -a "VALOR1" -lt 20 ]

#AND (-a) se tudo separado pelo -a for verdade terá sucesso se não for não entra em lugar nenhum.

then
echo sucesso
fi

-----------------------

EXEMPLO OR:

-----------------------

VALOR1=15

if [ "$VALOR1" -gt 12 -o "VALOR1" -lt 20 ]

#OR (-o) se pelo menos uma situação for verdade terá sucesso. Se as duas forem falsas, não entra em lugar nenhum.

then
echo sucesso
fi

-----------------------

O -a TEM PREFERÊNCIA SOBRE O -o

-----------------------

Linux - aprendendo a usar o comando test:

-----------------------

Comando de retorno usando test (zero "0" é verdadeiro, um "1" é falso)

-----------------------

Abro o terminal pelo menu do sistema e executo:

-----------------------

1)

test 10 -gt 5 (é maior que)
echo $?

[ 10 -gt 5 ]
echo $?

2)

test 15 -eq 12 (é igual a)
echo $?

[ 15 -eq 12 ]
echo $?

3)

test 8 -ne 12 (é diferente)

echo $?

[ 8 -ne 12 ]
echo $?

4)

test 25 -ge 15 (é maior ou igual que)
echo $?

[ 25 -ge 15 ]
echo $?

5)

test 35 -lt 25 (é menos que)

echo $?

[ 35 -lt 25 ]
echo $?

6)

test 8 -le 10 (é menos que ou igual que)

echo $?

[ 8 -le 10 ]
echo $?

7)

VALOR1=101

8)

test $VALOR1 -eq 101

echo $?

[ $VALOR1 -eq 101 ]
echo $?

9)

test $VALOR1 -gt 90
echo $?

[ $VALOR1 -gt 90 ]
echo $?

10)

test $VALOR1 -ne 15
echo $?

[ $VALOR1 -ne 15 ]
echo $?

-----------------------

Executo:

mkdir -vp PastaIF/SubIF

cd PastaIF/SubIF

touch IfExemp.sh

chmod +x IfExemp.sh

ls -li

pwd

vi IfExemp.sh

(Aperto Esc, digito i, copio e colo o texto abaixo no vi com o mouse.)

#!/bin/bash

if grep "$1" /etc/passwd > /dev/null

# uso o parâmetro cifrão 1

then
echo "Este user existe"
else
echo "Este user não existe"
fi

# Fim do script

----------------------

Aperto Esc, digito Shift ZZ

----------------------

Executo:

whoami

./IfExemp.sh meu-usuário-whoami

./IfExemp.sh Jocam

./IfExemp.sh AnaCa

./IfExemp.sh

----------------------

OUTRO EXEMPLO CRIANDO UMA VARIÁVEL:

----------------------

#!/bin/bash

# Declarando variável: USUWARRIO

USUWARRIO=$(grep "$1" /etc/passwd) #OBS: uso o parâmetro cifrão 1

#OBS: test -n é para ver se uma varivel não é nula

if test -n "$USUWARRIO" #OBS: Colocar a variável entre aspa

then #OBS: se a variável não for nula cai no them
echo "Este user existe"
else
echo "Este user não existe"
fi

# Fim do script

----------------------

POSSO USAR O TEST SINTAXE COLCHETES:

----------------------

#!/bin/bash

# Declarando variável: USUWARRIO

USUWARRIO=$(grep "$1" /etc/passwd)

#OBS-1: uso o parâmetro cifrão 1 entre aspas
#OBS-2: test -n é para ver se uma varivel não é nula
#OBS-3: Colocar a variável entre aspa
#OBS-4: se a variável não for nula cai no then

if [ -n "$USUWARRIO" ]
then
echo "Este user existe"
else
echo "Este user não existe"
fi

# Fim do script

----------------------

PARA EXECUTAR O SCRIPT:

----------------------

touch 2IfExemp.sh

chmod +x 2IfExemp.sh

vi 2IfExemp.sh

(Aperto Esc, digito i, copio e colo o texto no vi com o mouse.)

----------------------

Aperto Esc, Seguro a tecla Shift, digito: ZZ

----------------------

Executo:

ls -lit

pwd

whoami

----------------------

Executo:

./2IfExemp.sh meu-usuário-whoami

./2IfExemp.sh JeCam

./2IfExemp.sh UneCo

./2IfExemp.sh root

----------------------

MAIS OUTRO EXEMPLO:

----------------------

#!/bin/bash

# Declarando variável: USUWARRIO

USUWARRIO=$(grep "$1" /etc/passwd)

#OBS-1: uso o parâmetro cifrão 1 entre aspas
#OBS-2: test -n é para ver se uma varivel não é nula
#OBS-3: Colocar a variável entre aspa
#OBS-4: se a variável não for nula cai no then

if [ -n "$USUWARRIO" ]
then
echo "Este user existe"
if [ "$USUWARRIO" = root ]
then
echo ok
fi
else
echo "Este user não existe"
fi

# Fim do script

----------------------

CONTINUANDO COM EXEMPLOS:

----------------------

#!/bin/bash

# Declarando variável: USUWARRIO

USUWARRIO=$(grep "$1" /etc/passwd)

#OBS-1: uso o parâmetro cifrão 1 entre aspas
#OBS-2: test -n é para ver se uma varivel não é nula
#OBS-3: Colocar a variável entre aspa
#OBS-4: se a variável não for nula cai no then
#OBS-5: "if test $# -gt 0" - O cifrão mais cerquilha testa se foi inserido algum parâmetro. Se o parâmetro for maior que zero prossegue.

if test $# -gt 0
then
echo 'Foi inserido um valor maior que zero. Prosseguindo...'
else
echo 'Informe um nome como parâmetro.' ; exit

fi

if [ -n "$USUWARRIO" ]
then
echo "Este user existe"
else
echo "Este user não existe"
fi

# Fim do script

----------------------

PARA EXECUTAR O SCRIPT:

----------------------

touch 3IfExemp.sh

chmod +x 3IfExemp.sh

vi 3IfExemp.sh

(Aperto Esc, digito i, copio e colo o texto no vi com o mouse.)

----------------------

Aperto Esc, Seguro a tecla Shift, digito: ZZ

----------------------

Executo:

ls -lit

pwd

whoami

----------------------

Executo:

----------------------

1) ./3IfExemp.sh

2) ./3IfExemp.sh meu-usuário-whoami

3) ./3IfExemp.sh JeCam

4) ./3IfExemp.sh UneCo

5) ./3IfExemp.sh root

----------------------

UM EXEMPLO PARECIDO, USANDO TEST COLCHETES:

----------------------

#!/bin/bash

# Declarando variável: USUWARRIO

USUWARRIO=$(grep "$1" /etc/passwd)

#OBS-1: uso o parâmetro cifrão 1 entre aspas
#OBS-2: test -n é para ver se uma varivel não é nula
#OBS-3: Colocar a variável entre aspa
#OBS-4: se a variável não for nula cai no then
#OBS-5: "if test $# -gt 0" - O cifrão mais cerquilha testa se foi inserido algum parâmetro. Se o parâmetro for maior que zero prossegue.

if [ $# -gt 0 ]
then
echo 'Foi inserido um valor maior que zero. Prosseguindo...'
else
echo 'Informe um nome como parâmetro e execute novamente o script.'
echo
sleep 2
echo 'Para obter o nome do usuário digite: whoami antes de executar o script.'
sleep 2
echo
exit

fi

if [ -n "$USUWARRIO" ]
then
echo "Este user existe"
else
echo "Este user não existe"
fi

----------------------

Pronto! Nós sabemos usar if, then, else e fi.

----------------------

Até Breve!

🙂

.

Linux – aprendendo a usar o comando test

Linux - aprendendo a usar o comando test:

-----------------------

Comando de retorno usando test (zero "0" é verdadeiro, um "1" é falso)

-----------------------

1) test 10 -gt 5 (é maior que)
echo $?

2) test 15 -eq 12 (é igual a)
echo $?

3) test 8 -ne 12 (é diferente)
echo $?

4) test 25 -ge 15 (é maior ou igual que)
echo $?

5) test 35 -lt 25 (é menos que)
echo $?

6) test 8 -le 10 (é menos que ou igual que)
echo $?

7) VALOR1=101

8) test VALOR1 -eq 101
echo $?

9) test VALOR1 -gt 90
echo $?

10) test VALOR1 -ne 15

-----------------------

Até Breve!

🙂

.

GNU/Linux “instruções condicionais”

.

Linux - Instruções condicionais

.

No GNU/Linux "instruções condicionais" são instruções utilizadas para a "execução condicional" de comandos.

.

GNU/Linux - Instruções condicionais: Instruções usadas em shell script para executar uma serie de comandos com base em uma condição.

.

Se acontece ISTO uma série de comandos é executada. Se não acontece ISTO, uma OUTRA série de comandos é executada.

Caso aconteça ISTO uma série de comandos é executada. Caso não aconteça ISTO, outra série de comandos é executada.

-----------------------

No shell script para fazer "isto", usa-se:

1) if
2) case

-----------------------

Primeira sintaxe - if:

if #começa com "if" mais um "comando-condição" e se for verdadeiro...

then #Então
comando1 #Execute este comando ou esta lista de comandos
comando2
comando3

fi #Fecha a instrução condicional usando o if ao contrário

-----------------------

Segunda sintaxe - if:

if #Se isto for verdadeiro

then # Então
comando1 #Verdadeiro este comando é executado

else # Se não...
comando2 #Este outro comando é executado

fi #Fecha a instrução condicional o if ao contrário

-----------------------

Terceira sintaxe - if:

-----------------------

Exemplo1:

-----------------------

if #Se isto for verdadeiro
then # Então
comando1 #Execute este comando ou lista de comandos

elif #elif = else if, se não, se acontecer isto...
then #Então
comando2 #Execute este outro comando

else #Se não for verdadeiro...
comando3 #Execute então este outro comando
fi

-----------------------

Exemplo2:

-----------------------

A terceira sintaxe é ou já foi usada dentro dos scripts de inicialização do GNU/Linux. A forma comum acho que é (era):

-----------------------

if [ condição ];
then
comando-instrução1;
comando-instrução2;
comando-instrução3;

...
elif [ condição ];
comando-instrução4;
comando-instrução5;
comando-instrução6;

...
else
comando-instrução7;
comando-instrução8;
comando-instrução9;

...
fi.

-----------------------

Exemplo3:

-----------------------

if [ condição ];

then

comando-instrução1

elif [ condição ];

then

comando-instrução1

else

comando-instrução2

fi

-----------------------

OBS:
O if do shell script tem um comando e verifica se o comando foi executado com sucesso ele cai como verdadeiro tendo código de retorno zero. Se for falso (maior que zero), cai no else ou sai do if.

-----------------------

Tem um comando que faz uma condição. O comando test. O comando test é usado para criar uma condição. A sintaxe é:

test

-----------------------

O comando test tem várias expressões. As mais usadas são do um ao 6.

-----------------------

-eq (equal), -ne (not equal), -gt (greater than), -ge (greater equal), -lt (lower than), -le (lower equal)

-----------------------

1) -eq - é igual a - if [ "$a" -eq "$b" ]

2) -ne - é diferente - if [ "$a" -ne "$b" ]

3) -gt - é maior que - if [ "$a" -gt "$b" ]

4) -ge - é maior ou igual que - if [ "$a" -ge "$b" ]

5) -lt - é menos que - if [ "$a" -lt "$b" ]

6) -le - é menos que ou igual que - if [ "$a" -le "$b" ]

7) < - é menos que - (("$a" < "$b"))

8) "$b"))

10) >= - é maior ou igual que - (("$a" >= "$b"))

-----------------------

Strings podem ser comparadas:

1) = (Uma string igual a outra)

2) != (Uma string diferente da outra)

3) -n (String não nula)

4) -Z (String nula)

-----------------------

Arquivos podem ser testados:

1) -f (É um arquivo)

2) -d (É um diretório/pasta)

3) -r (Tem permissão de leitura)

4) -W (Tem permissão de escrita)

5) -X (Tem permissão de execução)

6) -S (Possui tamanho maior que zero)

-----------------------

EXEMPLOS:

# test 25 -gt 50 (25 é maior que 50? Não. O código de saída será 1.)

# test "$VALOR1" -eq 15 (O valor da variável VALOR1 é igual a 12? Se for o exit code será zero.)

# test -f /tmp/testes (O arquivo tmp/testes existe? Se existir o exit code será zero. Se não existir será 1)

# test "$VALOR1" = "$VALOR2" (A corda da variável VALOR1 é igual a string da variável VALOR2?)

-----------------------

OBS-IMPORTANTE:

EM VEZ DE ESCREVER A PALAVRA TEST USA-SE COLCHETES COM ESPAÇO

-----------------------

EXEMPLOS:

[ 25 -gt 50 ] (25 é maior que 50? Não. O código de saída será 1.)

[ "$VALOR1" -eq 15 ] (O valor da variável VALOR1 é igual a 12? Se for o exit code será zero.)

[ -f /tmp/testes ] (O arquivo tmp/testes existe? Se existir o exit code será zero. Se não existir será 1)

[ "$VALOR1" = "$VALOR2" ] (A corda da variável VALOR1 é igual a string da variável VALOR2?)

-----------------------

A FORMA MAIS USADA É COM COLCHETES E ESPAÇO.

-----------------------

OUTRO EXEMPLO:

VALOR1=15
if [ ! "$$VALOR1" -gt 12 ] #Negação (!) inverte não entra no fluxo

#É dado como falso não entra em lugar nenhum.

then
echo sucesso
fi

-----------------------

MAIS UM EXEMPLO:

-----------------------

VALOR1=15

if [ "$VALOR1" -gt 12 -a "VALOR1" -lt 20 ] #AND (-a) se tudo separado pelo -a for verdade terá sucesso se não for não entra em lugar nenhum.

then
echo sucesso
fi

-----------------------

EXEMPLO OR:

VALOR1=15

if [ "$VALOR1" -gt 12 -o "VALOR1" -lt 20 ] #OR (-o) se pelo menos uma situação for verdade terá sucesso. Se as duas forem falsas, não entra em lugar nenhum.

then
echo sucesso
fi

-----------------------

O -a TEM PREFERÊNCIA SOBRE O -o

-----------------------

Linux – Declarar variáveis torna o shell script mais fácil

#!/bin/bash

# Nome do Script: 5ScrNomeUserUID.sh

# Descrição: script recebe um
# nome de usuário como parâmetro
# e exibe UID do usuário, Nome Completo /
# Descrição do Usuário, Total em Uso no /home do
# usuário, Informações do último login do usuário,
# Validar se o usuário existe
# ou não sem o uso do if.
# Se não existir retorne o exit code 1, se
# existir retorne exit 0

# Execução: ./5ScrNomeUserUID.sh
# Autor: Fulano de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail@email.com
# Histórico de modificações:

# COMENTÁRIO:
# Comando “du” para descobrir
# o uso do diretório
# Comando “lastlog” para
# informações do login
# Dados do usuário no
# arquivo /etc/passwd
# Para fazer a validação posso usar
# as opções de execução sequencial
# de comandos &&, ou ;

# COMENTÁRIOS ESPECIAIS:

# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção - Cuidado para não usar dentro do script a variável de ambiente UID

#ls /home/$1 > /dev/null 2>&1 || echo "Usuário Inexistente"
#ls /home/$1 > /dev/null 2>&1 || exit 1

#ls /home/$1 > /dev/null 2>&1 || { echo "Usuário Inexistente" ; exit 1;}

# Declarando 4 variáveis:
ESERU=$(echo $USER)
USERLOGIN=$(lastlog -u $USER | grep $USER)
UIDUSER=$(echo $UID)
TOTAL=$(du -hs ~/ | cut -f1)

clear
echo "Relatório do Usuário: $ESERU"
echo
echo "UID do usuário: $UIDUSER"
echo "Nome ou Descrição: $ESERU"
echo "Ultimo Login: $USERLOGIN | grep "
echo "Total Usado no ultimo Login: $TOTAL"
echo
# Fim do Script

---------------

Para Praticar:

---------------

Colo o comando "echo -e" com o parâmetro abaixo no terminal redirecionando com o write ">" para um arquivo de texto:

---------------

echo -e '\nO Marco Marciano\n \nPelos alto-falantes do universo \nVou louvar-vos aqui na minha loa\nUm trabalho que fiz noutro planeta \nOnde nave flutua e disco voa \nFiz meu marco no solo marciano \nNum deserto vermelho sem garoa \n \nEste marco que eu fiz é fortaleza. \nElevando ao quadrado Gibraltar! \nTorreão, levadiço, raio-laser \nE um sistema internet de radar \nNão tem sonda nem nave tripulada \nQue consiga descer nem decolar. \n\nConstrui o meu marco na certeza \nQue ninguém, cibernético ou humano. \nPoderia romper as minhas guardas \nNem achar qualquer falha nos meus planos \nFicam todos em Fobos ou em Deimos \nContemplando o meu marco marciano \n \nO meu marco tem rosto de pessoa \nTem ruínas de ruas e cidades \nTem muralhas, pirâmides e restos \nDe culturas, demônios, divindades \nA história de Marte soterrada \nPelo efêmero pó das tempestades \n
\nConstrui o meu marco gigantesco \nNum planalto cercado por montanhas \nPrecipícios gelados e falésias \nProjetando no ar formas estranhas \nComo os muros Ciclópicos de Tebas \nE as fatais cordilheiras da Espanha \n \nBem na praça central. um monumento \nEmbeleza meu marco marciano \nUm granito em enigma recortado \nPelos rudes martelos de Vulcano \nUma esfinge em perfil contra o poente \nGuardiã imortal do meu arcano... \n \n -- Lenine \n' > arq_marciano.txt

.

Executo os 35 comandos abaixo:

.

1) cat arq_marciano.txt

2) cat -n arq_marciano.txt

3) file arq_marciano.txt

4) !ca

5) !fi

6) wc arq_marciano.txt

wc -l arq_marciano.txt (linhas)

wc -w tarq_marciano.txt (palavras)

wc -c arq_marciano.txt (caracteres)

7) whereis arq_marciano.txt

8) whatis xingar

9) cat arq_marciano.txt | less

10) cat arq_marciano.txt | more

11) cat arq_marciano.txt | head -n 3

cat arq_marciano.txt | head -n 2 | grep 'O Marco' | cut -f1- | cut -c8-

12) cat -n arq_marciano.txt | head -n 3

cat arq_marciano.txt | head -n 2 | grep 'O Marco' | cut -f1- | cut -c8- | sed 's/Marciano/Plutoniano/'

13) cat arq_marciano.txt | tail -n 3

cat arq_marciano.txt | awk /Marciano/

14) cat -n arq_marciano.txt | tail -n 3

15) cat arq_marciano.txt | head -n 4 | grep imortal

16) cat arq_marciano.txt | head -n 4 | grep cidades

17) cat arq_marciano.txt | head -n 28 | grep -v marco

18) touch arq_marciano.txt

19) ls -til

20) cp -v arq_marciano.txt arq_marciano_back.txt

21) ls1

22) grep -i "marciano" arq_marciano.txt

grep -i marciano "arq_marciano.txt" -v

23) grep -i "meu" arq_marciano.txt

grep -i "meu" arq_marciano.txt -v

24) fgrep "sonda" arq_marciano.txt

25) egrep '(radar|decolar)' arq_marciano_back.txt

26) find ./ arq_marciano.txt

27) find arq_marciano.txt

28) ls [a-m]*.txt

29) mv arq_marciano_back.txt renomeado_arq_marciano_back.txt

30) ls -t

31) find ./* -type f -exec grep -l tem {} \;

32) egrep "ruas" -r ?*.txt

33) fgrep "montanhas" -r ./

34) ls2

35) clear

.

OBS:
Para remover o arquivo criado (ou use o mouse):

rm -f nome-do-arquivo.txt

Linux – Praticando shell script – NomeUserUID.sh

Abro o terminal pelo menu do sistema.

-----------------

Executo:

-----------------

touch 5ScrNomeUserUID.sh

-----------------

chmod +x 5ScrNomeUserUID.sh

-----------------

vi 5ScrNomeUserUID.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

(Para apagar um linha aperto Esc clico nela e digito dd)

-----------------

#!/bin/bash

# Nome do Script: 5ScrNomeUserUID.sh
# Descrição: script recebe um nome de usuário como
# parâmetro e exibe UID do usuário, Nome Completo /
# Descrição do Usuário, Total em Uso no /home do
# usuário, Informações do último login do usuário,
# Validar se o usuário existe ou não sem o uso do if.
# Se não existir retorne o exit code 1, se
# existir retorne exit 0
# Execução: ./5ScrNomeUserUID.sh
# Autor: Fulano de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail@email.com
# Histórico de modificações:
# COMENTÁRIO:
# Comando “du” para descobrir o uso do diretório
# Comando “lastlog” para informações do login
# Dados do usuário no arquivo /etc/passwd
# Para fazer a validação posso usar as opções de
# execução sequencial
# de comandos &&, ou ;

# COMENTÁRIOS ESPECIAIS:

# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção - Cuidado para não usar dentro do script a variável de ambiente UID

# Declarando variáveis:
DATATUAL=$(date)
NOMEDAMAQUINA=$(cat /etc/hostname)
EUSER=$USER
USERLOGIN=$(w | grep 'tty7')
UIDUSER=$UID
TOTAL=$(du -hcs ~/ | grep 'total')

clear
echo "Data: $DATATUAL"
echo "Relatório do Usuário: $EUSER"
echo
echo "UID do usuário: $UIDUSER"
echo 'Nome ou Descrição:' $USER
echo "Nome da Máquina: $NOMEDAMAQUINA"
echo "Ultimo Login: $USERLOGIN"
echo "Total Usado no ultimo Login: $TOTAL"
echo
# Fim do Script 5ScrNomeUserUID.sh

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh 5ScrNomeUserUID.sh

-----------------

Linux – comando ls e as expressões regulares

Linux - comando ls e as expressões regulares -

--------------------
Coisas que o Linus Torvalds não criou:
--------------------

O comando ls é GNU!
O comando mv é GNU!
O comando rm é GNU!
O comando cp é GNU!
O comando du é GNU!
O comando chmod é GNU!
O comando split é GNU!
O comando uniq é GNU!
O comando wc é GNU!
O comando env é GNU!
O comando pwd é GNU!
O comando uptime é GNU!
O comando uname é GNU!

--------------------

O comando ls = lista arquivos e o conteúdo de diretórios

--------------------

Executando alguns comandos ls:

--------------------

1) ls -d */ (Para exibir pastas)

2) ls -a (Arquivos ocultos, ou seja, iniciados com “.”)

3) ls -A (arquivos ocultos, exceto o “.” e “..”)

4) ls | less (Listar arquivos e diretórios)

5) ls -C (Arquivos em colunas, ordenados verticalmente)

6) ls -l | grep ^d OU ls -la | grep ^d (Somente diretórios)

7) ls -h (Exibe os arquivos em seus tamanhos em KB, MB e GB)

8) ls -t (exibe primeiramente os arquivos criados/alterados recentemente)

9) ls -l (exibe informações referentes a arquivos e diretorios em colunas)

10) ls -F (exibe apenas arquivos executáveis, ou seja, marcados por um asterisco
no final do seu nome)

11) ls -u (exibe arquivos de acordo com o tempo do ultimo acesso ao inves
do tempo de modificacao do mesmo)

12) ls -r (exibe os arquivos na ordem inversa de z para a)

13) ls -R (exibe um diretorio e seus respectivos subdiretorios)

--------------------

Linux criar comandos usando expressões regulares

--------------------

Expressões regulares são caracteres com base em padrões, usandos simultaneamente para buscar e alterar textos em diretórios ou arquivos. Posso usar com diversos comandos do Linux.

--------------------

Expressões regulares são criadas a partir de metacaracteres. Sendo eles:

--------------------

\ . * + - { } [ ] ^ $ | ? ( ) : ! = \b | \1

--------------------

Metacaracteres podem, dependendo do caso, ter mais de um significado de acordo com o contexto.

--------------------

Aspa " não é metacaractere.

--------------------

Para criar comandos usando expressões regulares, posso usar um arquivo de texto. O arquivo de texto serve para eu aprender a criar comandos usando expressões regulares. Posso criar comandos usando expressões regulares imaginando também.

--------------------

Se eu quero criar comandos usando expressões regulares preciso usar metacaracteres.

--------------------

Lista de metacaracteres para eu consultar:

--------------------
. ponto
[] lista
[^] lista negada
? opcional
* asterisco
+ mais
{} chaves
^ circunflexo
$ cifrão
\b borda
\ escape
| ou
() grupo
\1 retrovisor
--------------------

Os metacaracteres e suas funções estão divididos em quatro grupos distintos:

--------------------

1) Representantes
2) Quantificadores
3) Âncoras
4) Outros

--------------------
--------------------

1) Representantes

--------------------
--------------------

.

(ponto - um caractere qualquer)

Ex.:

ls .

ls -li | grep ".ocumentos"

ls -li | grep ".odelos"

--------------------

[...]

(lista - lista de caracteres permitidos)

Ex.:

ls | grep [D]

(ls liste o que tiver D maiúsculo)

ls -t | grep [D-I]

--------------------

[^...]

(lista negada - lista de caracteres proibidos)

ls | grep [^D]

ls -t | grep [^D-I]

--------------------
--------------------

2) Quantificadores

--------------------
--------------------

?

(opcional - zero ou um)

Ex.:

ls -li | grep [M?]

ls -li | grep [D?]

--------------------

*

(asterisco - zero, um ou mais)

Ex.:

ls -li | grep [M*]

ls -li | grep [V*]

--------------------

+

(mais - um ou mais)

Ex.:

ls -li | grep [M+]

ls -li | grep [V+]

--------------------

{n,m}

(chaves - de n até m)

ls -t | grep {D,}

ls -t | grep {M,}

--------------------
--------------------

3) Âncoras

--------------------
--------------------

^

(circunflexo - início da linha)

Ex.:

ls -la | grep ^d

ls -la | grep ^d

--------------------

$

(cifrão - fim da linha)

Ex.:

ls -t | grep "$o"

--------------------

\b

(borda - início ou fim de palavra)

Ex.:

ls -li | grep [\bs]

ls -li | grep [\bV+]

--------------------

4) Outros

\c

(escape - torna literal o caractere c)

ls -li | grep [\c,M+]

ls -li | grep [\cV+]

--------------------

(...)

(ou - ou um ou outro)

ls -li | grep ...

--------------------

\1...\9

(retrovisor - texto casado nos grupos 1...9)

ls -li | grep \1...\9

--------------------

OBS:
Curingas usados em linha de comando, não são expressões regulares.

--------------------

Executo:

read -p "Informe um valor que será inserido em VAR1: " VAR1

read -p "Informe um valor que será inserido em VAR2: " VAR2

--------------------

OBS:
# $(expr $VAR1 + $VAR2) É uma substituição de comando que executa e joga o resultado na tela.

--------------------

Executo:

echo "A soma de $VAR1 + $VAR2 é $(expr $VAR1 + $VAR2)"

--------------------

Exemplos de scripts a serem executados:

--------------------

#!/bin/bash

# Nome do Script: 3Script-relatorio-da-maquina.sh
# Descrição:
# Execução: sh 3Script-relatorio-da-maquina.sh
# Autor: Fulano de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail@email.com
# Histórico de modificações:
# Comentário:

# COMENTÁRIOS ESPECIAIS:

# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção
#
# Primeiro definir as variáveis
# 8 Variáveis

KERNEL=$(uname -r)
HOSTNAME=$(hostname)
CPUNO=$(cat /proc/cpuinfo | grep "model name" | wc -l)
CPUMODEL=$(cat /proc/cpuinfo | grep "model name" | head -n1 | cut -c14-)

# Acima cat /proc/cpuinfo mostra um monte de informação. Só quero uma linha de
# informação.
# Filtro usando pipe grep e o que tem no início da string "model name".
# Ainda aparecem 4 strings.
# Uso mais um pipe e o comando head -n1 aparece só uma
# linha. Mas...
# Uma parte desta única string não quero que apareça.
# Uso pipe e o comando cut -c14- para sumir com 14
# caracteres iniciais da
# string.

MEMTOTAL=$(free -h | grep 'Mem:' | cut -d: -f2)
MEMTOTAL2=$(cat /proc/meminfo | grep 'MemTotal:' | cut -c17-)
FILESYS=$(df -h | egrep -v '(tmpfs | udev)')
UPTIME=$(uptime -s)

# Noto que algumas variáveis são bem conhecidas
# mas outras são comandos criados a partir de
# expressões regulares.

# Para fazer um shell script funcionar criamos
# comandos via expressões regulares, colocamos
# eles dentro de variáveis. A variável só aceita
# um valor! Uma expressão regular é um só valor
# composto de quantos comandos a pessoa quiser.

# Este é o segredo da necessidade de aprender
# expressões regulares. Aprenda muito bem, para
# poder criar ótimos shell scripts.

clear
echo
echo ':::::::::::::::::::::::::::::'
echo "Relatório da Máquina: $HOSTNAME"
echo "Data/Hora: $(date)"
echo ':::::::::::::::::::::::::::::'
echo
echo "Ativa desde: $UPTIME"
echo
echo "Kernel: $KERNEL"
echo
echo "CPUs:"
echo "$CPUNO"
echo
echo "Modelo da(s) CPU(s): $CPUMODEL"
echo
echo "Memória Total: $MEMTOTAL"
echo
echo "$MEMTOTAL2"
echo
echo "Partições:"
echo
echo "$FILESYS"
echo
echo
echo 'Fim do Script'
echo
echo
# Fim do Script

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh 3Script-relatorio-da-maquina.sh

-----------------

OUTRO SHELL SCRIPT ESCRITO DIFERENTE MAS SOBRE O MESMO ASSUNTO:

-----------------

#!/bin/bash

# Nome do Script: RelatInfo.sh
# Descrição: Script que gera um relatório de algumas informações da máquina atual
# Execução: ./RelatInfo.sh
# Autor: Fulana de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail1@mail.com
# Histórico de modificações:
# Comentário:
# COMENTÁRIOS ESPECIAIS:
# TODO - indica uma tarefa a ser feita - Info Sist
# FIXME - indica um bug conhecido que precisa ser arrumado - strings duplicadas, uso de variáveis
# XXX - Notícia, chama a atenção. Para remover linhas duplicadas em uma expressão regular:
# Procuro por: find and remove duplicate strings via unix shell script
# awk '!_[$1]++' nome_do_arquivo.txt (a expressão _[$1]++ incrementa o valor do elemento de array com index $1 por um desde que ++ venha depois)

echo ""
echo "== Relatório de Informações da Máquina =="
echo ""
echo 'Dia:'
date
echo ""
echo 'Nome da Máquina:'
hostname
echo ""
echo 'Máquina Ativa desde:'
uptime
echo ""
echo
echo 'Versão Distro:'
cat /proc/version
echo
echo 'Usuario:'
whoami
echo
echo 'Versão do Kernel:'
uname -r
echo ""
lscpu | grep 'CPU(s):'
echo ""
lscpu | grep 'Nome do modelo:'
echo ""
echo 'Partições:'
df -kh
echo ""
lscpu | grep 'Arquitetura:'
echo ""
lscpu | grep 'Modo(s) operacional da CPU:'
echo ""
echo 'Relatório de BUGS (nCPUs):' ; cat /proc/cpuinfo | grep 'bugs' | awk '!_[$1]++'
echo ""
echo 'Identidade do vendedor:'
cat /proc/cpuinfo | grep 'vendor_id' | head -n1 | cut -c12-
echo ""
echo 'Memória total (MB):'
expr $(cat /proc/meminfo | grep MemTotal | tr -d ' ' | cut -d: -f2 | tr -d kB) / 1024
echo
echo 'Fim do Script'
echo ""
# Fim do Script

Linux – praticando – Script relatório da máquina

Linux - praticando - Script relatório da máquina

.

Abro o terminal pelo menu do sistema.

-----------------

Executo:

-----------------

touch 3Script-relatorio-da-maquina.sh

-----------------

chmod +x 3Script-relatorio-da-maquina.sh

-----------------

vi 3Script-relatorio-da-maquina.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

(Para apagar um linha aperto Esc clico nela e digito dd)

-----------------

#!/bin/bash

# Nome do Script: 3Script-relatorio-da-maquina.sh
# Descrição:
# Execução: sh 3Script-relatorio-da-maquina.sh
# Autor: Fulano de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail@email.com
# Histórico de modificações:
# Comentário:

# COMENTÁRIOS ESPECIAIS:

# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção
#
# Primeiro definir as variáveis
# 8 Variáveis

KERNEL=$(uname -r)
HOSTNAME=$(hostname)
CPUNO=$(cat /proc/cpuinfo | grep "model name" | wc -l)
CPUMODEL=$(cat /proc/cpuinfo | grep "model name" | head -n1 | cut -c14-)

# Acima cat /proc/cpuinfo mostra um monte de informação. Só quero uma linha de
# informação.
# Filtro usando pipe grep e o que tem no início da string "model name".
# Ainda aparecem 4 strings.
# Uso mais um pipe e o comando head -n1 aparece só uma linha. Mas...
# Uma parte desta única string não quero que apareça.
# Uso pipe e o comando cut -c14- para sumir com 14 caracteres iniciais da
# string.

MEMTOTAL=$(free -h | grep 'Mem:' | cut -d: -f2)
MEMTOTAL2=$(cat /proc/meminfo | grep 'MemTotal:')
FILESYS=$(df -h | egrep -v '(tmpfs | udev)')
UPTIME=$(uptime -s)

# Noto que algumas variáveis são bem conhecidas
# mas outras são comandos criados a partir de
# expressões regulares.

# Para fazer um shell script funcionar criamos
# comandos via expressões regulares, colocamos
# eles dentro de variáveis. A variável só aceita
# um valor! Uma expressão regular é um só valor
# composto de quantos comandos a pessoa quiser.

# Este é o segredo da necessidade de aprender
# expressões regulares. Aprenda muito bem, para
# poder criar ótimos shell scripts.

clear
echo
echo ':::::::::::::::::::::::::::::'
echo "Relatório da Máquina: $HOSTNAME"
echo "Data/Hora: $(date)"
echo ':::::::::::::::::::::::::::::'
echo
echo "Ativa desde: $UPTIME"
echo
echo "Kernel: $KERNEL"
echo
echo "CPUs:"
echo "$CPUNO"
echo
echo "Modelo da(s) CPU(s): $CPUMODEL"
echo
echo "Memória Total: $MEMTOTAL"
echo
echo "$MEMTOTAL2"
echo
echo "Partições:"
echo
echo "$FILESYS"
echo
echo
echo 'Fim do Script'
echo
echo
# Fim do Script

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh 3Script-relatorio-da-maquina.sh

-----------------

Outro Shell Script escrito diferente mas sobre o mesmo assunto:

-----------------

#!/bin/bash

# Nome do Script: RelatInfo.sh
# Descrição: Script que gera um relatório de algumas informações da máquina atual
# Execução: ./RelatInfo.sh
# Autor: Fulana de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail1@mail.com
# Histórico de modificações:
# Comentário:
# COMENTÁRIOS ESPECIAIS:
# TODO - indica uma tarefa a ser feita - Info Sist
# FIXME - indica um bug conhecido que precisa ser arrumado - strings duplicadas, uso de variáveis
# XXX - Notícia, chama a atenção. Para remover linhas duplicadas em uma expressão regular:
# Procuro por: find and remove duplicate strings via unix shell script
# awk '!_[$1]++' nome_do_arquivo.txt (a expressão _[$1]++ incrementa o valor do elemento de array com index $1 por um desde que ++ venha depois)

echo ""
echo "== Relatório de Informações da Máquina =="
echo ""
echo 'Dia:'
date
echo ""
echo 'Nome da Máquina:'
hostname
echo ""
echo 'Máquina Ativa desde:'
uptime
echo ""
echo
echo 'Versão Distro:'
cat /proc/version
echo
echo 'Usuario:'
whoami
echo
echo 'Versão do Kernel:'
uname -r
echo ""
lscpu | grep 'CPU(s):'
echo ""
lscpu | grep 'Nome do modelo:'
echo ""
echo 'Partições:'
df -kh
echo ""
lscpu | grep 'Arquitetura:'
echo ""
lscpu | grep 'Modo(s) operacional da CPU:'
echo ""
echo 'Relatório de BUGS (nCPUs):' ; cat /proc/cpuinfo | grep 'bugs' | awk '!_[$1]++'
echo ""
echo 'Identidade do vendedor (nCPUs):'
cat /proc/cpuinfo | grep 'vendor_id' | awk '!_[$1]++'
echo ""
echo 'Fim do Script'
echo ""

# Fim do Script

.

Até Breve!

.

:)

.

Linux shell script praticando – Script que soma 3 valores e exibe resultado

Linux shell script praticando - Script que soma 3 valores e exibe resultado

.

Abro o terminal pelo menu do sistema.

-----------------

Executo:

-----------------

touch 2script-soma-numeros.sh

-----------------

chmod +x 2script-soma-numeros.sh

-----------------

vi 2script-soma-numeros.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

(Para apagar um linha aperto Esc clico nela e digito dd)

-----------------

#!/bin/bash

# Nome do Script: 2script-soma-numeros.sh
# Descrição:
# Autor: Fulano de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail@email.com
# Histórico de modificações:
# Comentário:
# COMENTÁRIOS ESPECIAIS:
# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção
# Execução: sh 2script-soma-numeros.sh

echo
echo "Por favor, digite alguns números:"
sleep 2
echo

read -p "Digite a Variavel 1: " VARIAVEL1
read -p "Digite a Variavel 2: " VARIAVEL2
read -p "Digite a Variavel 3: " VARIAVEL3

echo
echo "A soma da $VARIAVEL1 + $VARIAVEL2 + $VARIAVEL3" é $(expr $VARIAVEL1 + $VARIAVEL2 + $VARIAVEL3)

echo
echo 'Fim do Script'
sleep 2
echo

# Fim do Script: 2script-soma-numeros.sh

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh 2script-soma-numeros.sh

-----------------

.

O Resultado é:

.

$ sh 2script-soma-numeros.sh

Por favor, digite alguns números:

Digite a Variavel 1: 22
Digite a Variavel 2: 20
Digite a Variavel 3: 10

A soma da 22 + 20 + 10 é 52

Fim do Script

.

.

Até Breve!

🙂

.

Script que gera um relatório de algumas informações da máquina atual

#!/bin/bash

# Nome do Script: RelatInfo.sh

# Descrição: Script que gera um relatório de algumas informações da máquina atual

# Autor: Fulano de Tal

# Data da Criação: DD/MM/YYYY

# Email: meu_mail1@mail.com

# Histórico de modificações:

# Comentário:

# COMENTÁRIOS ESPECIAIS:

# TODO - indica uma tarefa a ser feita

# FIXME - indica um bug conhecido que precisa ser arrumado

# XXX - Notícia, chama a atenção

#

echo ""
echo "== Relatório de Informações da Máquina =="

echo ""
echo 'Dia:'
date

echo ""
echo 'Usuario:'
whoami

echo ""
echo 'Máquina Ativa desde:'
uptime

echo ""
echo 'Verão do Kernel:'
uname -r
echo ""

lscpu | grep 'CPU(s):'
echo ""

lscpu | grep 'Nome do modelo:'
echo ""

echo 'Partições:'
df -kh
echo ""

lscpu | grep 'Arquitetura:'
echo ""

lscpu | grep 'Modo(s) operacional da CPU:'
echo ""

echo 'Relatório de BUGS (nCPUs):' ; cat /proc/cpuinfo | grep 'bugs'
echo ""

echo 'Identidade do vendedor (nCPUs):'
cat /proc/cpuinfo | grep 'vendor_id'
echo ""

echo 'Fim do Script'
echo ""

# Fim do Script

Linux Parâmetros e entradas do usuário

Linux Parâmetros e entradas do usuário

.

Executo:

.

mkdir -vp DirParam/SubDirP

.

ls -t

.

cd DirParam/SubDirP/

.

LEITURA:
Usar parâmetros. Tenho comandos que uso. Estes comandos tem opções. Muitos comandos e suas opções precisam de parâmetros.

.

Exemplo: O comando grep busca linha que tem um padrão de busca que é root. A opção -E interpreta o padrão como uma expressão regular estendida. O parâmetro /etc/passwd.txt diz ao comando e a opção onde fazer o serviço. Fica assim:

.

1) grep -E padrão Argumento

2) grep -E root /etc/passwd

3) grep -v bash /etc/passwd

.

Posso usar parâmetros em shell script.

.

Executo:

-----------------

touch ArqParam.sh

-----------------

chmod +x ArqParam.sh

-----------------

vi ArqParam.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

# Declaro uma função em ShellScript

function BoasVindas(){
echo -e "\n\nSeja Bem Vindo $1 \n\n"
}

echo -n "Digite seu nome: "
read NOME

# A variável NOME receberá o que foi digitado por mim

BoasVindas "$NOME"

# Aqui passo o conteúdo da variável NOME como o 1º parâmetro para a função BoasVindas()

-----------------

Salvo e saio apertando a tecla Esc e digitando :wq (Enter)

-----------------

Executo:

-----------------

sh ArqParam.sh

-----------------

OBS:

1) Funções em shell script não recebem parâmetros na sua declaração.
2) Dentro da função há um "$1", esse é o parâmetro que a função receberá, então caso queira passar mais de um parâmetro para a função, basta chamar dentro dela os valores respectivos aos parâmetros, ou seja, $1 = primeiro parâmetro, $2 = segundo parâmetro, $3 = terceiro ... $9 = nono parâmetro.
3) Se a função tiver mais de 9 parâmetros, posso declarar da seguinte forma: ${10}, ${11} etc.

-----------------

Executo:

-----------------

touch ArqParam2.sh

-----------------

chmod +x ArqParam2.sh

-----------------

vi ArqParam2.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

# Declaro uma função em ShellScript

function EscrevePalavra(){
echo -e "\n\nVocê escreveu $1 \n\n"
}

echo -n "Escreva uma palavra: "
read PALAVRA

EscrevePalavra "$PALAVRA"

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh ArqParam2.sh

-----------------

O script ArqParam2.sh imprime no terminal os parâmetros que foram passados. Para usar um parâmetro em específico uso $1 o primeiro parâmetro. A partir do décimo parâmetro tem que usar ${10}, do contrário o shell vai usar o parâmetro 1 e escreverá um 0 em seguida

-----------------

Executo:

-----------------

touch ArqParam3.sh

-----------------

chmod +x ArqParam3.sh

-----------------

vi ArqParam3.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

# ArqParam3.sh

# Declaro uma função em ShellScript

echo "O parâmetro 1 é: $1"
echo "O parâmetro 3 é: $3"
echo "O parâmetro 10 é: ${10}"
echo "O parâmetro 15 é: ${15}"
echo "O parâmetro 16 é: ${16}"
echo "O parâmetro 17 é: ${17}"

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh ArqParam3.sh 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

-----------------

bash ArqParam3.sh um 2 três 4 5 6 7 8 9 dez 11 12 13 14 quinze 16 dezessete

-----------------

Executo:

-----------------

touch ArqParam4.sh

-----------------

chmod +x ArqParam4.sh

-----------------

vi ArqParam4.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

echo Existem $# argumentos para $0: $*
echo primeiro argumento: $1
echo segundo argumento: $2
echo terceiro argumento: $3
echo quarto argumento: $4
echo Aqui estão eles de novo: $@

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

bash ArqParam4.sh experimento shell script Linux

-----------------

echo "" ; sh ArqParam4.sh experimento shell script Linux ; echo ""

-----------------

Executo:

-----------------

touch ExemploParametros.sh

-----------------

chmod +x ExemploParametros.sh

-----------------

vi ExemploParametros.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

# $0 - Nome do programa

# $# - Quantidade de parâmetros inseridos

# $* - Todos os parâmetros inseridos

# $1 - Parametro 1
# $2 - Parametro 2
# $3 - Parametro 3
# $4 - Parametro 4
# $5 - Parametro 5
# $6 - Parametro 6
# $7 - Parametro 7
# $8 - Parametro 8
# $9 - Parametro 9

# ${10} - Parametro 10
# ${11} - Parametro 11

echo "O script $0 recebeu $# parâmetros "

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh ExemploParametros.sh

-----------------

Resultado:

-----------------

$ sh ExemploParametros.sh
O script ExemploParametros.sh recebeu 0 parâmetros

-----------------

Se eu adicionar ao comando "sh ExemploParametros.sh" as palavras: Vida Jovem Filosofa Poetisa.

.

Executo:

.

sh ExemploParametros.sh Vida Jovem Filosofa Poetisa

.

Resultado:

.

$ sh ExemploParametros.sh Vida Jovem Filosofa Poetisa
O script ExemploParametros.sh recebeu 4 parâmetros

.

Executo:

.

sh ExemploParametros.sh Vida Jovem Filosofa Poetisa GNU Linux

.

Resultado:

.

$ sh ExemploParametros.sh Vida Jovem Filosofa Poetisa GNU Linux
O script ExemploParametros.sh recebeu 6 parâmetros

.

Executo:

.

vi ExemploParametros.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

# $0 - Nome do programa

# $# - Quantidade de parâmetros inseridos

# $* - Todos os parâmetros inseridos

# $1 - Parametro 1
# $2 - Parametro 2
# $3 - Parametro 3
# $4 - Parametro 4
# $5 - Parametro 5
# $6 - Parametro 6
# $7 - Parametro 7
# $8 - Parametro 8
# $9 - Parametro 9

# ${10} - Parametro 10
# ${11} - Parametro 11

echo ""
echo "O script $0 recebeu $# parâmetros "
echo ""
echo "Os parâmetros recebidos foram: $*"
echo ""

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh ExemploParametros.sh Luz Velho Sombra GNU Linux Unix Novos Alunos

-----------------

Executo:

.

vi ExemploParametros.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

# $0 - Nome do programa

# $# - Quantidade de parâmetros inseridos

# $* - Todos os parâmetros inseridos

# $1 - Parametro 1
# $2 - Parametro 2
# $3 - Parametro 3
# $4 - Parametro 4
# $5 - Parametro 5
# $6 - Parametro 6
# $7 - Parametro 7
# $8 - Parametro 8
# $9 - Parametro 9

# ${10} - Parametro 10
# ${11} - Parametro 11

echo ""
echo "O script $0 recebeu $# parâmetros "
echo ""
echo "Os parâmetros recebidos foram: $*"
echo ""
echo "Parâmetro \$1 = $1" # Noto o escape em \$
echo "Parâmetro \$2 = $2"
echo "Parâmetro \$3 = $3"
echo "Parâmetro \$4 = $4"
echo "Parâmetro \$5 = $5"
echo "Parâmetro \$6 = $6"
echo "Parâmetro \$7 = $7"
echo ""

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh ExemploParametros.sh Vida Jovem Velho Poeta GNU Linux Unix

.

Executo:

.

echo -e 'AlunaA Xh \nAmunoC Beg \nAnunaE Yok \nApunoT Wxs' > ParamNom.txt

.

touch ParamLunos.sh

chmod -x ParamLunos.sh

.

vi ParamLunos.sh

.

Copio e colo no ParamLunos.sh:

.

#!/bin/bash

# ParamLunos.sh - Procura nomes
# Autor: Average Joe
# Exemplo de script para uso de parâmetros
# Uso: sh ParamLunos.sh

NOMEALUN="ParamNom.txt"

clear
echo ""
echo "== Script busca Nome =="
echo ""

NOMECOMP=$(grep "$1" $NOMEALUN) # O grep recebe o parâmetro $1

echo ""
echo "O nome completo é: $NOMECOMP"
echo ""
echo "Fim do Script"
echo ""

--------------------

sh ParamLunos.sh AnunaE

--------------------

.

Até Breve!

.

🙂

Linux comando read

Linux comando read

.

No Bash o comando read recebe a entrada do usuário (EU). O comando read ajuda a manipular e tratar a entrada de dados em Bash Shell. Exemplo para escrever scripts:

read VARIAVEL

.

IMPRIMINDO E LENDO VALORES AO MESMO TEMPO:

read -p 'TEXTO' VARIAVEL

.

A opção -p originalmente mostra uma mensagem na saída de erro padrão.
Se não estiver redirecionando essa saída para o /dev/null ou para nenhum outro lugar, ela será apresentada na tela do terminal.

----------------

Exemplo:

#!/bin/bash

# A entrada de dados é encerrada ao apertar a interrogação '?'

read -p "Digite uma pergunta? : " -d'?' PERGUNTA

echo

echo "$PERGUNTA"

----------------

LIMITANDO A QUANTIDADE DE CARACTERES A SEREM LIDOS

read -n NUMERO

.

A opção -n faz o read ler até a quantidade de caracteres especificada em NUMERO.

Útil para fazer menus em que apenas um caractere deve ser informado, sem a necessidade do ENTER para finalizar, pois a condição de -n já foi atendida.

----------------

CONTINUANDO...

.

ABRO O TERMINAL PELO MENU DO SISTEMA.

.

EXECUTO:

.

read UM_NOME

.

Digito:

Average Joe

.

Executo:

.

echo $UM_NOME

.

read VALOR1 VALOR2 VALOR3

.

Digito:

Aprendendo Linux Shellscript

.

Executo:

.

echo $VALOR1 $VALOR2 $VALOR3

.

read VALOR1 VALOR2

.

Aprendendo Linux Shellscript

.

echo $VALOR1

.

echo $VALOR2

.

read -p "Escreva uma palavra: " CRONOS

.

Biplano

.

echo $CRONOS

.

read -s CURSE

.

6a5b4c3d2e1f

.

echo $CURSE

.

mkdir -vp TesteRead/SubPasta

.

cd TesteRead/SubPasta

.

pwd

.

ls -R

.

echo -e 'Alu Mino \nZeta Ser \nXandre Bol \nErbe Pro \nHugu Ben \nKako Tom \nQuex Vuz' > ArqRead.txt

.

cat ArqRead.txt

.

cd ..

.

pwd

.

grep Quex ~/TesteRead/SubPasta/ArqRead.txt

.

cd -

.

pwd

.

ls

.

echo -e '#!/bin/bash \n \n# Este é script teste cmd read \n' > readscript.sh ; chmod +x readscript.sh ; cat readscript.sh

.

ls -til

.

vi readscript.sh

.

Aperto Esc. Clico no terminal. Digito i.

.

Copio o texto abaixo e colo no vi.

.

# Inicio

ARQREAD="ArqRead.txt"

clear

echo ""
echo '== Script Busca Nomes =='
echo
echo -n "Favor informar o nome a buscar:"
read NOME

echo ""
echo "O nome completo é: $(grep "$NOME" $ARQREAD)"
echo ""
echo "Fim do Script"
echo ""

# Fim

.

Salvo e saio apertando a tecla Esc e digitando :wq (Enter)

.

Executo:

.

sh readscript.sh

.

Digito: Kako

.

Aperto a tecla Enter

.

O resultado é:

.

== Script Busca Nomes ==

Favor informar o nome a buscar:Kako

O nome completo é: Kako Tom

Fim do Script

.

OBS.
Em vez de usar:

echo -n "Favor informar o nome a buscar:"
read NOME

Poderia ser:

read -p "Favor informar o nome a buscar: " NOME

.

Salvo e saio apertando a tecla Esc e digitando ZZ (Enter)

.

Executo:

.

vi readscript.sh

.

Aperto Esc. Clico no terminal. Digito i.

.

OBS:
No Vi apertando a tecla Esc e digitando dd - deleta linha corrente, apertando a tecla Esc e digitando dG - deleta até a última linha do arquivo, d$ - deleta até o fim da linha, d^ - deleta até o início da linha.

.

Copio o texto abaixo e colo no vi.

.

# Inicio

ARQREAD="ArqRead.txt"

clear

echo ""
echo '== Script Busca Nomes =='
echo
read -p "Favor informar o nome a buscar: " NOME

echo ""
echo "O nome completo é: $(grep "$NOME" $ARQREAD)"
echo ""
echo "Fim do Script"
echo ""

# Fim

.

Salvo e saio apertando a tecla Esc e digitando :x (Enter)

Executo:

.

sh readscript.sh

.

Digito: Zeta

.

O resultado é:

== Script Busca Nomes ==

Favor informar o nome a buscar: Zeta

O nome completo é: Zeta Ser

Fim do Script

.

OUTRO MODO DE FAZER A MESMA COISA...

.

Executo:

.

vi readscript.sh

.

Aperto Esc. Clico no terminal.

.

REPITO OBS:
No Vi apertando a tecla Esc e digitando dd - deleta linha corrente, apertando a tecla Esc e digitando dG - deleta até a última linha do arquivo, d$ - deleta até o fim da linha, d^ - deleta até o início da linha.

.

Copio o texto abaixo e colo no vi.

.

# Inicio

ARQREAD="ArqRead.txt"

clear

echo ""
echo '== Script Busca Nomes =='
echo
read -p "Favor informar o nome a buscar: " NOME

NOMECOMPLETO=$(grep "$NOME" $ARQREAD)

echo ""
echo "O nome completo é: $NOMECOMPLETO"
echo ""
echo "Fim do Script"
echo ""

# Fim

.

Salvo e saio apertando a tecla Esc e digitando :wq (Enter)

.

Executo:

.

cat ArqRead.txt

.

bash readscript.sh

.

Digito: Erbe

.

O resultado é:

.

== Script Busca Nomes ==

Favor informar o nome a buscar: Erbe

O nome completo é: Erbe Pro

Fim do Script

.

Linux alterando textos no terminal com sed sem enrolação

Linux alterando textos no terminal com sed sem enrolação

.

Para usar o comando sed, eu tenho um arquivo com preços de produtos.

1, Produto A, Title 545, Price $6.30
2, Produto B, Title 723, Price $7.90
3, Produto C, Title 610, Price $7.90
4, Produto A, Title 118, Price $6.30
5, Produto B, Title 482, Price $6.50
6, Produto C, Title 335, Price $6.30
7, Produto A, Title 271, Price $7.90

.

Crio o arquivo abrindo o terminal pelo menu do sistema. Executo:

1)

mkdir -v DirSed

2)

cd DirSed/

3)

echo -e '1, Produto A, Title 545, Price $6.30
2, Produto B, Title 723, Price $7.90 \n3, Produto C, Title 610, Price $7.90 \n4, Produto A, Title 118, Price $6.30 \n5, Produto B, Title 482, Price $6.50 \n6, Produto C, Title 335, Price $6.30 \n7, Produto A, Title 271, Price $7.90' > ArqProdut.txt ; cat ArqProdut.txt

.

OBS:
Quero mudar o preço dos produtos que custam 6.30 para 7.30.

.

Executo:

1) sed 's/6.30/7.30/' > ArqProdut.txt

2) cat ArqProdut.txt

.

As duas principais ferramentas para manipulação de arquivos e streams do Unix/Linux/GNU talvez sejam o "sed" e o "awk".

.

Com o SED é possível substituir e “casar” padrões, sempre por meio de Expressões Regulares.

.

O esquema SED e AWK:

O comando lê um arquivo, linha por linha, e aplica a expressão do parâmetro a cada uma delas.

.

A FÓRMULA DO SUCESSO COM SED:

.

1) sed 's/texto-a-ser-substituido/texto-novo/'

2) sed -i 's,palavra-a-ser-substituida,palavra-nova,' nome-do-arquivo.txt

.

OBS:
(a opção -i, sobrescreve o conteúdo do nome-do-arquivo.txt)

.

3) sed 's,texto-a-ser-substituido,texto-novo,' *

4) sed -i 's,texto-a-ser-substituido,texto-novo,g' *

.

OBS:
O comando acima faz a substituição de uma mesma string dentro de vários arquivos de um mesmo diretório fazendo uso do comando sed

.

5)

> nome-do-arquivo.txt

sed -i.novobkp 's,palavra-a-ser-substituida,palavra-nova,' nome-do-arquivo.txt

.

É possível filtrar a saída de outro comando, em vez de filtrar um arquivo, usando pipe "|".

.

Executo:

1)

echo "Testando o sed: Aprendo a trabalhar com sed" | sed 's/sed/awk/'

2)

echo "Testando a vida: Aprendo a trabalhar com a vida" | sed 's/vida/morte/'

3)

echo "Testando o claro: Aprendo a trabalhar com o claro" | sed 's/claro/escuro/g'

4)

echo "Testando o líquido : Aprendo a trabalhar com o líquido" | sed 's/líquido/sólido/g'

5)

mkdir -vp SedTeste/SubDirSed

cd SedTeste/SudDirSed/

echo "Testando o líquido : Aprendo a trabalhar com o líquido" | sed 's/líquido/sólido/' > ArqLiquido.txt

ls -t

6)

cat ArqLiquido.txt

7)

sed -i.bkp 's/líquido/sólido/' ArqLiquido.txt

ls -t

cat ArqLiquido.txt

.

USAR CARACTERES DE ESCAPE:

.

OBS:
Escapo caracteres usando barra invertida: \

.

Isto: /proc/cpuinfo tem que ser escapado. Fica assim:

\/proc\/cpuinfo

.

Isto: /etc/passwd tem que ser escapado. Fica assim:

\/etc\/passwd

.

EXECUTO:

.

1) echo "O arquivo /proc/cpuinfo possui importantes informações!"

2) echo "O arquivo /etc/passwd possui importantes informações!"

.

AGORA USO O SED:

.

1) echo "O arquivo /proc/cpuinfo possui importantes informações!" | sed 's,\/proc\/cpuinfo,\/etc\/passwd,'

.

OBS:
ENTÃO, ABAIXO A MESMA COISA QUE ACIMA; MAS DE UM MODO VISUAL MAIS ILEGÍVEL QUE ASSUSTA:

.

EXECUTO:

.

echo "O arquivo /proc/cpuinfo possui importantes informações!" | sed 's/\/proc\/cpuinfo/\/etc\/passwd/'

.

OBS:
SETE META CARACTERES PARA LEMBRAR.

1) ^ : começa com

2) $ : término de linha

3) . : qualquer caractere

4) [] : relação de valores possíveis para um caracter. Você pode especificar uma lista ( [abcde] ), uma faixa ( [0-9] ), ou várias faixas ( [a-zA-Z0-9] ).

5) \{\} : especifica quantas vezes o caractere pode se repetir. Por exemplo: “{2}” (duas vezes), “{2,5}” (duas a cinco vezes), “{2,}” (duas ou mais vezes).

6) | : operador lógico ou

7) .* : operador lógico e

.

OBS:
CURINGAS PARA NOME DE ARQUIVO (GLOBAIS) É DIFERENTE DE META CARACTERE.

1) Curinga Casa com... Exemplo

2) * Qualquer coisa *.txt

3) ? Um caractere qualquer arquivo-??.zip

4) [...] Qualquer um dos caracteres listados [Aa]rquivo.txt

5) [^...] Qualquer um caractere, exceto os listados [^A-Z]*.txt

6) {...} Qualquer um dos textos separados por vírgula arquivo.{txt,html}

.

CONTINUANDO...

.

SE EU QUISER SUBSTITUIR:

https://com.semanickzaine.wordpress/

POR:

https://semanickz.wordpress.com/

.

USO ESTE EXEMPLO:

sed 's,texto-a-ser-substituido,texto-novo,'

.

EXECUTO NO TERMINAL:

1) echo 'O endereço deste blog é https://com.semanickzaine.wordpress/'

2) echo 'O endereço deste blog é https://com.semanickzaine.wordpress/' | sed 's,https://com.semanickzaine.wordpress/,https://semanickz.wordpress.com/,'

3) echo ; echo 'O endereço deste blog é https://com.semanickzaine.wordpress/' | sed 's,https://com.semanickzaine.wordpress/,https://semanickz.wordpress.com/,' ; echo

.

RESULTADO:

~$ echo 'O endereço deste blog é https://com.semanickzaine.wordpress/' | sed 's,https://com.semanickzaine.wordpress/,https://semanickz.wordpress.com/,'
O endereço deste blog é https://semanickz.wordpress.com/

.

EXPRESSÃO CASADA NA EXPRESSÃO REGULAR PARA SUBSTITUIÇÃO SEM ENROLAÇÃO:

.

EXECUTO:

.

1) echo ; echo -e "O arquivo /proc/cpuinfo possui informações importantes! \nEste tutorial está em /home/user-whoami/Downloads. Há outros nesse diretório" ; echo

2) echo ; echo -e "O arquivo /proc/cpuinfo possui informações importantes! \nEste tutorial está em /home/user-whoami/Downloads. Há outros nesse diretório" | sed -r 's/(\/[^ .,]*)+/"&"/' ; echo

.

OBS:
1) O pipe | liga um comando a outro.
2) Aí vem o sed.
3) A opção “-r” usa o padrão estendido de expressões regulares - o mesmo usado por “egrep”. Isso possibilita o uso da lista negada.
4) inicia aspa simples '
5) s/ Significa substitua
6) A expressão regular fica entre parênteses ()
7) Escapo caracteres usando barra invertida: \

.

8) Esta é a expressão regular entre parênteses e com caractere de escape: (\/[^ .,]*)

OBS:
META CARACTERES
1) ^ (circunflexo): representa o começo da linha
2) $ (cifrão): representa o fim da linha
3) . (ponto): casa com um caractere qualquer
4) .* (curinga): casa qualquer coisa, é tudo ou nada
5) a+ (mais): casa a letra "a" uma ou mais vezes
6) a* (asterisco): casa a letra "a" zero ou mais vezes
7) a? (opcional): casa a letra "a" zero ou mais vezes
8) a{2} (chaves): casa a letra "a" duas vezes
9) a{2,} (chaves): casa a letra "a" no mínimo duas vezes
10) [abc] (lista): casa as letras "a" ou "b" ou "c"
11) [^abc] (lista): casa qualquer caractere, exceto "a", "b", e "c"
12) (isso|aquilo) (Ou): casa as strings "isso" ou "aquilo"

.

9) Uso o caractere & entre aspas duplas para me referir à expressão casada pela expressão regular que se refere a /.

.

SUBSTITUIR PARTES DE UM TEXTO E MANTER OUTRAS

.

Usar “retrovisores”, que inserem na string final os padrões casados na Expressão Regular inseridos em grupos (( e )).

O primeiro grupo casado é referenciado por \1, o segundo, por \2 e assim sucessivamente, até \9.

Por exemplo, vou manter apenas a primeira palavra de cada linha de um texto.

.

Uso este exemplo:

sed 's,texto-a-ser-substituido,texto-novo,'

.

Executo:

.

1) echo -e "Primeira palavra\nSegunda palavra\nTerceira palavra"

2) echo -e "Primeira palavra\nSegunda palavra\nTerceira palavra" | sed -r 's,^([a-zA-Z]+).*,\1,g'

.

OBS:
META CARACTERES
1) ^ (circunflexo): representa o começo da linha
2) $ (cifrão): representa o fim da linha
3) . (ponto): casa com um caractere qualquer
4) .* (curinga): casa qualquer coisa, é tudo ou nada
5) a+ (mais): casa a letra "a" uma ou mais vezes
6) a* (asterisco): casa a letra "a" zero ou mais vezes
7) a? (opcional): casa a letra "a" zero ou mais vezes
8) a{2} (chaves): casa a letra "a" duas vezes
9) a{2,} (chaves): casa a letra "a" no mínimo duas vezes
10) [abc] (lista): casa as letras "a" ou "b" ou "c"
11) [^abc] (lista): casa qualquer caractere, exceto "a", "b", e "c"
12) (isso|aquilo) (Ou): casa as strings "isso" ou "aquilo"

.

Executo:

echo -e "Primeira palavra\nSegunda palavra\nTerceira palavra" | sed -r 's/^([a-zA-Z]+).*/\1/g'

.

OBS:
No final do comando o modificador "g" trata a linha inteira

.

Executo:

echo "palavras1 palavras2 palavras3" | sed -r 's/([a-zA-Z0-9]+)/NULL/g'

.

Remover todas as palavras substituir por NULL. Executo:

echo "palavras1 palavras2 palavras3" | sed -r 's/([a-zA-Z0-9]+)/NULL/g'

.

Remover todas as palavras menos a primeira e substituir por NULL. Executo:

echo "palavras1 palavras2 palavras3" | sed -r 's/([a-zA-Z0-9]+)/NULL/2g'

OBS:
O “2” faz com que a substituição ocorra apenas a partir da segunda ocorrência do padrão.

.

Por padrão, o SED imprime na saída padrão todas as linhas lidas - e modificadas. A opção -n impede que o sed faça a impressão das linhas. É nessa situação que o modificador “p” é útil. Quando quiser imprimir somente as linhas alteradas pelo SED.

.

Executo:

echo -e "linha sem número \nLinha com números: 1 2 3 4 5 6 7 \nLinha com mais números 52 91" | sed -r -n 's/[0-9]+/X/gp'

.

Exemplos:

.

Supressão da 3a linha:

sed '3d' meu_arquivo.txt

.

Supressão da última linha:

sed '$d' meu_arquivo.txt

.

Supressão de todas as linhas vazias:

sed '/^$/d' meu_arquivo.txt sed '/./!d' meu_arquivo.txt

.

Supressão do intervalo compreendido entre as linhas 7 e 9:

sed '7,9d' meu_arquivo.txt

.

REVISO META CARACTERES

----------------------
1) . Ponto Curinga de um caractere
----------------------
2) [] Lista Casa qualquer um dos caracteres listados
----------------------
3) [^] Lista negada Casa qualquer caractere, exceto os listados
----------------------
4) ? Opcional O item anterior pode aparecer ou não (opcional)
----------------------
5) * Asterisco O item anterior pode aparecer em qualquer quantidade
----------------------
6) + Mais O item anterior deve aparecer no mínimo uma vez
----------------------
7) {,} Chaves O item anterior deve aparecer na quantidade indicada {mín,máx}
----------------------
8) ^ Circunflexo Casa o começo da linha
----------------------
9) $ Cifrão Casa o fim da linha
----------------------
10) \b Borda Limita uma palavra (letras, números e sublinhado)
----------------------
11) \ Escape Escapa um meta, tirando seu poder
----------------------
12) | Ou Indica alternativas (usar com o grupo)
----------------------
13) () Grupo Agrupa partes da expressão, é quantificável e multinível
----------------------
14) \1 Retrovisor Recupera o conteúdo do grupo 1
----------------------
15) \2 Retrovisor Recupera o conteúdo do grupo 2 (segue até o \9)
----------------------
16) .* Curinga Casa qualquer coisa, é o tudo e o nada
----------------------
17) ?? Opcional NG Idem ao opcional comum, mas casa o mínimo possível
----------------------
18) *? Asterisco NG Idem ao asterisco comum, mas casa o mínimo possível
----------------------
19) +? Mais NG Idem ao mais comum, mas casa o mínimo possível
----------------------
20) {}? Chaves NG Idem às chaves comuns, mas casa o mínimo possível

.

EXPRESSÕES REGULARES E O COMANDO SED
-----------------------
EXPLICANDO UMA EXPRESSÃO REGULAR:
-----------------------

'\*\..{3}$'

-----------------------
Na expressão regular acima, as aspas simples são usadas para proteger a expressão e impedir que o interpretador de comandos dê um significado diferente a qualquer um dos caracteres. O * e o . são um asterisco e um ponto, literalmente, por isso são escapados por uma barra invertida. O . (ponto) significa um caractere qualquer, que é quantificado pelo número entre as chaves que o sucede. No caso, procuro por três caracteres após um asterisco e um ponto, mas isto por si só também abrangeria os casos onde temos extensões com mais de três letras. Para evitar que isto aconteça, dizemos que estes três caracteres são sucedidos por um “fim de linha”, representado pelo cifrão.
-----------------------

Executo os comandos abaixo:

.

# crio um arquivo para os testes

echo "Eu gosto de água de ar e terra. 1234567890" > teste.txt

cat teste.txt

ls -t

# substituir água por ar e vice-versa

sed -i 's/\(água\) e \(ar\)/\2 e \1/' teste.txt ; cat teste.txt

# substituir vogais 'a' ou 'u' por 'x'

sed -i 's/[ou]/x/g' teste.txt ; cat teste.txt

# substituir numeros pares por 0

sed -i 's/[2468]/0/g' teste.txt ; cat teste.txt

# substituir numeros impares por nada

sed -i 's/[13579]//g' teste.txt ; cat teste.txt

# substituir 3 primeiros caracteres por nada

sed -i 's/^...//g' teste.txt ; cat teste.txt

# substituindo espaços por nada

sed -i 's/\s//g' teste.txt ; cat teste.txt

.

Já é um bom começo. Se não usa Linux, teste em um terminal online.

.

cap-webminal

.

Até Breve!

🙂

.

Linux – dividindo arquivo por linhas

COMANDOS SPLIT e WC

.

Abro o terminal.

.

Executo:

1) man wc

2) man wc | grep -A 8 DESCRIPTION

3) man wc | grep -A 8 line

4) man split

5) man split | grep -A 8 DESCRIPTION

6) man split | grep -A 7 lines

.

> Gerar arquivos com cinco linhas ou arquivos de mil linhas cada...

.

Ex.

1) split -l 5 NomeDoArq.txt

2) split --lines=1000 NomeDoArq.txt

3) wc -l NomeDoArq.txt

4) ls -l

.

Executo:

.

cd ; mkdir split ; cd split/ ; echo -e 'L1\nL2\nL3\nL4\nL5\nL6\nL7\nL8\nL9\nL10 \nL1\nL2\nL3\nL4\nL5\nL6\nL7\nL8\nL9\nL20' > ArqL20.txt ; cat -n ArqL20.txt ; sleep 4 ; echo ; wc -l ArqL20.txt ; echo ; sleep 4 ; split -l 5 ArqL20.txt ; ls -tli ; sleep 4 ; cat -n xad ; echo ; cat -n xac ; echo

.

Abro o terminal pelo menu do sistema.

.

EXECUTO:

.

1) cd ; cd Downloads ; mkdir -p pasta/sub-pasta ; cd pasta/sub-pasta/ ; pwd

2) echo -e 'L1\nL2\nL3\nL4\nL5\nL6\nL7\nL8\nL9\nL10 \nL11\nL12\nL13\nL14\nL15\nL16\nL17\nL18\nL19\nL20' > ArqL20.txt

3) cat -n ArqL20.txt

4) wc -l ArqL20.txt

5) seq 40 > Arq40L.txt

6) cat -n Arq40L.txt

7) wc -l Arq40L.txt

8) split -l 5 Arq40L.txt

9) ls -tli

10) cat -n xab

11) cat -n xac

12) cat -n xad

13) rm x*

14) ls -t

15) sed -n '1,5 p' ArqL20.txt

16) sed -n '3,13 p' ArqL20.txt

17) sed -n '4,13 w foo.txt' ArqL20.txt

(Da linha 4 a linha 13 escreva no arquivo foo.txt)

18) cat -n foo.txt

19) echo $?

20) man sed

21) man sed | grep -A 8 DESCRIPTION

22) man sed | grep -A 8 REGULAR

23) man sed | grep -A 8 exit-code

24) echo $?

25) seq 1 5 20

26) seq 5 5 20

27) seq 1 5 20 > a1

28) seq 5 5 20 > a2

29) paste a1 a2

30) paste a1 <(seq 5 5 20)

31) paste <(seq 1 5 20) <(seq 5 5 20)

32) rm a?

33) paste -d , <(seq 1 5 20) <(seq 5 5 20)

34) paste -d , <(seq 1 5 20) <(seq 5 5 20) | sed 's/.*/& w foo.txt/'

35) paste -d , <(seq 1 5 20) <(seq 5 5 20) | sed 's/.*/& w foo-&.txt/'

36) paste -d , <(seq 1 5 20) <(seq 5 5 20) | sed 's/.*/& w Lines-&.txt/'

37) paste -d , <(seq 1 5 20) <(seq 5 5 20) | sed 's/.*/& w Lines-&.txt/'

38) paste -d , <(seq 1 5 20) <(seq 5 5 20) | sed 's/.*/& w Lines-&.txt/ ; s/ ,/-/2' ; echo $?

39) paste -d , <(seq 1 5 20) foo.sed ; echo $?

40) cat -n foo.sed ; echo $?

41) #sed -n -f foo.sed ArqL20.txt

42) rm foo*.txt

43) ls

44) sed -n -f foo.sed ArqL20.txt

45) ls

46) cat Lines-1,5.txt

47) cat -n Lines-6,10.txt

48) cat Lines-11,15.txt

49) cat -n Lines-16,20.txt

50) file Lines-1,5.txt

51) whereis Lines-16,20.txt

52) pwd Lines-11,15.txt

53) ls Lines-6,10.txt

54) rm foo.sed

55) echo ; paste -d , <(seq 1 5 20) <(seq 5 5 20) | sed 's/.*/& w Lines-&.txt/ ; s/ ,/-/2' ; echo

56) paste -d , <(seq 1 5 20) <(seq 5 5 20) | sed 's/.*/& w Lines-&.txt/ ; s/ ,/-/2' | sed -n -f - ArqL20.txt

57) clear ; echo ; ls -t ; echo

58) rm Lines-*

59) ls -t

60) paste -d , <(seq 1 5 20) ArquivoDeDestino

.

Ex.

cat x* > nome-do-arq.iso

.

Até Breve

🙂

.

Linux man exiftool grep cut tr sed touch echo

.

LINUX MAN EXIFTOOL GREP CUT TR SED TOUCH ECHO

.

1) man exiftool

2) man exiftool | grep -A 30 'File Types'

3) man exiftool | grep -A 60 'File Types'

4) exiftool nome-do-arquivo.qualquer_ext_de_'File Types'

5) exiftool nome-do-arquivo.mkv

6) exiftool nome-do-arquivo.png

7) exiftool nome-do-arquivo.mp4

8) exiftool nome-do-arquivo.mp3

9) exiftool nome-do-arquivo.jpg

10) exiftool nome-do-arquivo.jpg | grep Create

11) exiftool nome-do-arquivo.jpg | grep | cut -d : -f 2-

.

OBS:

O "| grep create" mostra a linha que tem a palavra Create.

Já "| cut -d : -f" apaga o que vem antes dos dois pontos.

O "-d" casa com o caractere ":".

O "-f" filtra os campos desejados ou não.

O "2-" mostra do campo 2 em diante. Os campos começam com campo zero, campo 1, campo 2, Etc.

.

12) touch nome-do-arquivo.jpg (Altera a data do arquivo. Pode ser mkv, png, mp4, mp3, Etc.)

13) man touch (Encontro opção -t)

14) man touch | grep -A 5 times

15) man touch | grep -A 3 STAMP

.

16) exiftool nome-do-arquivo.png | grep Create | cut -d : -f 2- | tr -d ': '

(Apaga os dois pontos e espaço em branco)

.

exiftool nome-do-arquivo.png | grep Create | cut -d : -f 2- | tr -d ': ' | sed 's/./&./'

(Insere um ponto. A parte final do comando usa expressões regulares)

.

exiftool nome-do-arquivo.png | grep Create | cut -d : -f 2- | tr -d ': ' | sed 's/./&./6'

(Insere um ponto na sexta ocorrência.)

.

exiftool nome-do-arquivo.png | grep Create | cut -d : -f 2- | tr -d ': ' | sed 's/./&./12'

(Insere um ponto na ocorrência 12.)

.

touch -t numeros-data-com-ponto-antes-das-2-ultimas-ocorrencias nome-do-arquivo.png

.

CRIAR UM LOOP

.

DIGITO NO TERMINAL:

for VARIAVEL in *.png (Teclo Enter)

do (Teclo Enter)

echo Esta VARIAVEL: (Teclo Enter)

done (Teclo Enter)

.

EXECUTO:

for VARIAVEL in *.png; do echo Essa VARIAVEL: $VARIAVEL; done

for VARIAVEL in *.png; do echo Essa Outra VARIAVEL: $VARIAVEL; done

for VARIAVEL in *.png; do echo touch -t .... $VARIAVEL ; done

.

COLOCANDO SUB SHELL DENTRO DO COMANDO:

(Quer dizer colocar um comando dentro de outro comando.)

.

EXEMPLO:

inicio-do-comando $(sub shel) fim-do-comando

.

EXEMPLO:

for VARIAVEL in *.png; do echo touch -t $(exiftool "$VARIAVEL" | grep Create | cut -d : -f 2- | tr -d ': ' | sed 's/./&./12') "$VARIAVEL" ; done

.

OBS:

1) No comando acima o "echo" simula o comando antes de executar realmente o comando. Para executar o comando removo o "echo".
2) Se coloco variável dentro de um comando coloco aspas.

.

REMOVER PERMISSÃO DE EXECUÇÃO DE TODOS OS ARQUIVOS EM UMA PASTA.

.

EXECUTO:

chmod -x *

.

cap-Vi-post

.

Dissecando uma Poesia usando Linux

Anotações Linux shell script

.

AnotacoesLinuxShellScript.txt

.

Não quero de forma alguma aprender tudo hoje nem amanhã. Saber tudo é horrível. Rouba de mim o prazer de estudar. Não saber é bom, pois assim, posso buscar e aprender alguma coisa. Qualquer coisa. Creio que uma pessoa que sabe tudo, no final, talvez não possa fazer nada.

.

CRIAR DIRETORIO/PASTA

.

mkdir -p ~/Downloads/NotasLinuxShell/EstLinux

.

NAVEGAR ATÉ EstLinux

.

cd ~/Downloads/NotasLinuxShell/EstLinux

pwd

.

OBJETIVO CONTAR PALAVRAS EM SHELL

.

criar um arquivo de texto com dezoito palavras em seis linhas

.

echo -e 'contando palavras shell \nFalantes loa leia \nLuz olhos shell \nCibernético planos sonda \nEscritor não loucura \nCharles Aluno1 leia' > ContarPalavrasEmShell.txt

.

EXECUTANDO COMAND WC DO PACOTE GNU COREUTILS

.

1) wc -w ContarPalavrasEmShell.txt

2) wc -w /etc/passwd

3) wc -l ContarPalavrasEmShell.txt

4) wc -l /etc/passwd

5) wc -c ContarPalavrasEmShell.txt

6) wc -c /etc/passwd

7) wc -m ContarPalavrasEmShell.txt

8) wc -m /etc/passwd

.

Se executar "echo 333 | wc -c" o resultado é 4

.

EXECUTO:

.

echo 333 | wc -c

.

ME INFORMANDO SOBRE O COMANDO UNIQ NA MANPAGE:

.

man uniq | grep count

.

man uniq | grep -A 1 count
.

man uniq | grep -A 3 count

.

man uniq | grep -A 5 count

.

EXECUTO:

echo ; cat ContarPalavrasEmShell.txt | uniq -c ; echo

.

O RESULTADO NÃO É BEM O CORRETO

.

EXECUTO:

echo ; cat ContarPalavrasEmShell.txt | sort | uniq -c ; echo

.

clear ; echo ; cat ContarPalavrasEmShell.txt | sort #| uniq -c ; echo

.

TEM QUE SER UMA PALAVRA POR LINHA LINHA E ESTAS LINHAS DEVEM ESTAR ORDENADAS.

.

CRIO NOVO ARQUIVO DE TEXTO

.

EXECUTO:

echo -e 'leia1\nleia2\nleia3\nleia4\nleia5' > LeiaPalavrasEmShell.txt

.

EXECUTO:

.

cat LeiaPalavrasEmShell.txt | sort | uniq -c

.

cat LeiaPalavrasEmShell.txt | sort #| uniq -c

.

COPIO ESTE TEXTO DA INTERNET:

.

Se vai tentar
siga em frente.
Senão, nem começe!
Isso pode significar perder namoradas
esposas, família, trabalho...e talvez a cabeça.
Pode significar ficar sem comer por dias,
Pode significar congelar em um parque,
Pode significar cadeia,
Pode significar caçoadas, desolação...
A desolação é o presente
O resto é uma prova de sua paciência,
do quanto realmente quis fazer
E farei, apesar do menosprezo
E será melhor que qualquer coisa que possa imaginar.
Se vai tentar,
Vá em frente.
Não há outro sentimento como este
Ficará sozinho com os Deuses
E as noites serão quentes
Levará a vida com um sorriso perfeito
É a única coisa que vale a pena.
-- Charles Bukowski

.

EXECUTO:

.

vi PoesiaBukowski.txt

.

Aperto Esc. digito i. colo o texto copiado com o mouse. confiro. Aperto Esc. Digito :wq.

.

EXECUTO:

ls -tli

.

clear

cat | uniq -c PoesiaBukowski.txt

.

OBS:
teclo Ctrl C

.

MAS QUERO CONTAR UMA PALAVRA POR LINHA

.

EXECUTO:

cat PoesiaBukowski.txt | sort | uniq -c

.

PARA UMA PALAVRA POR LINHA USO "xargs -n 1"

.

EXECUTO:

1)

cat PoesiaBukowski.txt | xargs -n 1

2)

clear ; echo ; cat PoesiaBukowski.txt | xargs -n 1 ; echo

3)

cat PoesiaBukowski.txt | xargs -n 3

4)

clear ; echo ; cat PoesiaBukowski.txt | xargs -n 3 ; echo

5)

cat PoesiaBukowski.txt | xargs -n 4

6)

clear ; echo ; cat PoesiaBukowski.txt | xargs -n 4 ; echo

.

SEM VIRGULAS E PONTOS

.

EXECUTO:

cat PoesiaBukowski.txt | egrep -o '\w+'

.

PARA ORDENAR E PARA CONTAR

.

EXECUTO:

clear

cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c

.

ORDENAR OS QUE MAIS APARECEM

.

EXECUTO:

clear

cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c | sort -n

.

ISTO É ÚTIL SE EU ESCREVO UM TEXTO E TENHO VÍCIO DE USAR CERTAS PALAVRAS EM EXCESSO, ACHO EU; QUE ESCREVO.

.

MOSTRAR DO MAIOR PARA O MENOR

.

EXECUTO:

clear

cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c | sort -n -r

.

PARA VER SÓ AS DEZ PRIMEIRAS

.

EXECUTO:

clear

cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c | sort -n -r | head

.

PARA VER A QUE MAIS APARECE NO TEXTO:

.

EXECUTO:

cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c | sort -n -r | head -n1

.

PARA VER AS 7 QUE MAIS APARECEM

.

EXECUTO:

1) clear

2) cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c | sort -n -r | head -n 7

3) echo ; cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c | sort -n -r | head -n 7 ; echo

4) egrep -o '\w+' (uma palavra por linha), sort (ordena), uniq -c (conta), sort -n -r (o resultado é ordenado numericamente do maior para o menor), head -n 7 (pega as sete primeiras)

.

Me pergunto se num desafio, alguém poderia produzir um texto poderoso como o que achei na internet usando as sete palavras mais usadas na poesia:

.

5 significar
4 Pode
4 a
3 que
3 em
3 E
2 vai

.

QUERO SÓ AS QUE TIVEREM TRES LETRAS OU MAIS.

.

EXECUTO:

1)

cat PoesiaBukowski.txt | egrep -o '\w+' | grep ...

2)

cat PoesiaBukowski.txt | egrep -o '\w+' | grep .....

3)

cat PoesiaBukowski.txt | egrep -o '\w+' | grep ... | sort | uniq -c | sort -n -r | head -n 7

4)

clear ; echo ; cat PoesiaBukowski.txt | egrep -o '\w+' | grep ... | sort | uniq -c | sort -n -r | head -n 7 ; echo

5)

cat PoesiaBukowski.txt # | egrep -o '\w+' | grep ... | sort | uniq -c | sort -n -r | head -n 7

6)

cat PoesiaBukowski.txt | egrep -o '\w+' # | grep ... | sort | uniq -c | sort -n -r | head -n 7

.

E assim usando Linux disseco uma poesia.

.

Até Breve

.

Meu Quarto Script Vi

Meu Quarto Script Vi

.

LINUX COMANDOS E SHELL SCRIPT

----------------------

EXECUTO OS COMANDOS:

1) cd ; cd Downloads/ ; mkdir EstudoEmDown ; cd EstudoEmDown/ ; echo -e 'Xandra \nUtacilio\nFlorildo \nInaciana \nKaline\nBertoco \nAnistica \nDoelha \nVentroto \nClarada \nHugal \nMirto \nErebrow \nLenicia \nPlobo' > Alista_de_list.txt

2) cd

3) ARQ_CRIATURAS='Downloads/EstudoEmDown/Alista_de_list.txt'

4) sort $ARQ_CRIATURAS

.

DEPOIS EXECUTO:

1) > MeuQuartoScriptVi.sh

2) chmod +x MeuQuartoScriptVi.sh

3) vi MeuQuartoScriptVi.sh

4) Aperto Esc digito i e colo:

#!/bin/bash
#
##################################
# Nome do Script: MeuQuartoScriptVi.sh
#
# Descrição:
# 1) monom nomnom monm
# 2) nomo nom nomonm
# 3) mon mobm nomobm
#
# Autor: Fulano de Tal
#
# Data da Criação: DD/MM/YYYY
#
# Email: meu_mail1@mail.com
#
#
##################################
#
#
# Sobre este script:
# 1) nononono nono nono nonon
# 2) momo momoo momoom momom
# 3) nono mo mo momom
#
# Exemplo de uso:
# 1) nom nmomomomn momomono nomonm
# 2) monom monomomnom nomom nmonm
#
# Histórico de modificações:
# 1) Dia X - Inclusão da função de...
# 2) monm monomonom mnomo nomoomn
#
# Comentário:
# 1) monom monom monomon
# 2) monom nomonmom nomo
#
# REGRAS DO CÓDIGO LIMPO:
#
# 1) Colocar apenas um comando por linha
#
# 2) Alinhar verticalmente comandos de um mesmo bloco
#
# 3) Deslocar o alinhamento a direita a cada novo bloco
#
# 4) Usar linhas em branco para separar trechos
#
# 5) Não ultrapassar o limite de 80 colunas por linha
#
#
# COMENTÁRIOS ESPECIAIS:
#
#
# TODO - indica uma tarefa a ser feita
# 1)
# 2)
# 3)
#
# FIXME - indica um bug conhecido que precisa ser arrumado
#
#
#
# XXX - Notícia, chama a atenção
#
#
#
##################################

# Nota: As variaveis sao sempre declaradas no comeco do script

# Nota: Crio o arquivo que vai ser usado neste script com o comando: cd ; cd Downloads/ ; mkdir EstudoEmDown ; cd EstudoEmDown/ ; echo -e 'Xandra \nUtacilio\nFlorildo \nInaciana \nKaline\nBertoco \nAnistica \nDoelha \nVentroto \nClarada \nHugal \nMirto \nErebrow \nLenicia \nPlobo' > Alista_de_list.txt

# Nota: o comando da primeira variável é "date +%H:%M" ele está entre parenteses "()" e precedido de "$"

DATAHORA=$(date +%H:%M)

# Nota: Declarando a segunda variavel do script

ARQ_CRIATURAS='Downloads/EstudoEmDown/Alista_de_list.txt'

# Nota: comando que limpa a tela do emulador de terminal

# Daqui para baixo começa o script

clear # comando que limpa a tela do emulador de terminal

# Funcao de leitura data e hora

echo "==== MeuQuartoScriptVi.sh ===="
sleep 2
echo ""
echo -n "Data e hora: $DATAHORA"

sleep 3 # intervalo de tempo destinado a leitura da data e hora

# Area de leitura da lista de criaturas

echo ""
echo "== Listagem de Criaturas: =="
echo ""
sleep 2
sort $ARQ_CRIATURAS
echo ""
sleep 5
sort Alista_de_list.txt
echo ""
sleep 5
echo ""
echo "=== Últimos arquivos modificados: ==="
echo ""
sleep 2
ls -t # Lista arquivos e diretórios por data de modificação
echo ""
sleep 8

5) Aperto Esc e digito :wq

6) cp MeuQuartoScriptVi.sh ~/

7) cd ~/

8) Executo o comando:

./MeuQuartoScriptVi.sh

9) cd Downloads/EstudoEmDown/

10) sh MeuQuartoScriptVi.sh

----------------------

Linux – comandos e shell script – meu treceiro script Vi

MEU TERCEIRO SCRIPT USANDO VI:

.

#!/bin/bash

#####################################
# Nome do Script: MeuTerceiroScriptVi.sh
#
# Descrição:
# 1) monom nomnom monm
# 2) nomo nom nmonm
# 3) mon mobm nmobm
#
# Autor: Fulano de Tal
#
# Data da Criação: DD/MM/YYYY
#
# Email: meu_mail1@mail.com
#
#
#####################################
#
#
# Sobre este script:
# 1) nononono nono nono nonon
# 2) momo momoo momoom momom
# 3) nono mo mo momom
#
# Exemplo de uso:
# 1) nom nmomommn mmmnoomonm
# 2) monom monmomnom nmom nmonm
#
# Histórico de modificações:
# 1) Dia X - Inclusão da função de...
# 2) monm mnmonm mnomo nmoomn
#
# Comentário:
# 1) monom monom monomon
# 2) monom nomonmom nomo
#
# REGRAS DO CÓDIGO LIMPO:
#
# 1) Colocar apenas um comando por linha
#
# 2) Alinhar verticalmente comandos de um mesmo bloco
#
# 3) Deslocar o alinhamento a direita a cada novo bloco
#
# 4) Usar linhas em branco para separar trechos
#
# 5) Não ultrapassar o limite de 80 colunas por linha
#
#
# COMENTÁRIOS ESPECIAIS:
#
#
# TODO - indica uma tarefa a ser feita
# 1)
# 2)
# 3)
#
# FIXME - indica um bug conhecido que precisa ser arrumado
#
#
#
# XXX - Notícia, chama a atenção
#
#
#
#####################################

DATAHORA=$(date +%H:%M) # As variaveis sao sempre declaradas no comeco do script

clear
# Funcao de leitura data e hora
echo "==== Meu Terceiro Script Vi ===="
sleep 2
echo ""
echo "======================"
echo -n "Data e hora: $DATAHORA"
sleep 3

# Area de leitura da lista de criaturas
echo "======================"
echo "Listagem de Criaturas:"
sleep 2
echo "======================"
sort Alista_de_list.txt
sleep 5
echo ""
echo "======================"
echo "=== Últimos arquivos modificados: ==="
sleep 2
echo "======================"
ls -t # Lista arquivos e diretórios por data de modificação
echo "======================"
sleep 8
exit

.

Executo:

.

1) > MeuTerceiroScriptVi.sh

2) chmod +x MeuTerceiroScriptVi.sh

3) vi MeuTerceiroScriptVi.sh

4) Aperto Esc digito i e colo:

#!/bin/bash

#####################################
# Nome do Script: MeuTerceiroScriptVi.sh
#
# Descrição:
# 1) monom nomnom monm
# 2) nomo nom nmonm
# 3) mon mobm nmobm
#
# Autor: Fulano de Tal
#
# Data da Criação: DD/MM/YYYY
#
# Email: meu_mail1@mail.com
#
#
#####################################
#
#
# Sobre este script:
# 1) nononono nono nono nonon
# 2) momo momoo momoom momom
# 3) nono mo mo momom
#
# Exemplo de uso:
# 1) nom nmomommn mmmnoomonm
# 2) monom monmomnom nmom nmonm
#
# Histórico de modificações:
# 1) Dia X - Inclusão da função de...
# 2) monm mnmonm mnomo nmoomn
#
# Comentário:
# 1) monom monom monomon
# 2) monom nomonmom nomo
#
# REGRAS DO CÓDIGO LIMPO:
#
# 1) Colocar apenas um comando por linha
#
# 2) Alinhar verticalmente comandos de um mesmo bloco
#
# 3) Deslocar o alinhamento a direita a cada novo bloco
#
# 4) Usar linhas em branco para separar trechos
#
# 5) Não ultrapassar o limite de 80 colunas por linha
#
#
# COMENTÁRIOS ESPECIAIS:
#
#
# TODO - indica uma tarefa a ser feita
# 1)
# 2)
# 3)
#
# FIXME - indica um bug conhecido que precisa ser arrumado
#
#
#
# XXX - Notícia, chama a atenção
#
#
#
#####################################

DATAHORA=$(date +%H:%M) # As variaveis sao sempre declaradas no comeco do script

clear
# Funcao de leitura data e hora
echo "==== Meu Terceiro Script Vi ===="
sleep 2
echo ""
echo "======================"
echo -n "Data e hora: $DATAHORA"
sleep 3

# Area de leitura da lista de criaturas
echo "======================"
echo "Listagem de Criaturas:"
sleep 2
echo "======================"
sort Alista_de_list.txt
sleep 5
echo ""
echo "======================"
echo "=== Últimos arquivos modificados: ==="
sleep 2
echo "======================"
ls -t # Lista arquivos e diretórios por data de modificação
echo "======================"
sleep 8
exit

5) Aperto Esc e digito :wq

6) Executo com o comando:

./MeuTerceiroScriptVi.sh

.

Muito beleza. Tudo ok!

.

Viva o GNU/Linux! Se não gosta, que remova coreutils vai fazer o que da vida então?

.

https://pt.wikipedia.org/wiki/GNU_Core_Utilities

.