Maringá/PR

Apostila Shell Script

2012
 Introdução

Hi,
Se você está començando a ler esta apostila é porque já conhece um pouco sobre o Shell,
não é? ou pelo menos tem ideia do que é. Por esse motivo não irei aprofundar tanto neste
assunto e iremos direto ao “x” da questão. Porém para conseguirmos absorver todos os
tópicos que serão apresentados aqui vamos explicar alguns e passar exemplos modelos.
Good Luck.

Autor: Carlos Demetrio.

Começando...

...nunca li nenhuma apostila que começa com um código na primeira página. Porém vou
colocar na minha. Não se assuste, fiz isso para você perceber se ler ela será realmente útil!

Consegue entender esse código a seguir fácilmente?

#!/bin/bash
#Introdução ao Shell-Script
#Autor: Carlos Demetrio
#Data : 19/03/2012

######################################################
DATA=`date +%d/%m/%Y`
######################################################

menu()
{
reset
echo "Olá, $USER."
echo "Hoje é: $DATA"

echo -n "Digite o seu sistema operacional favorito. Ex.: linux: "

read SO
if [ $SO = "linux" ]
then
clear
echo "Você é o cara!!"
exit 0
elif [ $SO = "windows" ]
then
clear
echo "Você é fraco!!"
exit 0
elif [ -z $SO ]
then
clear
echo "Digite algo..."
sleep 2
menu
else
clear
echo "Use linux que você será melhor!"
exit 0
fi
}

menu;
eai...

Conseguiu?
Se achou muito fácil... esquece esta apostila não foi feita para você!
Caso entendeu pouca coisa ou não entendeu nada vá em frente então, pois no final da 10
página já será capaz de fazer um código melhor que esse. :)

Dica: Não fique copiando e colando os códigos encontrados para ver o que ele faz. Tente
ler ele antes e escrever ele novamente para entender na prática. Isso ajuda muito!!

→ Usaremos como padrão aqui o shell → bash

→ Se imprimir essa apostila use esse espaço em branco para colocar sua criatividade em
ação, fazendo anotações ou simplesmente riscar o papel. Lembre-se:
“Um desenho vale mais que mil palavras.” Apesar de não usar nenhuma figura aqui. :(

→ Meu e-mail é chds_@[Link], anote ele para me enviar e-mail com dúvidas ou
sugestões. Responderei o mais breve possível prometo. Gosto muito deste relacionamento :)
O que é shell?

Shell, é ele que interpreta a linha de comandos digitada pelo usuário no terminal e chama os
programas desejados. Além disso o shell também tem seus próprios comandos como IF,
CASE, FOR, WHILE, ETC. Isso que iremos aprender aqui!

