.
COMANDOS MAIS USADOS DO SHELLSCRIPT 08
.
Sobre o Comandos mais usados do shellscript 08:
É para iniciantes. Pretende oferecer o máximo de informação possível em pouco tempo, para que a pessoa ao terminar de EXECUTAR este artigo entenda bastante coisa sobre shell script e seja capaz de criar scripts úteis para si mesma. Desde o primeiro artigo eu editei ele umas oito vezes. Para mim este ficou mais interessante. Longe de ser perfeito, peço que faça vista grossa a erros de digitação ou definições ligeiramente incoerentes. O negócio é que este artigo é realmente útil para mim e espero que seja útil para você também. A maior parte deste artigo é fruto de pesquisa, mas alguns trechos eu escrevi e reescrevi.
.
Por favor não esqueça de dar intervalos em seus estudos para se esticar, hidratar, etc.
Sabe por que?
Porque depois de executar algumas partes deste artigo a ficha cai, a pessoa fica animada e não quer parar (tipo eu).
.
Vamos lá?
.
Qual é o seu usuário?
.
Se você não tem certeza qual é o seu usuário, use o comando "whoami" sem aspas, para saber.
.
Abra o terminal pelo menu do sistema.
.
Como o prompt de usuário normal pode ser diferente para cada um, podemos em algum momento usar "prompt$" para indicar o prompt da linha de comando.
.
ALGUMAS DICAS ÚTEIS QUE SERÃO REPETIDAS DURANTE O CAMINHO:
.
1
Não execute shell script como root.
.
2
O shell script Linux usando o interpretador de comandos Bash começa com o shebang:
#!/bin/bash
.
3
Abra um editor de texto e cole nele o script salvando com um nome que termine com extensão .sh
.
4
Dar permissão para executar o script pode ser só para você ou para todos usarem:
chmod +x MeuScript.sh (só você)
chmod a+x MeuScript.sh (todos os usuários do PC)
.
5
Um script pode ser executado de 3 modos:
bash MeuScript.sh
sh MeuScript.sh
./MeuScript.sh
.
Exemplo para começar bem. Copie e cole o código abaixo no terminal que você vai abrir pelo MENU DO SISTEMA:
.
echo -e '#!/bin/bash\nclear\necho\necho Olá usuário Linux!\nsleep 2\necho\necho Olá Mundo!\nsleep 2\nVALOR=GNU/Linux\necho\necho Você quer aprender comandos $VALOR?\nsleep 2\necho\necho Então vamos aprender comandos $VALOR!\nsleep 2\necho\necho Até Breve usuário Linux!\necho\nsleep 2\nexit' > 03-olauser.sh ; chmod +x 03-olauser.sh ; bash 03-olauser.sh
.
Para remover o script criado pelo código acima, o arquivo 03-olauser.sh, use o mouse e o gerenciador de arquivos ou copie e cole o comando abaixo no mesmo terminal onde executou o código:
.
unset VALOR ; sleep 2 ; rm 03-olauser.sh ; sleep 2 ; ls -t ; sleep 2 ; exit
.
TEMOS VÁRIOS COMANDOS MAIS USADOS EM SHELL SCRIPT:
.
Operadores Aritméticos:
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Módulo
** Exponenciação
.
TEM ESTES COMANDOS ABAIXO:
.
awk cat cd chmod cut date diff echo find grep head kill ls printf rev scp sed seq sort ssh tac tail top
.
MAIS COMANDOS QUE VOCÊ PODE USAR EM SHELL SCRIPT:
.
echo Imprime texto na tela
read Captura dados do usuário e coloca numa variável
exit Finaliza o script
sleep Dá uma pausa em segundos no script
clear Limpa a tela
if Controle de fluxo que testa uma ou mais expressões
case Controle de fluxo que testa várias expressões ao mesmo tempo
for Controle de fluxo que testa uma ou mais expressões
while Controle de fluxo que testa uma ou mais expressões
.
O MAIS IMPORTANTE É ENTENDER: if, then, else, case, for e while. ISTO É MAIS PARA O FINAL.
.
Porém, podemos de repente fazer tudo ao contrário!
Podemos porque os melhores scripts e tutoriais já foram criados.
Aqui a gente dá um pulo e entende coisas impressionantes sobre shell script.
Graças ao mestre Carlos E. Morimoto.
Veja só:
.
Um script para pegar arquivo de vídeo da internet e converter para .mp3 e depois se quiser pegar o vídeo (faça o teste):
.
#!/bin/bash
# Nome do script: 04-youtube_download-mp3.sh
# Na minha home crio uma pasta bin e dentro desta pasta bin coloco os scripts. Nesta pasta bin/ crio uma pasta chamada youtube-dl assim:
# cd ; mkdir -p bin/youtube-dl
# Este script eu coloco na pasta bin/
echo
echo 'Obter arquivo de áudio'
sleep 2
echo
echo "Digite a URL do arquivo a baixar"
read arquivo
cd ; cd bin/ ; cd youtube-dl/ ; youtube-dl --extract-audio --audio-format mp3 ${arquivo}
echo -e 'Gostaria de obter arquivo de video?\n \nCaso não queira digite:\n \nCtrl+C'
sleep 3
echo
echo "Digite a URL do arquivo a baixar"
read arquivo
cd ; cd bin/ ; cd youtube-dl/ ; youtube-dl ${arquivo}
# Fim do script
.
Para scripts mais completos, precisamos começar a usar as operações lógicas, que permitem que o script tome decisões. O formato mais básico é o "se, então, senão", que no shell script é representado pelos operadores "if", "then" e "else"
.
Imagine que você está fazendo um script conversor de vídeos, que é capaz de gerar arquivos em quatro diferentes formatos. O script começa perguntando qual formato usar e, de acordo com a resposta, executa os comandos apropriados para fazer a conversão.
Para simplificar, vamos fazer com que o script simplesmente converta todos os arquivos dentro do diretório atual, em vez de perguntar quais arquivos converter ou de exibir uma caixa de seleção.
A parte da pergunta poderia ser feita com o "echo", como no exemplo anterior. Como agora são várias linhas de texto, usei aspas simples ( ' ) em vez de aspas duplas. As aspas simples permitem que você inclua quebras de linha e caracteres especiais dentro do texto, fazendo com que o shell simplesmente escreva tudo literalmente:
.
echo 'Escolha o formato de saída:
1) MPEG4, 320x240 (vídeos no formato 4:3)
2) MPEG4, 320x176 (vídeos em formato wide)
3) Real Player, 320x240 (vídeos no formato 4:3)
4) Real Player, 320x176 (vídeos em formato wide)
(Responda 1, 2, 3 ou 4, ou qualquer outra tecla para sair)'
read resposta
.
No final deste trecho, teríamos a variável "resposta", que armazenaria um número de 1 a 4. Precisamos agora fazer com que o script decida o que fazer de acordo com a resposta.
.
O jeito mais simples de fazer isso seria simplesmente colocar um bloco com 4 comandos "if" (se), um para cada possibilidade. Cada "if" é sempre acompanhado por um "then" (então) e um "fi" (fim do se), como em:
if [ "$resposta" = "1" ]; then
[comandos ...]
fi
if [ "$resposta" = "2" ]; then
[comandos ...]
fi
if [ "$resposta" = "3" ]; then
[comandos ...]
fi
if [ "$resposta" = "4" ]; then
[comandos ...]
fi
.
Uma forma mais elegante (e mais à prova de falhas), seria usar o "elif" (que poderia ser traduzido para "senão se") e o "else" (senão), como em:
if [ "$resposta" = "1" ]; then
[comandos ...]
elif [ "$resposta" = "2" ]; then
[comandos ...]
elif [ "$resposta" = "3" ]; then
[comandos ...]
elif [ "$resposta" = "4" ]; then
[comandos ...]
else
echo "Você digitou uma opção inválida. O script termina aqui."
fi
.
Como pode ver, ao usar o elif você não precisa mais incluir um "fi" para cada possibilidade. Outra vantagem é que você pode agora incluir um "else" no final, que faz com que o script responda com uma mensagem de erro ao receber alguma resposta que não estava esperando. Dentro de cada uma das condições, você incluiria um bloco de comandos destinado a gerar os arquivos convertidos com os parâmetros correspondentes, como em:
if [ "$resposta" = "1" ]; then
for i in *; do
mencoder -oac mp3lame -lameopts cbr:br=128 -ovc lavc -lavcopts \
vcodec=mpeg4:vbitrate=512 -ofps 16 -vf scale=320:176 -o "c-$i" "$i"
done
elif [ "$resposta" = "2" ]; then
[o resto do script...]
.
Esse comando gigante que se esparrama pela terceira e a quarta linha é um comando de conversão do mencoder (um pequeno utilitário de conversão de arquivos de mídia em modo texto, que é bastante flexível), que gera um arquivo de vídeo otimizado para ser assistido em smartphones. Esse é o tipo de comando que é longo demais para ser escrito manualmente, mas que pode perfeitamente ser usado através de um script.
Veja que a variável "i" é usada no final da quarta linha, para indicar o nome do arquivo. O "c-$i" "$i" faz com que o script adicione o prefixo "c-" no nome dos arquivos convertidos, permitindo que eles sejam incluídos na pasta sem apagar os arquivos originais.
O comando do mencoder é colocado dentro de outra condicional, agora usando o "for" (enquanto), que permite que o script execute um conjunto de comandos repetidamente.
No exemplo, ele é usado para fazer com que o comando de conversão do mencoder seja executado uma vez para cada arquivo dentro da pasta. Ao ser executado, a variável "i" (poderia ser qualquer outro nome) recebe o nome do primeiro arquivo, o que faz com que ele seja convertido.
Ao chegar no "done", o interpretador volta à linha inicial e a variável "i" recebe agora o nome do segundo arquivo. O processo é então repetido para cada um dos arquivos da pasta, até o último (a lista dos arquivos a converter é gerada pelo interpretador no início do script, por isso não existe o risco do conversor ficar em loop). O "for i in *; do" poderia ser traduzido como "para cada arquivo dentro da pasta atual, execute".
.
Confere este script abaixo:
.
#!/bin/bash # Onde o script vai rodar
# Exemplo de instrução IF
echo "Script para estudo de Shell Script - Função IF" # Exibe a frase entre ""
echo "Digite um número de 0 a 10:" # Exibe a frase entre ""
read num # Pega a resposta do user e salva na variável "num"
if [ $num 5 ] ; then # Caso a variável "num" seja maior que 5, faça
echo "Vc digitou o número $num, que é maior que 5" # Exibe a frase entre ""
else # Caso contrário...
echo "Voce não digitou um número válido" # Exibe a frase entre ""
fi
# Fim do script
.
AGORA VOLTEMOS AO PRINCÍPIO.
.
ESCOLHER O DIRETÓRIO ONDE COLOCAR O SCRIPT
Para que o script possa ser executado de qualquer parte do sistema, mova-o para um diretório que esteja no seu PATH. Para ver quais são estes diretórios, abra agora o terminal pelo menu do sistema e digite o comando:
echo $PATH
.
Exemplo:
~ $echo $PATH
/home/eu_user/bin:/sbin:/bin:/usr/sbin:/usr/bin:/snap/bin:/home/eu_user/bin
.
Se não tiver permissão de mover para um diretório do PATH, deixe-o dentro de seu diretório pessoal ($HOME). Digite no terminal: $HOME
.
CRIAR O ARQUIVO E COLOCAR NELE OS COMANDOS
Abra pelo menu do sistema o editor de texto gedit, pluma, leafpad, mousepad ou outro editor de textos de sua preferência para colocar todos os comandos dentro do arquivo.
.
COLOQUE A CHAMADA DO SHELL (shebang) NA PRIMEIRA LINHA
A primeira linha do script deve ser:
#!/bin/bash
.
Deve ser assim para que ao ser executado, o sistema saiba que é o BASH quem irá interpretar estes comandos.
.
TORNE O SCRIPT UM ARQUIVO EXECUTÁVEL
.
Use o seguinte comando para que seu script seja reconhecido pelo sistema como um comando executável:
.
chmod +x nome-do-teu-shellscript.sh
.
PARA PERMITIR QUE TODOS OS USUÁRIOS POSSAM EXECUTAR O SCRIPT:
.
chmod a+x nome-do-teu-shellscript.sh
.
EXECUTE O SCRIPT:
./nome-do-teu-shellscript.sh (Aqui "./" representa o diretório atual)
.
/home/seu-usuário/bin/nome-do-teu-shellscript.sh (Aqui informa onde está o script para que o bash execute em outra pasta)
.
BASH EXECUTANDO COMANDOS
.
Shell script é uma linguagem de script usada em vários sistemas operacionais, com diferentes dialetos, dependendo do interpretador de comandos utilizado.
.
Um exemplo de interpretador de comandos é o bash, usado na grande maioria das distribuições GNU/Linux.
.
A maior parte dos usuários classificam shell script como uma linguagem de fácil aprendizagem. Mas não é tão fácil assim. O primeiro passo é, saber o que se deseja fazer, então ver qual o código que executa este comando em shell e aí criar, basta escrever o código em algum editor de texto e salvar. Veja só por exemplo, que de tempos em tempos você quer saber informações do sistema, instalar programas, remover programas, converter/alterar/escrever arquivos, fazer backups, adicionar informações, remover informações, criar/mover/duplicar pastas, arquivos etc.
.
AGORA ABRE O TERMINAL E DIGITA COMANDOS, POR EXEMPLO, DIGITE ESTES COMANDOS ABAIXO UM DE CADA VEZ:
.
apropos shell
whereis bash
whatis bash
echo $SHELL
clear
echo
echo ''
echo ""
echo "Olá!"
printf 'Bem vindo ao bash!' (Aperte a tecla enter e digite: ls)
echo '#!/bin/bash'
echo "#!/bin/bash"
ls -t
ls -a
echo ; echo "Olá!" ; echo
echo -e 'Bom\nDia\nMundo!'
echo -e "Bom\nDia\nMundo!"
echo "Hello world!"
echo "Hello "world"!"
echo "Hello \"world\"!"
echo -e "1\t2\t3"
echo -e '1\t2\t3'
echo -e "Nós\tVós\tEles(as)"
echo -e 'Nós\tVós\tEles(as)'
printf "Hello world" (Aperte a tecla enter e digite: df -h)
pwd
clear
ls -ta
sleep 7
echo ; echo 'Olá!' ; sleep 3 ; ls -t
free -h -t
free -th
sleep 4
date
date -d "yesterday"
date -d "2 days ago"
date +"%d/%m/%Y"
cal
du -h
clear
uptime
uname -a
free -tmlh
whatis df
df -a -h
df -k -l
df -T -m
whatis history
history
echo ; whoami ; echo
ls ; echo ; pwd ; echo
echo ; ls -at ; echo
echo "sou \n um \n texto"
echo -e "sou \n um \n texto"
whatis du
du *
ls -lah
du -ach
lsb_release
lsb_release -a
whatis cat
cat /etc/hostname
cat -n /etc/hostname
cd ..
pwd
VARIAVEL="Meu diretório atual é o `pwd`"
echo $VARIAVEL
unset VARIAVEL
echo $VARIAVEL
ls
cd -
pwd
ls
clear
echo ; echo 'df: Relata o espaço de disco usado pelo sistema (Usado e Livre)' ; echo ; df -h ; echo
ls -hat
echo ; echo "du: Relata o espaço utilizado no disco de tal arquivo ou diretório" ; echo ; du -hcs ; echo
echo ; echo 'env (Este comando oferece uma lista de variáveis. Entre elas PWD, USER, SESSION_MANAGER e LANG)' ; sleep 4 ; echo ; env ; echo
clear
echo $PWD
echo ${PWD}
echo $USER
echo "Eu estou logado como usuário $USER"
echo $SESSION_MANAGER
echo ${SESSION_MANAGER}
echo $LANG
VALOR="Linux"
echo $VALOR
echo ${VALOR}
echo $VALOR $VALOR
echo ${VALOR} ${VALOR}
VALOR='ls -t'
$VALOR
${VALOR}
VALOR='history'
echo $VALOR
$VALOR
echo ${VALOR}
${VALOR}
unset VALOR
VALOR=$(cat /etc/hostname)
echo $VALOR
$VALOR
clear
VALOR='free -h -t'
$VALOR
${VALOR}
echo $VALOR
echo ${VALOR}
echo VALOR
echo -e '\nSaiba que ao usar o comando read VALOR\n \n(Aperte a tecla enter, digite: "ls" sem aspas e aperte enter.)\n \nDepois execute $VALOR\n \nVamos ver isto logo abaixo:\n'
read VALOR
$VALOR
${VALOR}
read VALOR
.
OBS: Aperte a tecla enter, digite: "uptime" sem aspas e aperte enter.
.
$VALOR
${VALOR}
echo "Entre com o valor para a variável: " ; read VARIAVEL
$VARIAVEL
unset VARIAVEL
VALOR='du -hcs'
echo ; $VALOR ; echo ; $VALOR ; echo
echo ; $VALOR ; sleep 4 ; echo ; $VALOR ; echo
echo ; ${VALOR} ; sleep 4 ; echo ; ${VALOR} ; echo
clear
unset VALOR
echo ; $VALOR
$VALOR
${VALOR}
echo ; ${VALOR}
VALOR='lsb_release -a'
$VALOR
VALOR=$(lsb_release -a)
echo $VALOR
echo -e '\nOlá!\nVamos\nSaber\nOs\nComandos\ndo\nShellscript Linux!'
clear ; echo -e '\n \nOlá!\n \nVamos\n \nSaber\n \nOs\n \nComandos\n \ndo\n \nShellscript Linux!\n'
HOJE=$(lsblk)
echo "Informação sobre dispositivos de bloco: $HOJE"
echo "Informação sobre dispositivos de bloco: ${HOJE}"
HOJE=$(cal)
echo "Informação sobre o calendário atual: $HOJE"
HOJE=$(uptime)
echo "Informação sobre tempo de funcionamento desta máquina: $HOJE"
clear
HOJE=$(lsblk)
echo 'Informação sobre dispositivos de bloco: $HOJE'
echo 'Informação sobre dispositivos de bloco: ${HOJE}'
unset HOJE
echo $HOJE
echo ${HOJE}
echo `expr 3 + 2`
echo $((3+2))
echo `expr 9 + 4`
echo $((9+4))
echo $((2*3))
echo 'dois vezes três é:' $((2*3))
echo $((2*4-2/2+3))
VALOR=44
echo $VALOR
echo $((VALOR*1))
echo $((VALOR*2))
echo $((VALOR*3))
echo $VALOR
VALOR=$((VALOR+1))
echo $VALOR
VALOR=$((VALOR+11))
echo $VALOR
VALOR=$((VALOR+1))
echo $VALOR
VALOR=$((VALOR+11))
echo $VALOR
unset VALOR
echo $VALOR
VALOR="echo -e \nBom\nDia\nMundo\nLinux\n"
$VALOR
echo $VALOR
echo ${VALOR}
VALOR=$(uname -a)
echo $VALOR
HOJE=$(arch)
echo $HOJE
clear
VALOR=$(uname -a) ; echo ; echo "Informação sobre o kernel: $VALOR" ; sleep 4 ; echo ; VALOR=$(arch) ; echo "Informação sobre a arquitetura do sistema: $USER" ; echo ; sleep 2
unset VALOR
unset HOJE
clear
printf "%-5s %-10s %-4s\n" No Nome Pontos
printf "%-5s %-10s %-4.2f\n" 1 Marta 8
printf "%-5s %-10s %-4.2f\n" 2 Joel 9
printf "%-5s %-10s %-4.2f\n" 3 Carlos 7
echo -e "\e[1;31m Este é o texto em vermelho \e[0m"
echo -e "\e[1;32m Este é o texto em verde \e[0m"
echo -e "\e[1;32m Este é o \e[1;34mtexto \e[1;31mmisturado \e[0m"
VALOR="echo -e \e[1;31m\nBom\nDia\nMundo\nLinux\n\e[0m"
$VALOR
echo $VALOR
echo ${VALOR}
unset VALOR
$VALOR
echo $VALOR
unset HOJE
echo $HOJE
clear
exit
.
Muito bom que você digitou um comando de cada vez.
Os comandos mais longos pode copiar e colar no terminal se quiser, mas no início seria melhor digitar.
Saiba que a partir deste momento você já está entendendo coisas extremamente úteis para escrever shellscript usando o Bash!
Uma coisa interessante sobre a maior parte dos comandos acima, é que para estudar eles, você não precisa estar conectado a internet.
Os comandos acima oferecem informações interessantes e úteis. Podemos colocar todos eles em um só script e executar. Dependendo do caso, é mais fácil que digitar um a um de cada vez toda vez que precisar.
.
SE PUDER, ANTES DE CONTINUAR EXECUTE OS COMANDOS ACIMA QUE TE CHAMARAM MAIS A ATENÇÃO DE NOVO POIS, EXECUTAR ELES É MUITO DIDÁTICO. NADA MELHOR QUE APRENDER PRATICANDO.
.
OBS:
Voce pode ajustar o PATH no Linux tornando mais fácil executar scripts. Em algumas distros parece que só de criar a pasta bin/, atualizar, adicionar o PATH ao .bashrc e reiniciar já deixa tudo pronto.
O .bashrc está na tua home para ver ele aperte as teclas Ctrl+H porque todo arquivo precedido por "." fica oculto no Linux.
.
ALTERAR A VARIÁVEL DE AMBIENTE PATH (Cuidado!!!) - É por sua conta e risco.
.
Criar um subdiretório no seu diretório local, para guardar seus scripts e seus programas compilados.
.
Pode informar este diretório específico ao PATH.
.
Você pode ver o conteúdo da variável de ambiente $PATH com o comando echo:
echo $PATH
.
Crie um subdiretório, no seu home, chamado ‘bin’, e o inclua no PATH. Assim:
whoami
cd
pwd
mkdir bin
ls -t
export PATH=$PATH:$HOME/bin
echo $PATH
.
Se quiser torná-la permanente, no final do arquivo ‘.bashrc’ inclua a linha abaixo copiando e colando ela no .bashrc usando um editor de texto:
export PATH=$PATH:$HOME/bin
.
Pode fazer isto pelo terminal também:
cd ; echo 'export PATH=$PATH:$HOME/bin' >> .bashrc
.
TALVEZ NÃO SEJA NECESSÁRIO MAS:
.
ACRESCENTAR O CAMINHO ‘/home/seu-usuario-whoami/bin’ AO PATH DE USUÁRIO.
.
Acrescentando o novo valor à variável $PATH:
cd
whoami
PATH=$PATH:/home/seu-usuario-whoami/bin/
.
Para tornar o valor, que você quiser, permanente, faça o ajuste da variável dentro do arquivo ‘.profile’ ou ‘.bash_profile’
export PATH="$HOME/bin:$HOME/.local/bin:$PATH"
.
Exemplo:
cd
pwd
ls -a
echo 'PATH=$PATH:/home/seu-usuario-whoami/bin/' >> .profile
ls -a -t
.
PARA FUNCIONAR, ATUALIZE E REINICIE O SISTEMA. COMANDO PARA REBOOT:
sudo shutdown -r now
.
VERIFICANDO A NOVA VARIÁVEL:
echo $PATH
.
LINUX SHELL SCRIPT BRINCANDO COM 5 VARIÁVEIS:
#!/bin/bash
clear
# Este script testa o uso de variáveis
# Definindo 5 variáveis
echo ; echo 'Definindo 5 variáveis em 10 segundos.' ; sleep 3 ; echo
VALOR1='ls -t' ; sleep 2 ; VALOR2='pwd' ; sleep 2 ; VALOR3='cal' ; sleep 2 ; VALOR4='uptime' ; sleep 2 ; VALOR5='whoami' ; sleep 2
# Executando as 5 variáveis
echo 'Executando as 5 variáveis com explicações.' ; sleep 4 ; echo
echo 'Vamos listar o conteúdo desta pasta:' ; echo ; $VALOR1 ; sleep 4 ; echo ; echo 'Vamos saber onde estamos localizados no sistema:' ; sleep 4 ; echo ; $VALOR2 ; sleep 4 ; echo ; echo 'Vamos ver o calendário atual' ; sleep 4 ; echo ; $VALOR3 ; echo ; echo 'Vamos saber o tempo de funcionamento da máquina:' ; sleep 4 ; echo ; $VALOR4 ; sleep 4 ; echo ; echo 'Vamos saber qual é o usuário logado' ; sleep 4 ; echo ; $VALOR5 ; echo
sleep 5
echo 'Executando apenas as variáveis:' ; echo ; $VALOR1 ; sleep 2 ; $VALOR2 ; sleep 2 ; $VALOR3 ; sleep 2 ; $VALOR4 ; sleep 2 ; $VALOR5
# Removendo as 5 variáveis pois este script é apenas um teste
echo ; echo 'Removendo as 5 variáveis em 10 segundos, pois este script é apenas um teste' ; sleep 4 ; echo
unset VALOR1 ; sleep 2 ; unset VALOR2 ; sleep 2 ; unset VALOR3 ; sleep 2 ; unset VALOR4 ; sleep 2 ; unset VALOR5 ; sleep 2
echo ; echo '10 seg para testar as variáveis que não devem ecoar valores' ; sleep 4 ; echo
echo 'Testando as variáveis:' ; echo ; $VALOR1 ; sleep 2 ; $VALOR2 ; sleep 2 ; $VALOR3 ; sleep 2 ; $VALOR4 ; sleep 2 ; $VALOR5
exit
# Fim do script
.
LINUX SHELL SCRIPT - OlaUsuario.sh
.
#!/bin/bash
# Titulo: 01-olauser.sh
clear
USERL='Usuário-Linux'
echo
echo "Olá $USERL"
sleep 2
echo
echo "Tchau $USERL"
sleep 2
clear
exit
# Fim do script
.
Abra o terminal pelo menu do sistema. Abra o gerenciador de arquivos. Coloque os dois lado a lado na tela do computador. Execute o script acima copiando e colando no terminal o código abaixo que vai executar o script e depois vai apagar o script:
.
cd ; mkdir praticando-shellscript ; cd praticando-shellscript/ ; echo -e '#!/bin/bash\n \n# Titulo: 01-olauser.sh\n \nclear\n \nUSERL=Usuário-Linux\necho\necho Olá $USERL\n \nsleep 4\necho\necho Tchau $USERL\n \nsleep 4\necho\n \nsleep 2\nclear\n \nexit\n \n# Fim do script' > 01-olauser.sh ; chmod a+x 01-olauser.sh ; sh 01-olauser.sh ; sleep 2 ; cd .. ; unset USERL ; rm -rf praticando-shellscript/ ; echo ; pwd ; sleep 2 ; echo ; ls -t ; sleep 2 ; $USERL
.
LINUX SHELL SCRIPT IMPRIMIR SAÍDA COLORIDA:
.
Um script pode usar sequências de escape para produzir textos coloridos no terminal. As cores são representadas por códigos, temos 9 códigos:
reset = 0
black = 30
red = 31
green = 32
yellow = 33
blue = 34
magenta = 35
cyan = 36
white = 37
.
O caractere de escape para vermelho é: "\e[1;31m" após o texto em vermelho, usa "\e[0m" para resetar a cor voltando ao padrão. Substitua o código 31 por outra cor que desejar. Temos 9 códigos: 0, 30, 31, 32, 33, 34, 35, 36, 37.
.
Exemplo:
echo -e "\e[1;36m texto que vai ficar colorido \e[0m"
.
PARA IMPRIMIR UM TEXTO COLORIDO USE ESTES EXEMPLOS ABAIXO:
.
echo -e "\e[1;34m Este é o texto em azul! \e[0m"
echo -e "\e[1;30m Este é o texto em preto! \e[0m"
echo -e "\e[1;32m Este é o texto em verde! \e[0m"
echo -e "\e[1;33m Este é o texto em amarelo! \e[0m"
echo -e "\e[1;35m Este é o texto em magenta! \e[0m"
echo -e "\e[1;36m Este é o texto em cyan! \e[0m"
echo -e "\e[1;37m Este é o texto em branco! \e[0m"
.
PODEMOS IMPRIMIR TODOS ESTE TEXTOS AO MESMO TEMPO PARA TESTAR.
.
Copie o código que eu escrevi abaixo e cole no seu terminal:
.
echo -e "\e[1;34m Este é o texto em azul! \e[0m" ; sleep 3 ; echo -e "\e[1;30m Este é o texto em preto! \e[0m" ; sleep 3 ; echo -e "\e[1;32m Este é o texto em verde! \e[0m" ; sleep 3 ; echo -e "\e[1;33m Este é o texto em amarelo! \e[0m" ; sleep 3 ; echo -e "\e[1;35m Este é o texto em magenta! \e[0m" ; sleep 3 ; echo -e "\e[1;36m Este é o texto em cyan! \e[0m" ; sleep 3 ; echo -e "\e[1;37m Este é o texto em branco! \e[0m"
.
DÁ PARA CRIAR UM SHELL SCRIPT COM ISTO VEJA SÓ:
.
#!/bin/bash
clear
echo
echo -e "\e[1;34mVamos criar uma \e[1;31mpasta. \e[0m"
echo
sleep 4
mkdir pasta-teste
echo
echo -e "\e[1;30mVamos ver se a \e[1;31mpasta \e[1;30mfoi criada. \e[0m"
echo
sleep 4
ls -t
echo
sleep 3
echo -e "\e[1;32mVamos criar um \e[1;31marquivo de texto \e[1;32mvazio \e[0m"
echo
sleep 4
> texto-teste.txt ; echo ; ls -t ; echo ; sleep 5 ; echo
echo -e "\n\e[1;33mVamos \e[1;31mescrever \e[1;33me \e[1;35mmover \e[1;33mo \e[1;32mtexto-teste.txt \e[1;33mpara:\n \n\e[1;34mpasta-teste\n \e[0m"
echo
sleep 4
echo -e "Esta frase\nserá escrita\nem\ntexto-teste.txt" > texto-teste.txt ; sleep 3 ; mv texto-teste.txt pasta-teste
echo
echo -e "\n\e[1;35mEntrar em \e[1;32mpasta-teste \e[1;35me conferir o conteúdo dela \e[0m\n"
echo
cd pasta-teste/ ; echo ; ls -t ; sleep 4 ; echo ; pwd ; echo ; sleep 4
echo
echo -e "\e[1;36mCopiando \e[1;37mtexto-teste.txt \e[1;36mpara \e[1;34mtexto-teste2.txt \e[0m"
echo
sleep 4
cp texto-teste.txt texto-teste2.txt ; echo ; ls -t ; echo ; sleep 4 ; echo ; pwd ; echo ; sleep 4
echo -e "\e[1;37mFim do script. \e[1;31mPode apagar tudo \e[1;32musando o \e[1;37mmouse. \e[0m"
echo
sleep 4
echo -e "\e[1;37mOu pode executar o comando: \e[1;31mrm -rf pasta-teste\e[1;32m mas antes confere os arquivos de texto.\e[0m"
echo
sleep 4
exit
# Fim do script
.
COMANDOS MAIS USADOS EM SHELL SCRIPT NO LINUX
.
ASPAS SIMPLES ' E ASPAS DUPLAS ":
.
Aspas duplas permitem interpretar caracteres especiais.
Aspas simples desabilitam esta interpretação.
Ambas são úteis.
.
CARACTERES DE ESCAPE:
echo "Hello \"world\"!"
.
TODO SCRIPT ESCRITO PARA RODAR NO BASH COMEÇA COM:
#!/bin/bash
Após "#!/bin/bash" de um espaço entre linhas e então pode começar a digitar comandos.
.
Exemplo:
#!/bin/bash
clear
echo ; date ; echo ; sleep 4
echo ; cal ; echo ; sleep 4
echo ; uptime ; echo ; sleep 4
echo ; df -h ; echo ; sleep 4
echo ; free -html ; echo ; sleep 4
echo ; whoami ; echo ; sleep 4
echo ; pwd ; echo ; sleep 4
echo ; ls -at ; echo ; sleep 4
echo ; whereis bash ; echo ; sleep 4
echo ; echo 'Este é o fim do script 01-script.sh' ; echo ; sleep 4
exit
# Fim do script
.
ESTE SCRIPT ÚTIL E INOFENSIVO ACIMA SERÁ SALVO NA PASTA HOME, A PASTA DA CASINHA, USANDO UM EDITOR DE TEXTO E TERÁ O NOME DE:
01-script.sh
.
Posso melhorar/tornar mais amigável este script acima explicando sobre cada comando:
.
#!/bin/bash
clear
echo ; echo 'Hoje é data:' ; echo ; sleep 2
echo ; date ; echo ; sleep 4
echo ; echo 'Hoje pelo calendário é:' ; echo ; sleep 2
echo ; cal ; echo ; sleep 4
echo ; echo 'Esta máquina está funcionando a:' ; echo ; sleep 2
echo ; uptime ; echo ; sleep 4
echo ; echo 'Sobre o tamanho desta pasta:' ; echo ; sleep 2
echo ; df -h ; echo ; sleep 6
echo ; echo 'Sobre a memória RAM:' ; echo ; sleep 2
echo ; free -html ; echo ; sleep 6
echo ; echo 'Você está logado como:' ; echo ; sleep 2
echo ; whoami ; echo ; sleep 4
echo ; echo 'Você está em:' ; echo ; sleep 2
echo ; pwd ; echo ; sleep 4
echo ; echo 'Neste diretório/pasta tem:' ; echo ; sleep 2
echo ; ls -at ; echo ; sleep 6
echo ; echo 'O Bash está em:' ; echo ; sleep 2
echo ; whereis bash ; echo ; sleep 4
echo ; echo 'Este é o fim do script 01-script.sh' ; echo ; sleep 4
exit
# Fim do script
.
No Linux o script deve ter permissão de execução, isto pode ser feito abrindo o terminal pelo menu do sistema e executando o comando:
chmod +x 01-script.sh
.
Depois de salvo você tem que executar o arquivo, dessa forma:
./01-script.sh
.
Viu alguma utilidade neste pequeno script?
Então siga adiante.
.
IMPORTANTE:
Para estudar shell script tem que ser como usuário normal. Se você está acessando o sistema como usuário administrador (root), saia e entre como um usuário normal. É muito perigoso estudar shell usando o superusuário, você pode danificar o sistema com um comando errado.
Ok, continuemos.
.
Para exibir um manual do bash ou mesmo do comando 'chmod', digite na linha de comando:
man bash
man chmod
.
É possível executar o arquivo mesmo sem modificar a permissão de execução, por exemplo, se for um arquivo escrito para ser executado pelo bash, usar:
sh ./"Nome do arquivo, sem aspas"
.
SHELL
É importante saber o que é um Shell.
Na linha de comandos de um shell, podemos utilizar diversos comandos um após o outro, ou mesmo combiná-los numa mesma linha.
Se colocarmos diversas linhas de comandos em um arquivo texto simples, teremos em mãos um Shell Script, ou um script em shell, já que Script é uma descrição geral de qualquer programa escrito em linguagem interpretada, ou seja, não compilada.
Outros exemplos de linguagens para scripts são o PHP, Perl, Python, JavaScript e muitos outros. Podemos então ter um script em php, um script perl e assim em diante.
Uma vez criado, um ShellScript pode ser reutilizado quantas vezes for necessário.
Seu uso, portanto, é indicado na automação de tarefas que serão realizadas mais de uma vez.
Todo sistema Unix e similares são repletos de scripts em shell para a realização das mais diversas atividades administrativas e de manutenção do sistema.
Os arquivos de lote (batch - arquivos *.bat) do Windows são também exemplos de ShellScripts, já que são escritos em linguagem interpretada e executados por um Shell do Windows, em geral o command.com ou hoje em dia o cmd.exe.
Os Shells do Unix, porém, são inumeras vezes mais poderosos que o interpretador de comandos do Windows, podendo executar tarefas muito mais complexas e elaboradas.
.
OS SCRIPTS SHELL PODEM SER AGENDADOS PARA EXECUÇÃO ATRAVÉS DA TABELA CRONTAB, ENTRE OUTRAS COISAS.
.
O shell é uma ferramenta indispensável aos administradores de sistemas Unix.
O Shell mais comum e provavelmente o que possui mais scripts escritos para ele é também um dos mais antigos e simples, o sh.
Este shell está presente em todo o sistema tipo Unix, incluído o Linux, FreeBSD, AIX, HP-UX, OpenBSD, Solaris, NetBSD, Irix, etc. Por ser o shell nativo mais comum é natural que se prefira escrever scripts para ele, tornando o script mais facilmente portável para outro sistema.
Os Shells não estão diretamente associados a um ou outro tipo de Unix, embora várias empresas comerciais tenham suas próprias versões de Shell. No software livre o Shell utilizado em um sistema em geral é exatamente o mesmo utilizado em outro. Por exemplo, o bash encontrado no Linux é o mesmo shell bash encontrado no FreeBSD e pode também facilmente ser instalado no Solaris, Windows através do Cygwin [1] ou outros sistemas Unix comerciais para passar a ser utilizado como interface direta de comandos ou como interpretador de scripts. O mesmo acontece com o tcsh e vários outros shells desenvolvidos no modelo de software livre.
.
INTERAGIR COM O USUÁRIO
.
Para o script ficar mais completo, vamos colocar uma interação mínima com o usuário, pedindo uma confirmação antes de executar os comandos.
.
#!/bin/bash
clear
echo "Vou buscar os dados do sistema. Posso continuar? [S/n] "
read RESPOSTA
test "$RESPOSTA" = "n" && exit
echo ; echo "Data e Horário:" ; echo
date
echo
echo "Uso do disco:" ; echo
df -ht
echo
echo "Usuários conectados:" ; echo
w
echo ; echo "Seu nome de login é:"
whoami
echo
exit
# Fim do script
.
O comando "read" leu o que o usuário digitou e guardou na variável RESPOSTA. Logo em seguida, o comando "test" verificou se o conteúdo dessa variável era "n". Se afirmativo, o comando "exit" foi chamado e o script foi finalizado. Nessa linha há vários detalhes importantes:
O conteúdo da variável é acessado colocando-se um cifrão "$" na frente
O comando test é útil para fazer vários tipos de verificações em textos e arquivos
O operador lógico "&&", só executa o segundo comando caso o primeiro tenha sido OK. O operador inverso é o "||"
.
MELHORAR O CÓDIGO DO SCRIPT
Com o tempo, o script vai crescer, mais comandos vão ser adicionados e quanto maior, mais difícil encontrar o ponto certo onde fazer a alteração ou corrigir algum erro. Para poupar horas de estresse, e facilitar as manutenções futuras, é preciso deixar o código visualmente mais agradável e espaçado, e colocar comentários esclarecedores.
.
#!/bin/bash
# nome-do-script - script que mostra informações sobre o sistema
# Autor: Fulano da Silva
# Pede uma confirmação do usuário antes de executar
clear
echo "Vou buscar os dados do sistema. Posso continuar? [S/n]"
read RESPOSTA
# Se ele digitou 'n', vamos interromper o script
test "$RESPOSTA" = "n" && exit
# O date mostra a data e a hora correntes
sleep 3 ; echo "Data e Horário:" ; echo
date
sleep 3
echo
# O df mostra as partições e quanto cada uma ocupa no disco
echo "Uso do disco:"
sleep 3
echo
df
echo
sleep 6
# O w mostra os usuários que estão conectados nesta máquina
echo "Usuários conectados:"
sleep 3
echo
w
sleep 3
echo
# Fim do script
.
Basta iniciar a linha com um "#" e escrever o texto do comentário em seguida. Estas linhas são ignoradas pelo shell durante a execução. O cabeçalho com informações sobre o script e seu autor também é importante para ter-se uma visão geral do que o script faz, sem precisar decifrar seu código. Também é possível colocar comentários no meio da linha # como este
.
CARACTERÍSTICAS
.
OS SCRIPTS SHELL PODEM CONTER ESTRUTURAS DE PROGRAMAÇÃO TAIS COMO:
.
ESTRUTURAS DE DECISÃO (if)
Recurso utilizado para dar sequencia em fluxos de execução baseado decisões. Cuja sintaxe é:
- Condição Verificada é o teste que definirá se controle deve ser passado para dentro do bloco then, observe que esse teste é feito sobre a saída de um comando.
- Ação são comandos a serem executados em caso verdadeiro da condição verificada.
.
OPERADORES PARA NÚMEROS
.
-eq Verifica se é igual,
-ne Verifica se é diferente,
-lt Verifica se é menor,
-gt Verifica se é maior,
-le Verifica se é menor ou igual,
-ge Verifica se é maior ou igual.
.
OPERADORES PARA TEXTO
.
!= Verifica se é diferente,
= Verifica se é igual.
.
OPERADORES LÓGICOS
.
! Lógica NOT,
-o Lógica OU, (OR) ou ||,
-a Lógica E, (AND) ou &&.
.
OPERADOR PARA arquivos/
.
-d Verifica se é diretório,
-f Verifica se é arquivo,
-e Verifica se existe.
.
Ex:
# !/bin/bash
# Uso de Estrutura de Decisão
clear
echo 'opções'
echo '======'
echo ' -> Data do Sistema'
echo ' -> Uso do Sistema'
read opcao
if [ "$opcao" -eq 1 ]
then
echo 'Data do sistema: ' && date
elif [ "$opcao" -eq 2 ]
then
echo 'Uso do disco: ' && df -Th
fi
# Fim do script
.
ESTRUTURAS DE REPETIÇÃO (for) (while)
.
ESTRUTURA DE REPETIÇÃO for:
Permite que ações de iteração sejam executadas sobre determinados comandos ou variáveis até que a condição seja satisfeita.
.
# !/bin/bash
clear
echo "DIAS DA SEMANA"
for dia in seg ter qua qui sex sab dom
do
echo "$dia"
done
# Fim do script
.
ESTRUTURA DE REPETIÇÃO while:
Em situações onde sabemos até onde o loop irá realizar uma contagem o ideal é usar o for entretanto em cenarios onde a iteração deve cessar somente após se satisfazer uma condição o uso do laço while é mais indicado. Ex:
.
# /bin/bash
clear
var=1
while [ $var -le 7 ]
do
echo "Valor de var: $var"
var=$((var+1))
done
# Fim do script
.
UM USO INTERESSANTE DO WHILE PARA VER O LOOP FUNCIONANDO:
.
Por vezes queremos acompanhar a cópia de um arquivo na console do Linux e o caminho mais normal é abrir um outro terminal e ficar repetitivamente executando o comando ls, ou algum outro comando, haja dedo para apertar a seta pra cima e enter, seta pra cima e enter, seta pra cima e enter. Podemos resolver isto usando o comando while de forma bem simples, por exemplo se quisermos executar um ls por várias vezes, podemos fazer assim:
.
OBS: Execute um de cada vez, parar o comando com Ctrl+C.
.
1
while true; do ls; done;
2
while true; do ls; echo; sleep 5; done;
3
while true; do ls; echo; sleep 5; clear; done;
.
ISTO VAI EXECUTAR O COMANDO LS ATÉ PRESSIONARMOS CTRL + C PARA QUEBRÁ-LO.
.
FUNÇÕES E ARGUMENTOS
.
Ex:
.
# !/bin/bash
# REALIZAR BACKUP DO DIR
echo -e " \033[1;33m Digite o caminho de origem.: \033[0m "
read DIR_ORIGEM
clear
echo -e " \033[1;34m Digite o caminho de destino.: \033[0m "
read DIR_DESTINO
clear
verifica_argumentos(){
if [ $# -lt 1 ];
then
echo "Faltou informar um dos argumentos (parametros) necessarios!"
exit 1
fi
}
copia_arquivos(){
verifica_argumentos
clear
echo "Realizando backup..."
#Verificando se o dir de destino existe
if ! [ -d $DIR_DESTINO ]
then
mkdir $DIR_DESTINO
echo "Diretorio de Destino Criado"
fi
#COPIANDO ARQUIVOS
for arq in `ls $DIR_ORIGEM`
do
cp /$DIR_ORIGEM/$arq $DIR_DESTINO/$arq.bak
done
}
copia_arquivos
# Fim do script
.
DEFINIÇÕES DE VARIÁVEIS E ESCOPO DESTAS
.
Variáveis são definidas pela nomenclatura NOME_VARIAVEL="Valor da Variável". O valor pode ser tanto numérico quanto texto.
.
Nome="Joel"
.
Se quisermos acessá-la, basta fazer referência a ela com o caractere $ (cifrão) antes do nome: o comando echo $Nome, por exemplo, retornará a palavra "Joel".
.
Se quiser sabe informações sobre os sistemas de arquivo nos quais cada ARQUIVO reside ou, por padrão, sobre todos os sistemas de arquivos posso abrir um terminal e digitar:
VarInfo="df -h"
.
Depois digito no terminal "$VarInfo" sem aspas.
.
VARIÁVEIS DE AMBIENTE
.
As variáveis de ambiente independem da definição do usuario. Elas são criadas automaticamente, no momento em que se faz o login no sistema.
.
Ex:
PATH: define diretórios de procura por programas executados no shell;
USER: informa o nome do usuário do shell;
HOME: informa o caminho do diretório home do usuário;
PWD: diretório atual;
.
As variáveis são a base de qualquer script. É dentro delas que os dados obtidos durante a execução do script serão armazenados. Para definir uma variável, basta usar o sinal de igual "=" e para ver seu valor, usa-se o "echo":
.
Execute estes comandos abaixo no terminal:
.
VARIAVEL="um dois tres"
echo $VARIAVEL
echo $VARIAVEL $VARIAVEL
.
Para remover a variável acima:
unset VARIAVEL
.
Teste:
echo $VARIAVEL
.
É possível armazenar a saída de um comando dentro de uma variável. Ao invés de aspas, o comando deve ser colocado entre "$(...)", execute no terminal os comandos abaixo:
HOJE=$(date)
echo "Hoje é: $HOJE"
sleep 2
unset HOJE
echo $HOJE
HOJE=$(ls)
echo "O conteúdo desta pasta tem: $HOJE"
sleep 2
unset HOJE
echo $HOJE
HOJE=$(free -hmt)
echo "Informando sobre a memória desta máquina: $HOJE"
sleep 2
unset HOJE
echo $HOJE
.
EXEMPLOS DE USO DO SHELL SCRIPT:
.
Apagar arquivos velhos - Apagar periodicamente arquivos mais velhos que 30 dias do diretório /tmp:
.
#!/bin/bash
cd /tmp
find . -type f -mtime +30 -delete
# Fim do script
.
Este seria o conteúdo de um shell script que sempre que fosse executado apagaria arquivos com data de modificação maior que 30 dias a partir do diretório /tmp do sistema de arquivos.
.
Notem que ele é nada mais do que uma associação de 2 comandos (cd e find) em um arquivo para facilitar a repetição da tarefa. Este poderia ser, por exemplo, o conteúdo do arquivo /bin/limpatmp.sh e poderíamos chamar este script pela linha de comandos sempre que desejássemos repetir esta ação:
.
$ limpatmp.sh
.
Onde o símbolo "$" representa o prompt de comandos. Do ponto de vista do usuário este seria mais um comando disponível para uso.
.
Os scripts em shell são também muito empregados junto à inicialização do sistema (para auto-iniciar tarefas) ou como mini-aplicativos, que facilitam tarefas dos usuários, tais como montagem de dispositivos, menus de ajuda, etc.
.
Sua primeira linha obrigatoriamente começa com um "#!" (que não se deve confundir com um comentário qualquer, pois realmente é uma exceção; este par se chama, em inglês, de shebang), informando diretamente ao núcleo (kernel) qual interpretador ele deverá usar, juntamente com seu caminho, de acordo com a necessidade de cada caso. Exemplo:
#!/bin/bash
.
Em seguida, são adicionados os comandos desejados, um por linha, ou separados por ponto e vírgula. Exemplo:
.
mount -t reiserfs /dev/hda1 /mnt/hda1
ls /mnt/hda1
cp -r /mnt/hda1/* /home/user/backup
umount /dev/hda1
.
Por fim, dá-se a permissão de execução a este arquivo de texto simples ("chmod +x arquivo").
.
DATA ANTERIOR
.
#!/bin/bash
# Função em Bash para retornar a data anterior, levando em conta o mês e ano.
fn_data_anterior()
{
DIA=$D
MES=$M
ANO=$A
# Dado DIA, MES e ANO numéricos, obtém a data do dia anterior
DIA=`expr $DIA - 1`
if [ $DIA -eq 0 ]; then
MES=`expr $MES - 1`
if [ $MES -eq 0 ]; then
MES=12
ANO=`expr $ANO - 1`
fi
DIA=`cal $MES $ANO`
DIA=`echo $DIA | awk '{ print $NF }'`
fi
}
ano=`date +%Y`;
mes=`date +%m`;
let dia=10\#`date +%d`;
if (( $dia<10 ));
then
j=0$dia;
else
j=$dia;
fi
dia=$j;
j="";
D=$dia
M=$mes
A=$ano
fn_data_anterior
echo $DIA $MES
# Fim do script
.
DETALHES SOBRE OS COMANDOS
.
Diferente de outras linguagens de programação, o shell não usa os parênteses para separar o comando de seus argumentos, usa sim o espaço em branco. O formato de um comando é sempre:
.
COMANDO + OPÇÕES + PARÂMETROS
.
O "read" é um comando do próprio shell, já o "date"" é um executável do sistema.
.
Dentro de um script, não faz diferença usar um ou outro, pois o shell sabe como executar ambos. Assim, toda a gama de comandos disponíveis no GNU/Linux pode ser usada em scripts.
Há vários comandos que foram feitos para serem usados com o shell, eles são ferramentas.
.
VEJAMOS ALGUNS DELES:
.
O comando "cat" mostra o conteúdo de um arquivo. O comando "cat -n sistema" mostra o nosso script, com as linhas numeradas. O "-n" é a opção para o comando, que o instrui a numerar linhas, e "sistema" é o último argumento, o nome do arquivo.
cat (Mostra arquivo)
cat -n, cat -s (comando com opções)
.
cut (Extrai campo)
cut -d -f (comando com opções)
cut -c (comando com opções)
.
date Mostra data as opções são: -d, +'...'
.
find Encontra arquivos, as opções são: -name, -iname, -type f, -exec
.
grep Encontra texto, as opções são: -i, -v, -r, -qs, -w -x
.
head Mostra Início, as opções são: -n, -c
.
printf Mostra texto as opções são: nenhuma
.
rev Inverte texto, as opções são: nenhuma
.
sed Edita texto, as opções são: -n, s/isso/aquilo/, d
.
seq Conta Números, as opções são: -s, -f
.
sort Ordena texto, as opções são: -n, -f, -r, -k -t, -o
.
tail Mostra Final, as opções são: -n, -c, -f
.
tr Transforma texto, as opções são: -d, -s, A-Z a-z
.
uniq Remove duplicatas, opções: -i, -d, -u
.
wc Conta Letras, opções: -c, -w, -l, -L
.
Use "man nome-do-comando" ou "nome-do-comando --help" para obter mais informações sobre cada um deles.
.
O melhor, é que em shell é possível combinar comandos, aplicando-os em seqüência, para formar um comando completo. Usando o pipe "|" é possível canalizar a saída de um comando diretamente para a entrada de outro, fazendo uma cadeia de comandos.
.
Exemplo:
.
prompt$ cat /etc/passwd | grep root | cut -c1-10
root:x:0:0
prompt$
.
O cat mostra o arquivo todo, o grep pega essa saída e extrai apenas as linhas que contêm a palavra "root" e o cut por sua vez, somente nessas linhas que o grep achou, extrai os 10 primeiros caracteres. Isso funciona como uma estação de tratamento de água, onde ela entra suja, vai passando por vários filtros que vão tirando as impurezas e sai limpa no final. E por fim, também é possível redirecionar a saída de um comando para um arquivo ao invés da tela, usando o operador ">". Para guardar a saída do comando anterior no arquivo "saida", basta fazer:
cat /etc/passwd | grep root | cut -c1-10 > saida
cat saida
.
O COMANDO TEST
O canivete suíço dos comandos do shell é o "test", que consegue fazer vários tipos de testes em números, textos e arquivos. Ele possui várias opções para indicar que tipo de teste será feito, algumas delas:
-lt Núm. é menor que (LessThan)
-d É um diretório
-gt Núm. é maior que (GreaterThan)
-f É um arquivo normal
-le Núm. é menor igual (LessEqual)
-r O arquivo tem permissão de leitura
-ge Núm. é maior igual (GreaterEqual)
-s O tamanho do arquivo é maior que zero
-eq Núm. é igual (EQual)
-w O arquivo tem permissão de escrita
-ne Núm. é diferente (NotEqual)
-nt O arquivo é mais recente (NewerThan)
= String é igual
-ot O arquivo é mais antigo (OlderThan)
!= String é diferente
-ef O arquivo é o mesmo (EqualFile)
-n String é não nula
-a E lógico (AND)
-z String é nula
-o OU lógico (OR)
.
SCRIPT QUE TESTA ARQUIVOS
Tente fazer um script "testa-arquivos", que pede ao usuário para digitar um arquivo e testa se este arquivo existe. Se sim, diz se é um arquivo ou um diretório.
.
CONCEITOS AVANÇADOS:
.
CASE
.
O case é para controle de fluxo, tal como é o if. Mas enquanto o if testa expressões não exatas, o case vai agir de acordo com os resultados exatos. Vejamos um exemplo:
.
case $1 in
parametro1) comando1 ; comando2 ;;
parametro2) comando3 ; comando4 ;;
*) echo "Você tem de entrar com um parâmetro válido" ;;
esac
.
Aqui aconteceu o seguinte: o case leu a variável $1 (que é o primeiro parâmetro passado para o programa), e comparou com valores exatos. Se a variável $1 for igual à “parametro1″, então o programa executará o comando1 e o comando2; se for igual à “parametro2″, executará o comando3 e o comando4, e assim em diante. A última opção (*), é uma opção padrão do case, ou seja, se o parâmetro passado não for igual a nenhuma das outras opções anteriores, esse comando será executado automaticamente. Com o case fica muito mais fácil criar uma espécie de “menu” para o shell script do que com o if.
.
If, for e while
.
Assim como qualquer outra linguagem de programação, o shell também tem estruturas para se fazer condicionais e loop. As mais usadas são if, for e while.
.
ATÉ ESTE PONTO EM QUE ESTAMOS, JÁ SABEMOS O BÁSICO, O NECESSÁRIO PARA SE FAZER UM SCRIPT DE FUNCIONALIDADE MÍNIMA. E ESTE MÍNIMO PODE FAZER COISAS INCRÍVEIS.
.
AVANÇAR:
case, if, for e while.
.
Comando if:
.
Comando if - else:
if ( condição ) {
comandos a serem executados se a condição for verdadeira;
}
else {
comandos a serem executados se a condição for falsa;
}
.
Controle de fluxo são comandos que vão testando algumas alternativas, e de acordo com essas alternativas, vão executando comandos. Um dos comandos de controle de fluxo mais usados é certamente o if, que é baseado na lógica “se acontecer isso, irei fazer isso, se não, irei fazer aquilo”.
.
Exemplo de um pedaço de código:
.
if [ -e $linux ]
then
echo 'A variável $linux existe.'
else
echo 'A variável $linux não existe.'
fi
.
O que este pedaço de código faz? O if testa a seguinte expressão: Se a variável $linux existir, então (then) ele diz que que existe com o echo, se não (else), ele diz que não existe. O operador "-e" é pré-definido, e você pode encontrar a listagem dos operadores na tabela:
.
-eq Igual
-ne Diferente
-gt Maior
-lt Menor
-o Ou
-d Se for um diretório
-e Se existir
-z Se estiver vazio
-f Se conter texto
-o Se o usuário for o dono
-r Se o arquivo pode ser lido
-w Se o arquivo pode ser alterado
-x Se o arquivo pode ser executado
.
Exemplo de uso do if:
.
if [COMANDOS]
then
comandos
else
comandos
fi
# Fim do script
.
Ex:
for VAR in LISTA
do
comandos
done
# Fim do script
.
Ex:
while COMANDO
do
comandos
done
# Fim do script
.
Diferente de outras linguagens, o if testa um comando e não uma condição. Porém como já conhecemos qual o comando do shell que testa condições, é só usá-lo em conjunto com o if. Por exemplo, para saber se uma variável é maior ou menor do que 10 e mostrar uma mensagem na tela informando:
.
Ex:
if test "$VARIAVEL" -gt 10
then
echo "é maior que 10"
else
echo "é menor que 10"
fi
# Fim do script
.
Há um atalho para o test , que é o comando [. Ambos são exatamente o mesmo comando, porém usar o [ deixa o if mais parecido com o formato tradicional de outras linguagens:
.
Ex:
if [ "$VARIAVEL" -gt 10 ]
then
echo "é maior que 10"
else
echo "é menor que 10"
fi
# Fim do script
.
Se usar o [, também é preciso fechá-lo com o ], e sempre devem ter espaços ao redor. É recomendado evitar esta sintaxe para diminuir suas chances de erro.
.
Já o while é um laço que é executado enquanto um comando retorna OK. Novamente o test é bom de ser usado. Por exemplo, para segurar o processamento do script enquanto um arquivo de lock não é removido:
.
Ex:
while test -f /tmp/lock
do
echo "Script travado..."
sleep 1
done
# Fim do script
.
E por fim, o for percorre uma lista de palavras, pegando uma por vez:
.
Ex:
for numero in um dois três quatro cinco
do
echo "Contando: $numero"
done
# Fim do script
.
Uma ferramenta muito útil para usar com o for é o seq, que gera uma seqüência numérica.
.
Para fazer o loop andar 10 passos, pode-se fazer:
for passo in $(seq 10)
.
O mesmo pode ser feito com o while, usando um contador:
.
i=0
while test $i -le 10
do
i=$((i+1))
echo "Contando: $i"
done
# Fim do script
.
Linux usando o "while" para Loops
.
Como podemos usar o loop while em um shell script?
.
O while funciona assim:
.
while [ condição ]
do
commandos
done
.
No exemplo acima saiba que o início e o final do loop é definido por "do" e "done". Estes dois são palavras chaves do Bash.
.
Exemplo 1 - O loop vai funcionar 5 vezes e imprimir o texto definido dentro do loop.
.
n=1 # Esta é a variável n é igual a um
.
Nome do script: 01-while1.sh
.
#!/bin/bash
n=1
while [ $n -le 5 ]
do
echo "Este é o loop $n"
(( n++ ))
done
# Fim do script
.
Pode abrir o terminal pelo menu do sistema e digitar: nano 01-while1.sh
.
O nano é um editor de texto que funciona na janela do terminal e você pode digitar normalmente nele.
.
Pode também copiar e colar.
.
Depois de colar o script, aperte as teclas Ctrl+O, aperte a tecla Enter e depois a tecla Ctrl+X.
.
Damos poder de execução ao script:
chmod a+x 01-while1.sh
.
Executamos:
./01-while1.sh
.
Ou podemos fazer tudo isto pelo terminal assim:
cd ; mkdir pasta-while-loop ; cd pasta-while-loop/ ; echo -e '#!/bin/bash\necho\n \nn=1\n \nwhile [ $n -le 5 ]\ndo\necho "Este é o loop $n"\n(( n++ ))\ndone\necho' > 01-while1.sh ; chmod a+x 01-while1.sh ; ./01-while1.sh
.
Exemplo:
.
~ $cd ; mkdir pasta-while-loop ; cd pasta-while-loop/ ; echo -e '#!/bin/bash\n \nn=1\n \nwhile [ $n -le 5 ]\ndo\necho "Este é o loop $n"\n(( n++ ))\ndone' > 01-while1.sh ; chmod a+x 01-while1.sh ; ./01-while1.sh
Este é o loop 1
Este é o loop 2
Este é o loop 3
Este é o loop 4
Este é o loop 5
pasta-while-loop $
.
CRIE SEU PRÓPRIO EPUB USANDO O PROGRAMA SIGIL
.
LINUX COMANDOS DE MANIPULAÇÃO DE ARQUIVOS PARA USAR EM SHELL SCRIPT
.
Crie uma pasta, abra o terminal nesta tua pasta criada e execute:
.
ls -t -a -h -l
pwd
cd ..
ls -a
pwd
cd -
ls -t
pwd
touch nome-do-arquivo-a-ser-criado1.txt nome2.txt
ls -t
cat nome2.txt
echo 'Olá Mundo!' > nome2.txt
cat nome2.txt
ls ; echo ; echo "E ..." ; sleep 4 ; echo ; ls -t
clear
mkdir pasta-teste
ls -a
ls -t ; echo
rmdir pasta-teste
ls -t ; pwd
mkdir -p pasta-mama/pasta-filha
ls -t ; echo
> nome-do-arquivo-a-ser-criado3.txt ; > nome4.txt
ls -at ; echo
pwd
cp nome2.txt nome3.txt
ls -t ; echo
mv nome2.txt nome1.txt
ls -t
find -name nome2.txt
find -name nome3.txt
find -name nome1.txt
mv nome1.txt pasta-mama/
find -name nome1.txt
find -name nome3.txt
rm nome3.txt
find -name nome3.txt
ls -t
pwd
find nome-do-arquivo-a-ser-criado3.txt
rm nome-do-arquivo-a-ser-criado3.txt
ls -t
rm nome4.txt nome-do-arquivo-a-ser-criado1.txt
ls -t ; echo
clear
ls
cd pasta-mama/
cd ..
pwd
ls
cd -
ls ; echo
echo -e 'Este texto\n \né do arquivo\n \nnome1.txt\n' >> nome1.txt
cat nome1.txt
ls
mv nome1.txt pasta-filha/
ls ; echo
mkdir pasta-bro
ls
cd pasta-filha/
> texto-filha.txt
ls -t
echo -e "\n \nEste texto\n \nEstá escrito em\n \ntexto-filha.txt!" > texto-filha.txt
cat texto-filha.txt
echo -e "\n \nEste texto\n \nSobreescreve\n \ntexto-filha.txt!" > texto-filha.txt
cat texto-filha.txt
echo -e "\n \nEste texto\n \nSerá adicionado a\n \ntexto-filha.txt\n" >> texto-filha.txt
cat texto-filha.txt
ls -t
cat nome1.txt
cp nome1.txt nome8.txt
clear
ls -t
cat nome8.txt
cd ..
ls
rm -rf pasta-filha/
ls
rmdir pasta-bro/
ls
cd ..
pwd
ls
rmdir pasta-mama/
ls
.
Criação/backup de/em links com ln:
ln -s
ln -b
ln -i
.
COMANDOS DE COMPACTAÇÃO / DESCOMPACTAÇÃO
.
TAR
Armazena ou extrai arquivos e diretórios dentro de um único arquivo ou dispositivo.
.
Sintaxe: tar [opções] arquivos_ou_diretórios
Opções:
-c :: cria um novo arquivo .tar e adiciona a ele os arquivos especificados
-x :: retira os arquivos agrupados no arquivo .tar
-f :: indica que o destino é um arquivo em disco e não uma fita magnética
-v :: exibe o nome de cada arquivo processado
-Z :: compacta ou descompacta arquivos utilizando o comando compress
-z :: compacta ou descompacta arquivos utilizando o comando gzip
-j :: compacta ou descompacta arquivos utilizando o comando bzip2
-M :: múltiplos volumes
-b n :: define o tamanho do bloco de dados utilizado pelo tar (n*512 bytes)
.
Exemplos:
1. Gera um arquivo de backup do diretório "documentos1":
tar -cvf documentos.tar documentos1
2. Exibe o conteúdo do arquivo "documentos.tar":
tar -tvf documentos.tar
3. Extrai o conteúdo do arquivo "documentos.tar":
tar -xvf documentos.tar
5. Gera um arquivo de backup compactado com bzip2 do diretório "documentos1":
tar -cvjf memorandos.tar.bz2 documentos1
6. Divide em vários disquetes o arquivo "documentos.tar.bz2":
tar -cvMf /dev/fd0 /operftp/documentos.tar.bz2
7. Extrai o arquivo de backup armazenado no disquete:
tar -xvMf /dev/fd0
.
CPIO
Executa funções de arquivamento de dados.
.
Sintaxe: cpio [opções]
Opções:
-o :: lê nomes de arquivos da entrada padrão e os copia para a saída padrão com a informação necessária para a sua recuperação posterior com o comando: cpio -i
-i :: lê da entrada padrão um arquivo criado pelo comando cpio -o e extrai os arquivos armazenados
-v :: exibe o nome de cada arquivo processado
.
Exemplos:
1. Copia todos os arquivos mencionados em "lista.txt" para o arquivo "backup.cpio":
cpio -o /operftp/lista.txt > /operftp/backup.cpio
2. Extrai todos os arquivos armazenados em "backup.cpio":
cpio -i procedimento.zip
.
COMPRESS
Compacta um ou mais arquivos utilizando a compactação Lempel-Ziv.
Sintaxe: compress [opções] arquivos
Opções:
-c :: grava o arquivo compactado na saída padrão e retém o arquivo original
-d :: descompacta o arquivo
-r :: compacta recursivamente arquivos em todos os subdiretórios
Exemplos:
compress documentos.tar
$ compress -d documentos.tar.Z
.
UNCOMPRESS
Descompacta um ou mais arquivos que tenham sido compactados com o comando compress.
Sintaxe: uncompress [opções] arquivos
Opções:
-c :: grava o resultado na saída padrão e retém o original
-r :: descompacta recursivamente arquivos em todos os subdiretórios
Exemplo:
uncompress documentos.tar.Z
.
GZIP
Compacta um ou mais arquivos.
Sintaxe: gzip [opções] arquivos
Opções:
-c :: grava o arquivo compactado na saída padrão e retém o arquivo original
-d :: descompacta arquivo. O mesmo que gunzip
-f :: sobrescreve arquivos já existentes
-h :: mensagem de ajuda
-l :: lista o conteúdo de um arquivo compactado
-t :: testa a integridade do arquivo compactado
-n :: não salva o nome original
-r :: compacta recursivamente arquivos em todos os subdiretórios
-L :: exibe a licença do comando
Exemplos:
gzip documentos.tar
$ gzip -d documentos.tar.gz
.
GUNZIP
Descompacta arquivos compactados pelos comandos gzip e compress. Utiliza as mesmas opções de gzip.
Sintaxe: gunzip [opções] arquivos
Exemplo:
gunzip documentos.tar.gz
.
BZIP2
Compacta um ou mais arquivos.
Sintaxe: bzip2 [opções] arquivos
Opções:
-z :: força a compressão
-c :: grava na saída padrão
-t :: testa a integridade do arquivo compactado
-f :: sobrescreve arquivos já existentes
-d :: descompacta arquivos. O mesmo que bunzip2
-k :: não apaga os arquivos de entrada
-L :: licença do comando
Exemplos:
bzip2 documentos.tar
$ bzip2 -d documentos.tar.bz2
.
BUNZIP2
Descompacta arquivos compactados pelos comandos gzip ou compress. Utiliza as mesmas opções de bzip2.
Sintaxe: bunzip2 [opções] arquivos
Exemplo:
bunzip2 documentos.tar.bz2
.
ZIP
Compacta um ou mais arquivos.
Sintaxe: zip [opções] arquivo-destino arquivo-origem
Opções:
-e :: permite encriptar o conteúdo de um arquivo ZIP através de senha. A senha será pedida no momento da compactação
-m :: apaga os arquivos originais após a compactação
-r :: compacta recursivamente arquivos em todos os subdiretórios
Exemplos:
zip documentos.zip *.txt
$ zip -r documentos.zip /usr/*.txt
.
UNZIP
Descompacta arquivos compactados pelo comando zip.
Sintaxe: unzip [opções] arquivo.zip arquivos-origem [diretório]
Opções:
-l :: exibe os arquivos existentes dentro do arquivo ZIP
-d :: diretório onde os arquivos serão descompactados
-o :: substitui arquivos existentes sem perguntar
Exemplos:
unzip documentos.zip
$ unzip documentos.zip -d /operftp
.
ZCAT, ZMORE, ZLESS, BZ2CAT
Visualiza o conteúdo de um arquivo texto compactado, sem precisar descompactar o arquivo.
Os comandos zcat, zless e zmore funcionam da mesma forma que cat, less e more. A única diferença, é que esses comandos podem ler diretamente arquivos compactados com gzip ou compress sem precisar descompactar os arquivos.
.
Exemplos:
.
zcat nome_arquivo
zless nome_arquivo
zmore nome_arquivo
bz2cat nome_arquivo
.
Paro por aqui. É bastante informação. É um bom começo. Até Breve!
.
semanickz 