.
Comandos mais usados em Shell Script no Linux
.
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.
.
COLOQUE A CHAMADA DO SHELL NA PRIMEIRA LINHA
A primeira linha do script deve ser:
#!/bin/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 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. 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:
echo
ls
echo ''
echo ""
echo "Olá!"
printf 'Bem vindo ao bash!' (Aperte a tecla enter e digite: ls)
echo '#!/bin/bash'
echo "#!/bin/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 -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
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
.
Muito bom que você digitou um comando de cada vez!!!
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 ":
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
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 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:
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.
É 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/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. Ex:
# /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
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"
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". 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.
.
Ex:
if COMANDO
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
.
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
.
.
🙂
.
= 2, executar (x) = 1, então se quiser que um arquivo tenha permissão apenas de leitura o valor a ser usado é 4, para apenas escrever o valor é 2 e para executar o valor será 1, um arquivo pode ter todos eles o 4 o 2 e o 1 o primeiro é o dono depois grupo de usuários e por fim world
semanickz 