Para ver como o shell faz parte do seu sistema Linux use o seguinte comando:
file /usr/bin/* | grep shell
Viu? ;)

Entendendo de verdade...

Quem usa Linux conhece bem o prompt de comando. O que muita gente não sabe é que o
bash têm uma “poderosa” linguagem de script embutido nela mesma. Diversas pessoas
utilizam-se desta linguagem para facilitar a realização de inúmeras tarefas administrativas no
Linux, ou até mesmo criar seus próprios programas. Patrick Volkerding, criador da
distribuição Slackware, utiliza esta linguagem para toda a instalação e configuração de sua
distribuição. Você poderá criar scripts para automatizar as suas tarefas diárias de um
servidor, para efetuar backup automático regularmente, procurar palavras em textos, criar
formatações, e muito mais.

Interpretadores de comandos são programas feitos para intermediar o usuário e seu sistema.
Através destes interpretadores, o usuário manda um comando, e o interpretador o executa
no sistema. Eles são o “Shell” do sistema Linux.

Uma das vantagens destes shell scripts é que eles não precisam ser compilados, ou seja,
basta apenas criar um arquivo texto qualquer, e inserir comandos à ele. Para dar à este
arquivo a definição de “shell script”, teremos que incluir uma linha no começo do arquivo
(#!/bin/bash) e torná-lo “executável”, utilizando o comando chmod +x. Vamos seguir com
um pequeno exemplo de um shell script que mostre na tela: “Yes! Vou aprender shell script”:

#!/bin/bash
clear
echo "Yes! Vou aprender shell script"

Explicando o código:
1ª linha: indica que os comandos serão interpretados pelo shell -> bash
2ª linha: com o comando clear, limpa a tela
3ª linha: exibe uma mensagem através do comando echo

Para executar um script escrito você deve dar permissão de execução no arquivo. Por
exemplo, vamos imaginar que esse script tenha sido gravado em um arquivo chamado
primeiro. Então usamos o comando:
chmod +x primeiro
e depois para executar o arquivo (o script):
./primeiro

Fácil né? Agora que já entendeu, vamos para a melhor parte. ;)

 Váriaveis

Entendendo variável:

Variável é um conjunto de caracteres que armazenam dados. O bash reconhece uma

variável quando ela começa com $, ou seja, a diferença entre “VARIAVEL” e “$VARIAVEL” é
que a primeira é uma palavra qualquer, e a outra é uma variável. Para definir uma variável,
utilizamos a seguinte sintaxe:

VARIAVEL="valor"
O “valor” será atribuído a VARIAVEL. Para mostrar o valor pode usar: echo $VARIAVEL

Valor pode ser uma frase, números, outras variáveis ou comandos. O valor pode ser
expressado entre as aspas (“”), apóstrofos (”) ou crases (“). As aspas vão interpretar as
variáveis que estiverem dentro do contexto, os apóstrofos retornar à variável o valor
literalmente sem interpretar nada e as crases irão interpretar um comando e retornar a sua
saída para a variável.

Vejamos exemplos:

$ VARIAVEL="Eu estou logado no bash como usuário: $USER"

$ echo $VARIAVEL
Eu estou logado no bash como usuário: demetrio

$ VARIAVEL='Eu estou logado no bash como usuário $USER'

$ echo $VARIAVEL
Eu estou logado no bash como usuário $USER

$ VARIAVEL="Meu diretório atual é o `pwd`"

$ echo $VARIAVEL
Meu diretório atual é o /home/demetrio

Entendeu? Caso não, leia novamente pois as váriaveis são fundamentais!

Se você quiser criar um script em que o usuário deve interagir com ele, é possível que você
deseje que o próprio usuário defina o valor a uma variável, e para isso usamos o comando
read, que dará uma pausa no script e ficarará esperando o usuário digitar algum valor e tecle
ENTER. Exemplo:

#!/bin/bash
clear
echo "Entre com o valor para a variável: "
read VARIAVEL
echo "O valor digital é: '$VARIAVEL'”
O valor digital é 'valor digitado'
Explicando o código:
1ª linha: indica que os comandos serão interpretados pelo shell -> bash
**Atenção apartir de agora essa linha não será mais comentada**
2ª linha: limpa a tela do terminal com o comando clear
3ª linha: comando echo exibe a mensagem no terminal solicitando o digitar...
4ª linha: o comando read espera o usuário que executou o script digitar alguma
coisa e apertar a tecla ENTER
5ª linha: exibe na tela do terminal o que foi digitado/ armazenado na VARIAVEL

Dica: Caso não entendeu faça o teste real. Lembrando, tente não copiar(CTRL + C)! ;)

→ [1] Ler o "man bash" em inglês, inteiro, é algo memorável que só se faz uma vez na vida...
(Aurelio Marinho Jargas)
 IF

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, senão,
irei fazer aquilo”.
Vamos dar um exemplo:
if [ -e $OLDPWD ]
then
echo 'A variável $OLDPWD existe.'
else
echo 'A variável $OLDPWD não existe.'
fi

Entendendo o código rapidamente: o if verifica se a váriavel OLDPWD existe(-e), caso exista

executa (then) → echo 'A variável $OLDPWD existe.', senão(else) → echo 'A variável
$OLDPWD não existe.' e fecha o bloco com o fi.

Lista de operadores que podem ser usados:

-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

Existem inúmeros comandos no Linux, e para explicar todos teríamos de publicar um livro e
não fazer uma simples apostila. Também existem outras formas de aprender os comandos,
em relação a estrutura também é usada em todas as programações. Primeiro de tudo você
pode dar uma olhada na manpage do bash(comando man bash, lembra da frase anterior do
Aurelio?), que disponibilizará os comandos embutidos no interpretador de comandos. Uma
das coisas essencias para o aprendizado é sair coletando exemplos de outros scripts e ir
estudando-os minuciosamente. Procure sempre comandos e expressões novos em outros
scripts e em manpages dos comandos. E por último, mas não o menos importante, praticar
bastante! :)
Enfim seja criativo e crie seus próprios scripts que facilite de uma vez só sua vida no Linux.
 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 $X 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 $X (que é o primeiro parâmetro passado
para o programa), e comparou com valores exatos. Se a variável $X 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.

Veja o mesmo exemplo com if:

if [ -z $X ]
then
echo "Você tem de entrar com um parâmetro válido"
elif [ $X = "parametro1" ]
then
comando1
comando2
elif [ $X = "parametro2" ]
then
comando3
comando4
else
echo "Você tem de entrar com um parâmetro válido"
fi

Obs.: Quando precisar testar mais de uma condição no if, usa o comando elif(else+if).

Dica: As vezes é melhor usar o case do que o if. ;)

 FOR

O laço for vai substituindo uma variável por um valor, e vai executando os comandos
pedidos. Veja um exemplo:
for X in *
do
cp $X $[Link]
mv $[Link] /mnt/backup
done

Primeiramente o laço for atribuiu o valor de retorno do comando “*”(que é equivalente a um

ls sem nenhum parâmetro) para a variável $X, depois executou o bloco de comandos. Em
seguida ele atribui outro valor do comando “*” para a variável $X e reexecutou os comandos.
Isso se repete até que não sobrem valores de retorno para o “*”. Outro exemplo:

for ORIGINAL in *
do
RESULTADO=`echo $ORIGINAL |
tr 'A-Z] [a-z]`
if [ ! -e $RESULTADO ]
then
mv $ORIGINAL $RESULTADO
fi
done

Aqui, o que ocorre é a transformação de letras maiúsculas para minúsculas. Para cada
arquivo que o laço lê, uma variável chamada $RESULTADO irá conter o arquivo em letras
minúsculas. Para transformar em letras minúsculas, usei o comando tr. Caso não exista um
arquivo igual e com letras minúsculas, o arquivo é renomeado para o valor da variável
$RESULTADO, de mesmo nome, mas com letras minúsculas.
Como os exemplos ilustram, o laço for pode ser bem útil no tratamento de múltiplos arquivos.
Você pode deixá-los todos com letras minúsculas ou maiúsculas sem precisar renomear
cada um manualmente, pode organizar dados, fazer backup, entre outras coisas. Think!
 WHILE

O while testa continuamente uma expressão, até que ela se torne falsa.
Exemplo:
VARIAVEL="valor"
while [ $VARIAVEL = "valor" ]
do
comando1
comando2
done

O que acontece aqui é o seguinte: Enquanto a “$VARIAVEL” for igual a “valor”, o while ficará
executando os comandos 1 e 2, até que a “$VARIAVEL” não seja mais igual a “valor”. Se no
bloco dos comandos a “$VARIAVEL” mudasse, o while iria parar de executar os comandos
quando chegasse em done, pois agora a expressão $VARIAVEL = “valor” não seria mais
verdadeira.

UNTIL
O until tem as mesmas características do while, mas a única diferença é que ele faz o
contrário. Veja o exemplo abaixo:
VARIAVEL="naovalor"
until [ $VARIAVEL = "valor" ]
do
comando1
comando2
done

Ao invés de executar o bloco de comandos (comando1 e comando2) até que a expressão se

torne falsa, o until testa a expressão e executa o bloco de comandos até que a expressão se
torne verdadeira. No exemplo, o bloco de comandos será executado desde que a expressão
$VARIAVEL = “valor” não seja verdadeira. Se no bloco de comandos a variável for definida
como “valor”, o until para de executar os comandos quando chega ao done.
Vejamos um exemplo para o until que, sintaticamente invertido, serve para o while também:
VAR=1
CONT=0
until [ $VAR = "0" ]
do
comando1
comando2
if [ $CONT = 9 ]
then
VAR=0
fi
CONT=$((CONT + 1))
done
Entendendo:

Primeiro, atribuímos ou declaramos à variável “$VAR” o valor “1″. A variável “$CONT” será
uma contagem para quantas vezes quisermos executar o bloco de comandos. O until
executa os comandos 1 e 2, enquanto a variável “$VAR” for igual a “0″. Então usamos um if
para atribuir o valor 0 para a variável “$VAR”, se a variável “$CONT” for igual a 9. Se a
variável “$CONT” não for igual a 0, soma-se 1 a ela. Isso cria um laço que executa o
comando 10 vezes, porque cada vez que o comando do bloco de comandos é executado,
soma-se 1 à variável “$CONT”, e quando chega em 9, a variável “$VAR” é igualada a zero,
quebrando assim o laço until.

→ O que achou até agora? Está fácil? Se quiser pare de ler, volte ou continue(fortes)...

Alguns comandos para ajudar:

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
reset Limpa todo o terminal ativo
date Mostra a hora do sistema. Pesquisar suas variáveis.
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

Variáveis especiais
$0 Nome do script que está sendo executado
$1-$9 Parâmetros passados à linha de comando
$# Número de parâmetros passados
$* ou $@ Mostra todos os parâmetros passados
$? Valor de retorno do último comando ou de todo o shell script. ( true = 0 and false = 1)

Dica: Você também encontra muitas variáveis, já predefinidas, na página de manual do bash
(comando “man bash”, seção Shell Variables). ;)
 Funções

Funções são blocos de comandos que podem ser definidos para uso posterior em qualquer
parte do código. Praticamente todas as linguagens usam funções que ajudam a organizar o
código. Vejamos a sintaxe de uma função:
funcao()
{
comando1
comando2
...
}

Fácil de entender, não? A função funcionará como um simples comando próprio. Você
executa a função em qualquer lugar do script shell, e os comandos 1, 2 e outros serão
executados. A flexibilidade das funções permite facilitar a vida do programador.

Exemplo Final:
#!/bin/bash
# Exemplo Final de Script Shell

principal() {
clear
echo "Exemplo Final sobre o uso de scripts shell"
echo "------------------------------------------"
echo "Opções:"
echo
echo "1. Trasformar nomes de arquivos"
echo "2. Fazer backup dos arquivos do /usr/bin"
echo "3. Sair"
echo
echo -n "Qual a opção desejada? "
read OPCAO
case $OPCAO in
1)
transformar
;;
2)
backup
;;
3)
exit
;;
*)
"Opção inválida"
principal
;;
esac}
transformar() {
clear
echo -n "Para Maiúsculo ou minúsculo? [M/m] "
read VAR
if [ $VAR = "M" ]
then
echo -n "Que diretório? "
read DIR
for X in `/bin/ls` $DIR
do
Y=`echo $X | tr 'A-Z] [a-z]`
if [ ! -e $Y ]
then
mv $X $Y
fi
done
elif [ $VAR = "m" ]
then
echo -n "Que diretório? "
read DIR
for X in `/bin/ls` $DIR
do
Y=` echo $X | tr 'A-Z] [a-z]`
if [ ! -e $Y ]
then
mv $X $Y
fi
done
else
clear
echo “Opção inválida”
transformar
fi
}
backup() {
clear
for X in `/bin/ls` /usr/bin
do
mkdir /usr/bin/backup
cp -R /usr/$X /usr/$[Link]
mv /usr/bin/$[Link] /usr/bin/backup
done
}

principal;
 Finalizando o mini curso

Pronto!

Agora é a hora de colocar tudo em prática e ver se realmente aprendeu. Faça os exercícios e
envie para mim para serem corrigidos, no meu e-mail (chds_@[Link]), se quiser fazer
perguntas também é possível. É só escrever ou enviar o *.txt. ;)

Alguns exigirão pesquisa e necessitarão de algumas ferramentas que foram apenas

citadas, mas não aprendidas. O shelleiro também tem que aprender a se virar sozinho! (A)

Exercícios propostos:
1) Faça um script que recebe dois números como parâmetro e mostra a relação entre eles.
Exemplo:
prompt$ ./relacao 3 5
3 é menor que 5
prompt$ ./relacao 5 3
5 é maior que 3
prompt$ ./relacao 5 5
5 é igual a 5
prompt$

2) Faça um script que recebe um número como parâmetro e o diminui até chegar a zero,
mostrando na tela cada passo, em uma mesma linha. Exemplo:
prompt$ ./zerador 5
543210
prompt$ ./zerador 10
10 9 8 7 6 5 4 3 2 1 0
prompt$

Desafio final:
3) O script deve mostra na tela todos os parâmetros recebidos na linha de comando,
contando-os. Exemplo:
prompt$ ./parametros a b c d e f
Parâmetro 1: a
Parâmetro 2: b
Parâmetro 3: c
Parâmetro 4: d
Parâmetro 5: e
Parâmetro 6: f
prompt$

Dica: Use o for. :)

Good luck again!

 Conclusão

Espero realmente que tenha aprendido as estruturas do shell-script e sua aplicação no

universo UNIX. Sendo assim passo a última e mais importante de todas dicas:
“Nunca pare de estudar”. ;)
Espero seu sucesso!!!!!!! Da mesma forma que busco o meu.
Fontes: [Link]
[Link]