Comandos Linux Revisao
---
O que é um sistema operacional? Sempre que você liga o computador, você vê uma tela na qual pode realizar atividades diferentes, como escrever, navegar na Internet ou assistir a um vídeo ele está lá.
O que faz o hardware do computador funcionar assim?
Como o processador do seu computador sabe que você está solicitando a execução de um arquivo mp3?
Bem, é o SISTEMA OPERACIONAL ou o KERNEL que faz esse trabalho. Um kernel é um programa no cerne, na base ou no coração de qualquer sistema operacional que cuida de coisas fundamentais, como permitir que o hardware se comunique com o software. Portanto, para trabalhar no seu computador, você precisa de um sistema operacional (SO). Na verdade, você está usando um enquanto lê isso no seu computador. Agora, você pode ter usado sistemas operacionais populares como Windows, Apple OS X, mas aqui aprenderemos o que é o Linux e quais benefícios ele oferece sobre outras opções de sistemas operacionais. Os benefícios do uso do Linux? O Linux agora desfruta de popularidade em seu auge, e é famoso entre programadores e usuários regulares de computadores em todo o mundo. Seus principais benefícios são:
Oferece um sistema operacional gratuito. Você não precisa desembolsar centenas de dólares para obter o sistema operacional como o Windows!
Sendo de código aberto, qualquer pessoa com conhecimento de programação pode modificá-lo. Os sistemas operacionais Linux agora oferecem milhões de programas/aplicativos para escolher, a maioria deles grátis! Depois de instalar o Linux, você não precisa mais de um antivírus! O Linux é um sistema altamente seguro. Mais ainda, há uma comunidade global de desenvolvimento constantemente procurando maneiras de melhorar sua segurança. A cada atualização, o sistema operacional se torna mais seguro e robusto. O Linux é o sistema operacional preferido para ambientes de servidor devido à sua estabilidade e confiabilidade (megaempresas como Amazon, Facebook e Google usam Linux para seus servidores). Um servidor baseado em Linux pode funcionar sem parar sem reinicializar por anos a fio.
---
A principal vantagem do Linux era que os programadores podiam usar o Linux Kernel para projetar seus próprios sistemas operacionais personalizados. Com o tempo, uma nova gama de sistemas operacionais amigáveis inundou o mundo dos computadores. Agora, o Linux é um dos mais populares e amplamente utilizados Kernel, e é a espinha dorsal de sistemas operacionais populares como Debian, Knoppix, Ubuntu, Solus, Deepin, Mx-Linux e Fedora. No entanto, a lista não termina aqui, pois EXISTEM MILHARES DE SISTEMAS OPERACIONAIS BASEADOS EM LINUX que oferecem uma variedade de funções aos usuários. O Linux Kernel é normalmente usado na combinação do projeto GNU do Dr. Richard Stallman.
TODAS AS DISTRIBUIÇÕES MORDERNAS DO LINUX SÃO NA VERDADE DISTRIBUIÇÕES DO LINUX/GNU.
---
Por que aprender interface de linha de comando? Embora o mundo esteja migrando para sistemas baseados em GUI, a CLI tem seus usos específicos e é amplamente usada em scripts e administração de servidores. Vejamos alguns usos convincentes. Comparativamente, os comandos oferecem mais opções e são flexíveis. Tubulação e stdin/stdout são imensamente poderosos não estão disponíveis na GUI. Algumas configurações na GUI têm até 5 telas de profundidade, enquanto em uma CLI é apenas um único comando. Mover, renomear milhares de arquivos na GUI consumirá muito tempo (usar Control/Shift para selecionar vários arquivos), enquanto estiver na CLI, usar expressões regulares para executar a mesma tarefa com um único comando. A CLI carrega rapidamente e não consome.
---
O grande atrativo do terminal é que, com exceção de alguns poucos aplicativos específicos, os comandos são sempre os mesmos. Isso faz com que ele seja um porto seguro, com o qual você pode contar, sem importar se você está no Ubuntu ou no Slackware. O terminal é também a forma mais natural de "conversar" com o sistema, sempre que você precisa de qualquer coisa fora do comum.
Comandos básicos do Linux/Unix - o gerenciamento de arquivos se torna fácil se você souber os comandos certos. Às vezes, os comandos também são chamados de "programas", pois sempre que você executa um comando, é o código do programa correspondente, escrito para o comando, que está sendo executado. Por exemplo, imagine que você precisa mover todos os arquivos com extensão .jpg de uma pasta com muitos arquivos para outra. Em vez de precisar mover um por um, ou fazer algum malabarismo com a ordem de exibição dos arquivos (para organizar a exibição com base na extensão dos arquivos e poder assim selecionar todos os .jpg com o mouse), você poderia simplesmente abrir o terminal e digitar:
mv *.jpg /outra-pasta
Além dos comandos básicos, dois outros recursos que tornam o terminal tão poderoso são a possibilidade de combinar diferentes comandos para executar tarefas mais complexas (ou filtrar os resultados para localizar informações específicas) e a possibilidade de escrever pequenos programas em shell script.
---
Comandos mais usados para um usuário linux tem a ver com arquivos e sua manipulação. Tudo começa com coisas simples muito importantes. Quais são elas? Se mover pelos diretórios, mover arquivos de um diretório para outro, copiar, recortar, colar, renomear, baixar, converter e sobrescrever. Para isto em grande escala ou em um único arquivo, o terminal do Linux é bastante útil.
1- pwd Diz onde está na árvore de diretórios.
2- cd Permite se mover pelos diretórios, cd .., cd -, cd ~/caminho/para/diretório. cd /usr/local/bin, cd 'dir com espaço'.
3- ls Lista o que existe no diretório, ls -t, ls -lah, ls -R
4- mv Move de um diretório a outro ou renomeia arquivos. Opções: -i, -u, -v
5- cp Copia arquivo, cp -r Copia diretório, cp arquivo_antigo novo_nome_arquivo Renomeia um arquivo substituindo nome antigo por um novo nome. Opções: -i, -n, -u, -R, -v
6- rm -f Remove arquivos, rm -r Remove diretório.
7- rmdir Remove diretório vazio. Opções: -p, -pv (Remove todos os pais e subdiretórios junto com o detalhado).
8- mkdir -p Cria diretórios e subdiretórios. mkdir –p nome_dir/{sub1,sub2,sub3}
9- date Data atual
10- cat Imprime conteúdo de arquivo na tela. cat ~/Documentos/texto_teste.txt. Opções: -b, -n, -s, -E
11- df -h Mostra tamanho, espaço usado e espaço disponível
12- exit Sai do teminal
13- find Encontra arquivos que existem mas não lembra onde os colocou. find . -name *nomedoarquivo* , find . -type f -name *nomedoarquivo*
12- finger
13- free -h
14- grep Este comando é usado para procurar uma sequência/palavra específica em um arquivo de texto. É semelhante a "Ctrl + F", mas executado via CLI. Opções: -i, -n, -v, -c
15- egrep (grep -E)
16- head
17- tail
20- history
21- kill
22- less
23- man
24- clear Limpa a tela do terminal
25- sort Este comando classifica os resultados de uma pesquisa alfabética ou numericamente. Arquivos, conteúdo e diretórios podem ser classificados usando este comando. Opções: -r, -f, -n.
26- tar Compacta arquivos em formato .tar. Exemplo: tar -cvf nome_do_arquivo_tar diretório_a_ser_compactado
27- touch Cria arquivo, modifica horário de acesso a arquivo. Comando: touch texto_teste.txt Cria arquivo chamado: texto_teste.txt
---
Existem muitos outros comandos, saber sobre eles depende quais o usuário necessita usar diariamente.
---
Comandos mais usados em Shell Script no Linux? São muitos e podem ser combinados de diversas maneiras. Um usuário que escreve scripts em sua casa necessita saber quais comandos para evoluir em seus estudos rotineiros?
Qual é o seu usuário? Se você não tem certeza qual é o seu usuário, use o comando "whoami" sem aspas, para saber. 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.
---
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
---
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.
---
Os shell scripts mais comuns são invólucros simples em torno dos binários de terceiros ou do sistema. Um wrapper (invólucro, embrulho) nada mais é do que um script de shell, uma função de shell ou um alias que inclui um comando ou utilitário do sistema.
---
COLOQUE A CHAMADA DO SHELL NA PRIMEIRA LINHA. A primeira linha do script deve ser:
#!/usr/bin/env bash
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):
chmod +x nome-do-teu-shellscript.sh
---
Para permitir que todos os usuários possam executar o script:
chmod +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. 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 arquivos, fazer backups, adicionar informações, remover informações, etc.
---
AGORA ABRE O TERMINAL E DIGITA COMANDOS, POR EXEMPLO, DIGITE ESTES COMANDOS ABAIXO UM DE CADA VEZ (cada linha é um comando):
echo
ls
echo 'ls é Listar arquivos'
echo ''
echo ""
echo "Olá!"
printf 'Bem vindo ao bash!' (Aperte a tecla enter e digite: ls)
echo '#!/bin/bash'
echo "#!/usr/bin/env bash"
echo ; echo "Olá!" ; echo
echo -e 'Bom\nDia\nMundo!'
echo "Hello world!"
echo "Hello "world"!"
echo "Hello \"world\"!"
printf "Hello world" (Aperte a tecla enter e digite: cd ~)
pwd
ls -t
sleep 7
echo ; echo 'Olá!' ; sleep 3 ; ls -t
free -h -t
free -th
sleep 4
date
cal
du -h
uptime
df -h
clear
free -tmlh
df -a -h
df -k -l
df -T -m
echo ; whoami ; echo
ls ; echo ; pwd ; echo
echo ; ls -at ; echo
du *
ls -lah
du -hcs
du -sch
du -ach
du -Sh
du -Sk
clear
echo ; echo 'df: Relata o espaço de disco usado pelo sistema (Usado e Livre)' ; echo
ls -hat
echo ; echo "du: Relata o espaço utilizado no disco de tal arquivo ou diretório" ; echo
whereis bash
VALOR="Linux"
echo $VALOR
echo $VALOR $VALOR
VALOR='ls -t'
$VALOR
touch Meu_Arquivo.txt
ls -t
ls -t | head
pwd
rm -f Meu_Arquivo.txt
ls -t
echo 'Cadê Meu_Arquivo.txt?'
echo $VALOR
VALOR='free -h -t'
$VALOR
echo $VALOR
echo VALOR
read VALOR (aperte a tecla enter, digite: "ls" sem aspas e aperte enter.)
$VALOR
read VALOR (aperte a tecla enter, digite: "uptime" sem aspas e aperte enter.)
$VALOR
echo ; $VALOR ; echo ; $VALOR ; echo
echo ; $VALOR ; sleep 4 ; echo ; $VALOR ; echo
unset VALOR
echo ; $VALOR
$VALOR
clear
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"
unset HOJE
echo $HOJE
echo $((2*3))
echo $((2*4-2/2+3))
VALOR=44
echo $((VALOR*1))
echo $((VALOR*2))
echo $((VALOR*3))
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=$(uname -a)
echo $VALOR
HOJE=$(arch)
echo $HOJE
echo "Informação sobre o kernel: $VALOR" ; echo ; echo "Informação sobre a arquitetura do sistema: $HOJE"
echo 'Informação sobre o kernel: $VALOR' ; echo ; echo 'Informação sobre a arquitetura do sistema: $HOJE'
unset VALOR
unset HOJE
echo "Informação sobre o kernel: $VALOR" ; echo ; echo "Informação sobre a arquitetura do sistema: $HOJE"
echo 'Informação sobre o kernel: $VALOR' ; echo ; echo 'Informação sobre a arquitetura do sistema: $HOJE'
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
clear
exit
---
O 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 os 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.
---
ASPAS SIMPLES ' E ASPAS DUPLAS " (as duas são úteis em determinadas circunstâncias). ASPAS DUPLAS permitem interpretar caracteres especiais. ASPAS SIMPLES desabilitam esta interpretação.
---
CARACTERES DE ESCAPE:
echo "Hello \"world\"!"
---
TODO SCRIPT ESCRITO PARA RODAR NO BASH COMEÇA COM:
#!/bin/bash OU #!/usr/bin/env bash
Após "#!/bin/bash" de um espaço entre linhas e então pode começar a digitar comandos.
---
Exemplo:
#!usr/bin/env bash
# Este é um comentário!
# Em bash shell scripts não recomendam usar
# ponto e vírgula para separar comandos.
# Mas acontece dos primeiros scripts serem assim.
# Sem variáveis, sem declarações ou comparações; apenas comandos.
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 INOFENSIVO ACIMA SERÁ SALVO NA PASTA HOME, A PASTA DA CASINHA, USANDO UM EDITOR DE TEXTO COM 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:
1) bash meu_script.sh
2) sh 'nome_do_arquivo_sem_aspas'
3) ./'nome_do_arquivo_sem_aspas'
---
SHELL - É importante saber o que é Shell? O shell do Linux é o Bash. A shebang do shell script é #!/usr/bin/env bash. Os comandos do Linux são executados no Bash. Na linha de comandos de um shell, podemos utilizar diversos comandos um após o outro, ou mesmo combiná-los numa mesma linha embora isto não seja o mais recomendado. 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/Linux 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.
É 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.
---
#!/usr/bin/env bash
#################
# isto é um comentário
# comentários são ignorados pelo script
# servem para ajudar e informar o programador
#################
# limpa a tela
clear
# imprime pergunta na tela
echo "Vou buscar os dados do sistema. Posso continuar? [S/n] "
# armazena resposta
read RESPOSTA
# testa a resposta e executa
test "$RESPOSTA" = "n" && exit
# imprime informação na tela
echo ; echo "Data e Horário:" ; echo
# comando mostra data
date
# espaço entre linhas
echo
# imprime informação na tela
echo "Uso do disco:"
# espaço entre linhas
echo
# comando informa uso de espaço em disco
df -ht
# espaço entre linhas
echo
# imprime informação na tela
echo "Usuários conectados:"
# espaço entre linhas
echo
# comando w
w
# espaço entre linhas
echo
# imprime informação na tela
echo "Seu nome de login é:"
# comando whoami
whoami
# espaço entre linhas
echo
# comando para sair
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:
1) O conteúdo da variável é acessado colocando-se um cifrão "$" na frente
2) O comando test é útil para fazer vários tipos de verificações em textos e arquivos
3) 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
---
Para fazer uma pergunta direta (que é o formato mais simples), usamos o comando "read ", que lê uma resposta e a armazena em uma variável. Quase sempre ele é usado em conjunto com o "echo", que permite escrever texto na tela, fazendo a pergunta, como em:
#!/usr/bin/env bash
echo "Digite a URL do arquivo a baixar"
read arquivo
wget -c $arquivo
# fim do script
---
Com estes três comandos, criamos um gerenciador de downloads primitivo, que pede a URL do arquivo (que você poderia colar no terminal usando o botão central do mouse) e faz o download usando o wget, que é um gerenciador em modo texto, muito usado em scripts. A URL digitada é armazenada na variável "arquivo", que pode ser usada ao longo do script. Ao usá-la, é necessário incluir um "$", que faz com que o shell entenda que se trata da variável "arquivo" e não de um trecho de texto qualquer. Quando o script fosse executado, o "wget -c $arquivo" seria transformado em algo como: "wget -c http://gdhpress.com.br/arquivo.zip", iniciando o download. O "-c" é uma opção para o wget, que faz com que ele continue o download caso interrompido. Se você pressionasse "Ctrl+C" durante o download para encerrar o script e o executasse novamente, fornecendo a mesma URL, ele continuaria o download de onde parou.
---
USAR O COMANDO/PROGRAMA DIALOG NOS BASH SHELL SCRIPTS:
O dialog é muito fácil de usar. Se você tem o teclado à mão, aqui está um exemplo de uma linha de uma caixa de mensagem que você pode tentar.
Cole este exemplo no terminal:
dialog --title 'Message' --msgbox 'Olá, Mundo!' 5 20
Depois tecle Enter, digite: clear e tecle Enter. Este exemplo cria uma caixa de mensagem com o título "Mensagem", contendo a saudação "Olá, mundo!". A caixa tem 5 linhas de altura e 20 caracteres de largura, com a mensagem bem centralizada na caixa. Um botão "OK" aparece na parte inferior; pressionar dispensa o menu. Tipos de caixas de diálogo - a maioria das chamadas para caixas de diálogo tem um formato semelhante: um título opcional, o tipo de caixa de diálogo, o texto a ser exibido e a altura e largura (em caracteres) da caixa de diálogo. Seguem parâmetros adicionais específicos para cada tipo de menu. Vamos dar uma breve olhada em cada um dos tipos disponíveis. O menu "yesno" é muito semelhante ao nosso primeiro exemplo:
dialog --title "Message" --yesno "Você está se\ divertindo?" 6 25
Escolha sim ou não. Depois tecle Enter, digite: clear e tecle Enter. Se você tentar este exemplo, verá que agora existem dois botões na parte inferior, rotulados como "Sim" e "Não". Você pode selecionar entre os botões usando as teclas do cursor (ou ) e fazer sua seleção pressionando . O status de saída retornado ao shell será 0 se "Sim" for escolhido e 1 se uma seleção "Não" for feita. Você pode tentar experimentar os parâmetros de altura e largura. Se a largura for menor que o comprimento da string, ela será quebrada (nos limites da palavra). Se você tornar a caixa de diálogo muito pequena, os caracteres serão perdidos. Anteriormente, vimos a caixa de mensagem. A "caixa de informações" é semelhante, exceto pelo fato de não esperar o usuário selecionar um botão "OK". Isso é útil para exibir uma mensagem enquanto uma operação está em andamento. Aqui está um exemplo:
dialog --infobox "Favor esperar" 10 30 ; sleep 4
A "caixa de entrada" permite que um usuário insira uma string. As teclas de edição habituais podem ser usadas e o campo de texto rola, se necessário. Depois que o usuário digita os dados, eles são gravados no erro padrão (ou mais comumente redirecionados para um arquivo como neste exemplo):
dialog --inputbox "Digite seu nick:" 8 40 2>answer
dialog --inputbox "Digite seu nome:" 10 40 2>nome.txt (Joga a resposta para um arquivo chamado nome.txt)
---
Dialog exemplo de mensagem:
dialog --title Information[!] --msgbox "Esta é uma menssagem informativa." 10 50
---
Dialog tem certeza que...
dialog --title "Confirmation" --yesno "Deletar mesmo este arquivo?" 10 40
---
Pega um nome de arquivo como parâmetro:
dialog --textbox /etc/profile 22 70
---
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:
#!/usr/bin/env bash
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 # Fechamento do if
---
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".
---
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.
---
Exemplo:
# !/bin/baxh
# 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. Exemplo:
# /bin/bash
clear
var=1
while [ $var -le 7 ]
do
echo "Valor de var: $var"
var=$((var+1))
done
# fim do script
---
FUNÇÕES E ARGUMENTOS
---
Uma prática um pouco mais avançada é o uso de funções. Elas permitem que você crie blocos de código destinados a executarem tarefas específicas que podem ser usados ao longo do script. Em outras palavras, as funções são pequenos scripts dentro do script. A grande vantagem de criar funções (em vez de simplesmente repetir os comandos quando precisar) é que, ao atualizar o script, você precisa alterar apenas um bloco de comandos, em vez de precisar procurar e alterar os comandos manuais em vários pontos do script. Por permitirem reaproveitar o código, as funções fazem com que o script seja mais organizado e fique com menos linhas, o que facilita muito a manutenção em scripts complexos.
---
msgerro()
{
echo "Algo deu errado durante a conexão. O erro foi:"
echo "$msg"
}
---
Veja que a função começa com uma declaração ("msgerro()"), onde você especifica um nome e adiciona o "()", que faz com que o sistema entenda que se trata de uma função e não de um outro bloco de comandos qualquer. Os comandos são, em seguida, colocados dentro de um par de chaves ( { .... } ), que indicam o início e o final. A partir daí, você pode executar os comandos dentro do script chamando o nome da função (msgerro), como se fosse um comando qualquer.
---
Ex:
#!/usr/bin/env bash
###############
# REALIZAR BACKUP DO DIR
###############
echo -e " \033[1;33m Digite o caminho de origem.: \033[0m "
read DIR_ORIGEM
clear
# -------------------------- # Este é um comentário que serve pra organizar
echo -e " \033[1;34m Digite o caminho de destino.: \033[0m "
read DIR_DESTINO
clear
verifica_argumentos(){ # O nome da função é: verifica_argumentos
if [ $# -lt 1 ];
then
echo "Faltou informar um dos argumentos (parametros) necessarios!"
exit 1
fi
}
# -------------------------- #
copia_arquivos(){ # O nome da função é: 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 # Chama a função pelo nome dela
# 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"
unset HOJE
echo $HOJE
HOJE=$(ls)
echo "O conteúdo desta pasta tem: $HOJE"
unset HOJE
echo $HOJE
HOJE=$(free -hmt)
echo "Informando sobre a memória desta máquina: $HOJE"
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 (imprime texto)
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 MAIS AVANÇADOS
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. Então daqui por diante, 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.
---
Base para escrever shell script com if, them, else e fi:
if COMANDO
then
comandos
else
comandos
fi
# fim do script
---
RODO ESTE SIMPLES SCRIPT QUE ESCREVI:
#!/usr/bin/env bash
# nome: if_then_else_fi_scr_contg.sh
contagem=1
if [ $contagem -eq 1 ]
then
echo
echo '*** Listando ***'
echo
ls -t | head
echo
echo '*** Onde estamos ***'
echo
pwd
echo
else
echo '*** Contagem não é 1 ***'
fi
---
Ex:
for VAR in LISTA
do
comandos
done
# fim do script
---
#!/usr/bin/env bash
# nome: exemplo_loop_for_test.sh
for f in .; do
echo '*** Listando ***'
ls -t | head
echo '*** Data atual ***'
date
done
# fim do script
---
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
---
Ex:
E por fim, o for percorre uma lista de palavras, pegando uma por vez:
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
---
Até Breve
:)
---
semanickz 