Você está na página 1de 26

Algoritmos em Shell Script

Autor: Wagner Souza <wagopc at gmail.com>


Data: 20/06/2014

Introduo / O Shell Script


Introduo
O estudo de algoritmos, de fundamental importncia para o desenvolvimento da lgica de programao e,
consequentemente, o aprendizado e domnio de uma linguagem de programao.
Um algoritmo uma sequncia finita de instrues bem definidas e no ambguas, ou seja, um conjunto de
instrues executadas passo a passo, necessrios para executar uma tarefa.
Outra definio muito interessante de algoritmo:
"Um algoritmo tem por objetivo, representar mais fielmente o raciocnio envolvido na lgica de
programao e, desta forma, permitir-nos abstrair de uma srie de detalhes computacionais, que podem ser
acrescentados mais tarde." [1]
Utiliza-se algoritmos para resolver problemas reais de forma abstrata com o auxlio de uma linguagem de
programao ou at mesmo por fluxogramas, que so grficos que demonstram a sequncia operacional do
desenvolvimento de um processo.
Este processo pode ser a troca de uma lmpada, calcular a mdia aritmtica de alunos, o espao percorrido
por um carro, entre outros.
A figura 1, mostra um exemplo de um algoritmo representado por um fluxograma:

O Shell Script
O shell, nada mais , do que um mediador entre o usurio e o kernel do sistema operacional. Este, interpreta
a entrada de comandos por meio da linguagem bash, tambm conhecido como shell. O bash (Bourne Again
Shell), o shell mais utilizado em modo texto em sistemas GNU/Linux.
Shell Script utilizado para combinar vrios comandos em um nico arquivo, onde este dever ter permisso
de execuo. Estes scripts so frequentemente usado como ferramenta de configurao e instalao em
sistemas operacionais.
Possui caractersticas de linguagens de programao, como:
Estrutura de deciso;
Estrutura de repetio;

Funes e argumentos;

Definies de variveis.

Abaixo, uma lista com os principais shells utilizados em ambientes Unix e Unix Like[1]:
Bourne Shell (sh): Desenvolvido por Stephen Bourne do Bell Labs (da AT&T, onde tambm foi
desenvolvido o Unix), foi durante muitos anos o shell padro do sistema operacional Unix. tambm
chamado de Standard Shell por ter sido durante vrios anos o nico, e at hoje o mais utilizado. Foi
portado para praticamente todos os ambientes Unix e distribuies GNU/Linux.

Korn Shell (ksh): Desenvolvido por David Korn, tambm do Bell Labs, um superconjunto do sh,
isto , possui todas as facilidades do sh e a elas agregou muitas outras. A compatibilidade total com o
sh vem trazendo muitos usurios e programadores de shell para este ambiente.

Boune Again Shell (bash): Desenvolvido inicialmente por Brian Fox e Chet Ramey, este o shell do
projeto GNU. O nmero de seus adeptos o que mais cresce em todo o mundo, seja porque ele o
Shell padro do Linux, seja por sua grande diversidade de comandos, que incorpora inclusive
diversos comandos caractersticos do C Shell.

C Shell (csh): Desenvolvido por Bill Joy, da Universidade de Berkley, o shell mais utilizado em
ambientes BSD. Foi ele quem introduziu o histrico de comandos. A estruturao de seus comandos
bem similar da Linguagem C. Seu grande pecado, foi ignorar a compatibilidade com o sh,
partindo por um caminho prprio.

Variveis / Operadores
Variveis
Em lgica de programao, variveis so espaos reservados na memria para armazenar um dado a ser
utilizado em uma operao aritmtica, lgica e em atribuies de valores.
O valor da varivel pode mudar de acordo com o andamento do algoritmo como, por exemplo, no clculo de
um mdia anual para alunos de uma escola. Cada aluno ter suas notas, onde estas sero calculadas para a
obteno da mdia.
Algumas variveis pode ter um valor fixo como a frmula para o clculo do raio de uma circunferncia,
onde Pi tem um valor aproximado de 3,1416... Aqui, Pi sempre ter este mesmo valor.
Antes de comear a criar variveis, importante seguir algumas dicas para nome-las:
1. Nome de variveis no podem ser iguais a palavras reservadas, nem tampouco conter caracteres especiais
(* & # @);
Exemplo: if, while, for.
2. No inicie variveis com nmeros e sempre atribua nomes que facilite o trabalho futuro. No atribua
nomes a variveis como a, b, c... Se o desenvolvedor do cdigo no tiver o costume de comentar o seu
cdigo, esse tipo de nome no ajudar em nada a lembrar a utilidade da varivel;
3. Cuidado com nomes muito extensos. Via de regra, o tamanho do nome de uma varivel no deve
ultrapassar 127 caracteres;
3

4. No pode conter espaos em branco;


5. Padronize no quesito de letras maisculas ou minsculas. Sempre procuro por nomes com letra em
minsculo.
Em shell, diferente de outras linguagens de programao, no faz-se necessrio indicar o tipo da varivel.
No preciso informar se a varivel ser um nmero inteiro, real, caractere (string) ou lgico.
Exemplo de programa em C:
#include <stdio.h>
void main()
{
int contador;
float PrecoDoQuilo;
double TaxaDeCambio;
char LetraDigitada;
int IdadeManoel, IdadeJoao, IdadeMaria;
double TaxaDoDolar,
TaxaDoMarco,
TaxaDoPeso,
TaxaDoFranco;
.......
}
Exemplo de um Shell Script:
#!bin/bash
var="teste"
num=3
echo "$var $num"
Perceba que a varivel var reconhecida pelo shell atravs do caractere $. Entre o nome de uma varivel e o
sinal de atribuio (=), no podem haver espaos em branco. Do contrrio, ocasionar erros. A diferena
entre as duas variveis, que uma um nmero inteiro e a outra uma string caracterizada pelas aspas duplas.
Caso exista uma varivel entre as aspas duplas, o valor desta ser considerado. Se estiver entre aspas simples
('') ser considerado o valor literal. E, por ltimo, se a varivel estiver entre crases (``), o comando do
sistema ser executado.
Existem variveis pr-definidas no sistema para serem utilizadas. Vale lembrar que ao trabalhar com Shell
Script, pode-se interagir com comandos internos do sistema GNU/Linux, como cat, tail, ls, entre outros. Essa
interao ser vista no decorrer do artigo.
Variveis Especiais:
4

$* Todos os valores passados como argumentos;


$n O valor do argumento na posio n;

$0 Nome do script que est sendo executado;

$1-$9 Parmetros passados pela linha de comando;

$# Total de parmetros passados;

$? Valor de retorno do ltimo comando ou de todo o script;

$$ Nmero do processo executado (PID).

Operadores
Abaixo, uma listagem de operadores lgicos, condicionais e aritmticos utilizados para escrever scripts em
shell com estruturas de controles, funes, entre outros.
Operadores Aritmticos:
+ Adio
- Subtrao

* Multiplicao

/ Diviso

** Exponenciao

% Resto da diviso (mod)

Operadores de Comparao:
= Igual (strings)
!= Desigualdade

< Menor que

> Maior que

<= Menor ou Igual

>= Maior ou igual

Operadores de Expresses Condicionais:


-lt Nmero menor que (LessThan)
-gt Nmero maior que (GreaterThan)

-le Nmero menor ou igual (LessEqual)

-ge Nmero maior ou igual (GreaterEqual)


5

-eq Nmero igual (EQual)

-ne Nmero diferente (NotEqual)

-a E lgico (AND)

-o OU lgico (OU)

Testes em Arquivos:
-d Se for um diretrio
-e Se existir

-z Se estiver vazio

-f Se contiver texto

-s Se o tamanho do arquivo for maior que zero

-r Se o arquivo tem permisso de leitura

-w Se o arquivo tem permisso de escrita

-x Se o arquivo pode ser executado

-nt Se o arquivo for mais recente (NewThan)

-ot Se o arquivo mais antigo (OlderThan)

-ef Se o arquivo o mesmo (EqualFile)

Primeiros algoritmos
Para a construo de algoritmos, muito importante a organizao do cdigo. Para este artigo, ser seguido
um padro para a criao dos algoritmos, como mostrado abaixo:
#!/bim/bash
#Autor:
#Data:
A primeira linha especifica o interpretador, que indicado pelos caracteres #!, termo conhecido como
shebang. O caractere #, significa que a linha um comentrio e no dever ser interpretada pelo shell.
Para iniciarmos o primeiro script, abra o terminal e, de acordo com a sua preferncia, escolha um editor de
textos para comear:
nano alg.001.sh
6

Dentro do editor de texto, vamos escrever nosso primeiro algoritmo. Este algoritmo ter a funo de receber
dois nmeros do usurio e efetuar uma soma.
Algoritmo 001:
#!/bin/bash
#Autor: k666
#Data: 13/07/2013
#Algoritmo que recebe dois nmeros pelo usurio e realiza a soma destes
echo "Digite o primeiro nmero: "
read num1
echo "Digite o segundo nmero: "
read num2
soma=$((num1+num2))
echo "Total: $soma"
Salve o arquivo e, em seguida, lhe atribua a permisso de execuo:
sudo chmod +x alg001.sh
$ ./alg001.sh
As variveis foram declaradas junto ao cdigo e foram utilizadas trs. O comando echo usado para
imprimir informaes na tela. O read, l o contedo da varivel.
Abaixo, sero apresentados mais exemplos de algoritmos. Proceda da mesma forma como mostrado
anteriormente, sempre criando um novo arquivo de texto e aps seu trmino, salve-o e lhe d permisso de
execuo.
Algoritmo 002:
#!/bin/bash
#Autor: k666
#Data: 13/07/2013
#Algoritmo que calcula o desconto e total do valor de uma compra
echo "Valor do produto: "
read valp
echo "Quantidade de produtos: "
read qtd
echo "Informe o valor do desconto: "
read desc
#Clculo do total inicial das compras
tcompra=$((valp*qtd))
#Clculo para saber o desconto
tdesc=$((tcompra*desc/100))
7

#O valor final das compras ser o valor total menos os descontos


total=$((tcompra-tdesc))
echo "Total das Compras: $total"
Para este exemplo foram usadas seis variveis, separados os clculos para ficar mais fcil o aprendizado e
evitar erros no resultado final.
A grande dificuldade que muitos enfrentam em aprender lgica de programao, oriundo de uma base fraca
na matemtica. Nos dois exemplos utilizados, foram postos elementos da matemtica para resoluo de
problemas do cotidiano.
Algoritmo 003:
#!/bin/bash
#Autor: k666
#Data: 13/07/2013
#Algoritmo que recebe trs notas fornecidas pelo usurio e calcula a mdia final
#Os valores das duas variveis abaixo esto entre crases
#O comando date, sleep e clear fazem parte do sistema GNU/Linux
#O comando date retorna a data e hora atual do sistema. Aqui foi utilizado o comando
#date para retornar separadamente o dia (%d), ms (%m), ano (%Y) e hora (%T - time)
data=`date +%d/%m/%Y`
hora=`date +%T`
echo "Data atual: $data"
echo "Hora atual: $hora"
#$USER uma varivel pr-definida do sistema que exibe o usurio atual logado no sistema
echo "Bem-vindo usurio $USER"
#Realiza uma pausa de 3 segundos, ou mais voc que define,
#antes de executar o prximo comando
sleep 3
#Comando que serve para limpar a tela
clear
echo "Informe o nome do aluno: "
read nome
echo "Digite a primeira nota "
read nota1
echo "Digite a segunda nota "
read nota2
echo "Digite a terceira nota "
read nota3
media=$(((nota1+nota2+nota3)/3))

echo "A mdia final do aluno $nome : $media"


Neste ltimo algoritmo, dei uma incrementada com comandos do sistema GNU/Linux. Essa uma das
grandes vantagens de trabalhar com Shell Script.
Fiz o comentrio direto no cdigo, isso importante, pois, com o decorrer do tempo, voc termina
esquecendo a funcionalidade de um cdigo, principalmente quando este passa a ter muitas linhas.
medida que os algoritmos forem aumentando de complexidade, apresentarei outros comandos do
GNU/Linux junto com explicaes.
Algoritmo 004:
#!/bin/bash
#Autor: k666
#Data: 13/07/2013
#Algoritmo que inverte o valor das variveis
#Este valor deve ser informado pelo usurio
echo "Digite um valor qualquer: "
read var1
echo "Digite um outro valor qualquer: "
read var2
echo "Valores atuais das variveis: "
echo "var1 = $var1 | var2 = $var2 "
#Ser criada mais uma varivel que armazenar um dos valores
#para realizar a troca
aux="$var2"
var2="$var1"
var1="$aux"
#O echo sem nenhuma informao serve para pular uma linha
echo
echo "Valores invertidos das variveis: "
echo "var1 = $var1 | var2 = $var2 "
Algoritmo 005:
#!/bin/bash
#Autor: k666
#Data: 20/07/2013
#Algoritmo converte em graus Celsius e apresenta-a convertida
#em graus Fahrenheit. A frmula de converso : F=(9*C+160) / 5,
#sendo F a temperatura em Fahrenheit e C a temperatura em Celsius.
9

echo "Informe a temperatura em graus Celsius: "


read cel
fah=$((9*$cel+160))
echo "Temperatura em Fahrenheit: $fah"

Estrutura de seleo
Uma estrutura de seleo, permite a escolha de um grupo de aes a serem executadas quando determinada
condio for satisfeita.
Em shell, utiliza-se o if, test e/ou case. O elemento test pode ser substitudo por if [ condio ]. O if
bastante conhecido em outras linguagens de programao, bem como o case.
Estrutura do if:
if [ condio ]
then
< sequncia de comandos >
fi
O comando if ir testar se a condio verdadeira, caso sim, ento (then), execute a sequncia de comandos.
A estrutura de seleo do if encerra com o fi.
possvel informar o que ser feito, caso uma condio seja falsa:
if [ condio ]; then
< sequncia de comandos >
else
< sequncia de comandos >
fi
No exemplo anterior, caso a condio no seja verdadeira, ser executado um outro bloco de comandos
diferente do primeiro exemplo que no executaria nada, caso a condio fosse falsa.
Outro ponto a ser observado, que o then est na primeira linha, junto com a condio. Isso possvel por
meio do caractere ; que permite executar comandos em sequncia.
Algoritmo 006:
#!/bin/bash
#Autor: k666
#Data: 20/07/2013
#Algoritmo que informa se o nmero impar ou par
10

#O nmero ser mpar se o resto da diviso por 2 for igual a 1


#se for 0, o nmero par.
echo "Digite um nmero: "
read num
#Efetuei o clculo que retorno o resto da diviso de um nmero com
#o operador %. Atribuir o nome a varivel de mod referente a modular (%)
#o if testa apenas variveis por isso fiz o clculo antes at por questo de organizao
mod=$(($num%2))
if [ $mod -eq 1 ]
then
echo "O nmero $num impar!"
else
echo "O nmero $num par!"
fi
Abaixo, o mesmo algoritmo, porm, utilizando o comando test. O resultado final ser o mesmo.
Algoritmo 006.1:
#!/bin/bash
#Autor: k666
#Data: 20/07/2013
#Algoritmo que informa se o nmero impar ou par
#O nmero ser mpar se o resto da diviso por 2 for igual a 1
#se for 0, o nmero par.
echo "Digite um nmero: "
read num
mod=$(($num%2))
if test $mod -eq 1
then
echo "O nmero $num impar!"
else
echo "O nmero $num par!"
fi
Algoritmo 007:
#!/bin/bash #Autor: k666 #Data: 20/07/2013 #Algoritmo que recebe trs nmeros e os escreve em ordem
crescente #e informar se estes so iguais

11

echo "Digite um nmero: " read num1


echo "Digite o segundo nmero: " read num2
echo "Digite o terceiro nmero: " read num3
#Sero seis possibilidades possveis para determinar qual
#nmero maior que o outro. Aqui estou usando operadores relacionais
#-gt (maior que) e -a (and que o e lgico)
if [ $num1 -gt $num2 -a $num1 -gt $num3 -a $num2 -gt $num3 ]
then
echo "Os nmeros em ordem crescente so: $num3, $num2 e $num1"
elif [ $num2 -gt $num1 -a $num2 -gt $num3 -a $num1 -gt $num3 ]
then
echo "Os nmeros em ordem crescente so: $num3, $num1 e $num2"
elif [ $num3 -gt $num1 -a $num3 -gt $num2 -a $num1 -gt $num2 ]
then
echo "Os nmeros em ordem crescente so: $num2, $num1 e $num3"
elif [ $num1 -gt $num2 -a $num1 -gt $num3 -a $num3 -gt $num2 ]
then
echo "Os nmeros em ordem crescente so: $num2, $num3 e $num1"
elif [ $num2 -gt $num1 -a $num2 -gt $num3 -a $num3 -gt $num1 ]
then
echo "Os nmeros em ordem crescente so: $num1, $num3 e $num2"
elif [ $num3 -gt $num1 -a $num3 -gt $num2 -a $num2 -gt $num1 ]
then
echo "Os nmeros em ordem crescente so: $num1, $num2 e $num3"
else
echo "Os nmeros so iguais"
fi
Algoritmo 008:
#!/bin/bash
#Autor: k666
#Data: 13/07/2013
#Algoritmo que recebe trs notas fornecidas pelo usurio e calcula a mdia final
#e informa se o aluno foi aprovado ou reprovado com a mdia com duas
#casas decimais
#Os valores das duas variveis abaixo esto entre crases
#O comando date, sleep e clear fazem parte do sistema GNU/Linux
#O comando date retorna a data e hora atual do sistema. Aqui
#foi utilizado o comando date para retornar separadamente o
#dia (%d), ms (%m), ano (%Y - quatro dgitos) e hora (%T - time)
data=`date +%d/%m/%Y`
hora=`date +%T`
12

echo "___________________________"
echo "Data atual: $data"
echo "Hora atual: $hora"
#O comando echo sem argumentos, permite pular uma linha
echo
echo -e "CALCULA MDIA 2013"
echo
#$USER uma varivel predefinida do sistema que exibe o usurio atual logado no sistema
echo "Bem-vindo usurio $USER"
echo "___________________________"
#Realiza uma pausa de 3 segundos, ou mais voc que define,
#antes de executar o prximo comando
echo
echo "Informe o nome do aluno: "
read nome
echo "Digite a primeira nota "
read nota1
echo "Digite a segunda nota "
read nota2
echo "Digite a terceira nota "
read nota3
#A varivel media ser utilizada para utilizar seu contedo
#na estrutura de deciso. O programa bc utilizado como uma
#calculadora matemtica onde o valor da varivel canalizado
#pelo pipe ( | ) para o bc e em seguida para o comando cut.
#O cut recorta uma informao que neste caso um caractere
#com o parmetro -c que pega apenas o primeiro para ser feito
#o teste condicional (if) j que este no aceita valores decimais
media=$(echo "scale=2;($nota1+$nota2+$nota3)/3" | bc -l | cut -c1)
#mf a mdia final com o clculo com as duas casas decimais como
#proposto no algoritmo
mf=$(echo "scale=2;($nota1+$nota2+$nota3)/3" | bc -l)
if [ $media -ge 7 ]; then
echo "O aluno $nome est aprovado! Mdia final: $mf"
else
13

echo "O aluno $nome est reprovado. Mdia Final: $mf"


fi
Uma outra estrutura de seleo, o case. A sua utilizao muito til quando trabalhamos com mltiplas
escolhas, como menus. Nos exemplos abaixo, essa compreenso ficar mais fcil de entender.
Estrutura do comando case:
case $var in
padrao1) cmd1
cmd2
cmdn ;;
padrao2) cmd1
cmd2
cmdn ;;
padraon) cmd1
cmd2
cmdn ;;
esac
Algoritmo 009 [3]:
#!/bin/bash
#Autor: k666
#Data: 13/07/2013
#Algoritmo que quando executado informa as seguintes saudaes: Bom dia, Boa tarde ou Boa noite.
#Alm disso, informar a saudao junto com o nome do usurio
#O comando date foi formatado de tal forma afim de pegar a penas a hora e no o minuto. Ex.: Suponha que
seja 08:30, com o comando abaixo, s ser obtido o 08
hora=$(date +%H)
#Entendendo as condies para a saudao:
#0? | 1[01] - Significa zero seguido de qualquer coisa (?), ou (|) um seguido de zero ou um ([01]) ou seja,
esta linha pegou 01, 02, ... 09, 10 e 11;
#1[2-7] - Significa um seguido da lista de dois a sete, ou seja, esta linha pegou 12, 13, ... 17;
#*
- Significa tudo que no casou com nenhum dos padres anteriores.
case $hora in
0? | 1[01]) echo "Bom Dia $USER"
;;
1[2-7] ) echo "Boa Tarde $USER"
;;
*
) echo "Boa Noite $USER"
;;
esac
exit
Algoritmo 010:
14

#!/bin/bash
#Autor: k666
#Data: 14/01/2014
#Algoritmo que disponibilize uma lista de escolha para o usurio poder procurar, instalar ou remover
#um pacote de software para o sistema Debian
echo "Escolha uma das opes abaixo: "
echo " (1) Procurar um pacote "
echo " (2) Instalar um pacote "
echo " (3) Remover um pacote "
read op
#Logo abaixo so apresentados os comandos para realizar as tarefas de procurar, instalar e remover pacotes
#no sistema Linux Debian
case $op in
1 ) echo -n "Informe o nome do pacote: "
read pkg
apt-cache search $pkg
;;
2 ) echo -n "Informe o nome do pacote: "
read pkg
apt-get install $pkg
;;
3 ) echo -n "Informe o nome do pacote: "
read pkg
apt-get remove $pkg
;;
* ) echo "Opo Invlida"
esac
exit
Algoritmo 010.1:
#!/bin/bash
#Autor: k666
#Data: 14/01/2014
#Algoritmo que disponibilize uma lista de escolha para o usurio poder procurar, instalar ou remover
#um pacote de software para o sistema Red Hat
echo "Escolha uma das opes abaixo: "
echo " (1) Procurar um pacote "
echo " (2) Instalar um pacote "
echo " (3) Remover um pacote "
read op
#Logo abaixo so apresentados os comandos para realizar as tarefas de procurar, instalar e remover pacotes
#no sistema Linux Red Hat
case $op in
15

1 ) echo -n "Informe o nome do pacote: "


read pkg
yum search $pkg
;;
2 ) echo -n "Informe o nome do pacote: "
read pkg
yum install $pkg
;;
3 ) echo -n "Informe o nome do pacote: "
read pkg
yum remove $pkg
;;
* ) echo "Opo Invlida"
esac
exit

Estrutura de repetio
At agora, criamos algoritmos que tm sua execuo apenas uma vez. Para uma nova execuo, preciso
acionar o script. Mas, e se fosse preciso calcular uma mdia para 50 alunos? Algo bastante trabalhoso, no
acham?!
Pensando nisso, o Shell, como em outras linguagens de programao, dispe das estruturas while (enquanto)
e for (para).
O while faz um teste no incio do algoritmo para dar continuidade, ou no, execuo do cdigo. J no caso
do for, informado um valor pr-definido de quantas vezes haver a repetio do cdigo.
Tanto na estrutura while quanto no for, teremos o elemento incrementador ou contador. A funo deste,
fazer um incremento a cada iterao do cdigo.
Este nmero inteiro e pode ter iteraes de 2 em 2, entre outras mediante a funo do algoritmo. Este
incremento assemelha-se a um ponteiro de relgio, onde a cada segundo incrementado 1, at completar os
60 segundos complementando um minuto, dando a vez ao prximo ponteiro.
Abaixo, alguns algoritmos com essas duas estruturas:
Algoritmo 011:
#!/bin/bash
#Autor: k666
#Data: 15/01/2014
#Algoritmo que calcula a mdia anual de uma turma com 5 alunos
#Iniciando a varivel contador (con - pode ser o nome que achar melhor)
16

#e a varivel utilizada para acumular (acm) as mdias para que no final


#seja calculado a mdia da turma.
con=1
acm=0
#A mdia anual ser armazenada na varivel ma
#Caso for digitar um mdia com casas decimais,
#utilizar o ponto ao invs da vrgula. Ex: 2.4
while [ $con -lt 6 ]
do
echo -n "Digite a mdia anual do $con aluno: "
read ma
#No clculo da varivel acm estou utilizando a crase (``) para
#atribuir o valor do clculo a esta. Uma outra forma de atribuio
acm=`echo "scale=2;$acm+$ma" | bc`
con=$(($con + 1))
done
#Calculo da mdia anual da turma (mat). Estou utilizando o comando
#scale junto com a calculadora bc para obter resultados de valor
#decimal especificando duas casas decimais ou quantas voc desejar
mat=$(echo "scale=2;$acm/5" | bc -l)
echo "Mdia anual da turma $mat"
Algoritmo 012:
#!/bin/bash
#Autor: k666
#Data: 15/01/2014
#Algoritmo que executa testes de ping para um range de IPs e ao
#final mostra a quantidade total de hosts.
echo "---------------------------------------"
echo " ALGORITMO TESTAR IP "
echo "---------------------------------------"
echo
#Iniciando a varivel contador (con)
con=0

17

#Aqui deve ser informado a rede. Ex.: 192.168.1 ou 192.168.2 e assim por diante
echo -n "Informe a rede: "
read net
#Informe o IP inicial do teste
echo -n "Informe o IP inicial: "
read ipini
#Informe o IP final do teste
echo -n "Informe o IP final: "
read ipfim
#Clculo de quantos IPs receberam o teste de ping
#tambm ser usado para fazer uma comparao com o contador
#na estrutura de repetio
calc=$(($ipfim-ipini))
#O primeiro teste da estrutura while vai ser com o primeiro
#IP informado pelo usurio. Assim que o lao comear a ser
#executado, este IP inicial ser somando com o contador
#at atingir o total de hosts que deve ser "pingado"
test="$ipini"
while [ $con -le $calc ]
do
#Aqui o comando ping executar um teste em cada host com a
#opo -c1 e ser unida a vivel $net e $test onde esta ltima
#contm o IP dentro do range a ser testado
echo `ping -c1 $net.$test`
con=$(($con + 1))
test=$(($ipini+$con))
done
sleep 2
clear
echo "--------------------------------"
echo " FIM DOS TESTES
"
echo "--------------------------------"
echo
echo "-> Total de IPs testados: $con"
Algoritmo 013:
#!/bin/bash
#Autor: k666
#Data: 17/01/2014
18

#Algoritmo que imprime a tabuada de cinco


#Aqui atribuir o nome a varivel contador de i e no
#de con como fiz em outro exemplos. Voc pode atribuir
#o nome que desejar contanto que saiba a finalidade deste
i=0
#Para este exemplo estou utilizando a tabuada de 5, porm, caso
#necessite usar um outro valor, basta substituir o 5
while [ $i -le 10 ]
do
#Aqui vai o clculo da multiplicao. Quando i for 0, ento ser
#multiplicado por 5 e assim sucessivamente at que o contador (i)
#seja 10 e finalize a execuo do lao.
calc=$(($i*5))
echo "$i X 5 = $calc"
i=$((i + 1))
done
Algoritmo 014:
#!/bin/bash
#Autor: k666
#Data: 17/01/2014
#Algoritmo que calcula o fatorial de um
#nmero fornecido pelo usurio
#O fatorial calculado da seguinte forma:
#fatorial de 3: 3x2x1 = 6
#fatorial de 4: 4x3x2x1 = 24
echo "Digite o nmero que queria saber o fatorial: "
read num
#Iniciando a varivel fatorial(fat)
fat=1
#O contador i inicia com o nmero 1 e o loop ser
#executado mediante seu valor ser menor igual ao valor
#da varivel $num
for ((i=1; i <= $num ; i++))
do
#Aqui utilizada a varivel $fat que ser multiplicado
#pela varivel $i(contador) at o fim do loop

19

fat=$(($fat*$i))
done
echo "O fatorial de $num : $fat "
Algoritmo 015:
#!/bin/bash
#Autor: k666
#Data: 17/01/2014
#Algoritmo que simule uma contagem regressiva de 10 minutos, ou seja,
#mostre 10:00, e ento 9:59, 9:58, ..., 9:00, 8:59 at 0:00
#Serve apenas para exibir a contagem ser iniciada em 10:00
echo "10:00"
#Varivel min (minutos) e seg (segundos)
#O primeiro for ser utilizado para contar os minutos (min)
for ((min=9; min>=0; min--))
do
#O primeiro for ser utilizado para contar os segundos (seg)
#Este for significa que o minuto s mudar quando o loop do segundo
#chegar ao seu fim. Tanto na varivel min quanto seg vai decrementar
#(min-- e seg--), ou seja, diminuir de 1 em 1
for ((seg=59; seg>=0; seg--))
do
#Perceba que entre a varivel $min e $seg tem : (dois pontos) para
#fazer a separao de minutos e segundos
echo "$min:$seg"
done
done

Funes
Conjunto de comandos agrupados em um bloco, que recebe um nome e atravs deste, pode ser ativado.
Por que utilizar funes?
Para permitir o reaproveitamento de cdigo j construdo (por voc ou por outros programadores);
Para evitar que um trecho de cdigo que seja repetido vrias vezes dentro de um mesmo programa;
20

Para permitir a alterao de um trecho de cdigo de uma forma mais rpida. Com o uso de uma
funo preciso alterar apenas dentro da funo que se deseja;

Para que os blocos do programa no fiquem grandes demais e, por consequncia, mais difceis de
entender;

Para facilitar a leitura do programa-fonte de uma forma mais fcil;

Para separar o programa em partes (blocos) que possam ser logicamente compreendidos de forma
isolada.[4]

A estrutura bsica de uma funo em Shell Script, :


funcao ()
{
}
E a chamada feita no cdigo, digitando o nome da mesma:
funcao
Dentro de um script. Declare primeiro as funes, ao invs de fazer isso no final, caso contrrio, ir
apresentar erros.
Alguns exemplos de funes:
Algoritmo 016:
#!/bin/bash
#Autor: k666
#Data: 21/01/2013
#Algoritmo que calcula a raiz quadrada
#O clculo trata-se de nmero exatos por exemplo: raiz quadrada
#de 4 2: 16 4. O Shell, por si s, no calcula valores
#de ponto flutuante a no ser que haja interao com a calculadora
#bc como j visto em outros algoritmos
raiz()
{
echo "Digite um nmero: "
read num
#Iniciando o contador com 1 pois no existe diviso por zero
i=1
while [ $i -lt $num ]
do
21

#Varivel calc significa clculo e calc2, clculo2


#A varivel calc far a diviso do nmero passado pelo
#usurio e o contador. Em seguida este valor ser multiplicado
#por ele mesmo na varivel calc2.
calc=$(($num / $i))
calc2=$(($calc * $calc ))
#Aqui realizado o teste que caso seja verdadeiro a
#condio $calc2 for igual a $num, haver uma interrupo
#no loop (com o comando break) e ser mostrado o comando
#echo logo abaixo
if [ $calc2 -eq $num ]
then
break
fi
i=$(($i + 1))
done
echo "A raiz quadrada de $num : $calc"
}
raiz
Algoritmo 017:
#!/bin/bash
#Autor: k666
#Data: 27/01/2013
#Algoritmo utilizado para criar, alterar e apagar
#contas de usurio do sistema Linux
menu()
{
echo _____________________________
echo
echo CADASTRAR USURIOS NO SISTEMA
echo _____________________________
echo
echo
echo " 1 - Cadastrar "
echo " 2 - Procurar "
echo " 3 - Apagar "
22

echo " 0 - Sair "


echo "Escolha uma das opes acima: "
read op
case $op in
1) cadastrar ;;
2) procurar ;;
3) apagar ;;
0) exit ;;
*) Opo invlida ;;
esac
}
cadastrar()
{
echo -n "Nome completo: "
read nome
echo -n "Informe o nome para Login: "
read login
echo -n "Cargo: "
read cargo
#Comando para criar contas no Linux
useradd -d /home/$login -m -c "$nome - $cargo" -s /bin/bash $login
passwd $login
#Limpa a tela e volta ao menu principal
clear
menu
}
procurar()
{
echo -n "Informe o login do usurio: "
read login
cat /etc/passwd | grep -i $login

23

sleep 4
clear
menu
}
apagar()
{
echo -n "Informe o login do usurio: "
read login
echo -n "Apagar o diretrio /home do usurio? (s ou n) "
read op
if [ $op = "s" ]
then
userdel -r $login
else
userdel $login
fi
sleep 3
clear
menu
}
#Chamando a funo
menu

Vetor (array)
As variveis de ambiente podem ser com arrays, possibilitando a insero de vrios valores dentro de uma
mesma varivel. Outro nome dado ao array, em lgica de programao, vetor.
Cada valor referenciado em um ndice representando uma posio reservada na memria.
O ndice de um vetor, tambm chamado de chave. atravs dele que temos acesso a determinadas
posies do vetor para realizarmos as tarefas de atribuio e consulta.
Estrutura:

24

variavel=(valor1 valor2 valor3 ...)


Para acessar um elemento no vetor (array), use seu nmero de ndice (entre colchetes), contando a partir de
zero todo conjunto entre chaves.
Ex.: acessando o valor que est na posio zero do vetor:
echo ${variavel[0]}
Para mostrar todo o contedo do array, use o asterisco no lugar no ndice:
echo ${variavel[*]}
Algoritmo 018:
#!/bin/bash
#Autor: k666
#Data: 17/01/2014
#Algoritmo que executa teste de conectividade com um lista de hosts
#Declarando a varivel que ir armazenar os sites a serem testados
hosts=(www.google.com.br www.vivaolinux.com.br www.uol.com.br)
#Executa o comando ping com o envio de apenas 1 pacote ao primeiro
#host armazenado no vetor
ping -c1 ${hosts[0]}
#Aps trs segundos, a tela ser limpa e testado o prximo site
sleep 3
clear
ping -c1 ${hosts[1]}
sleep 3
clear
ping -c1 ${hosts[2]}
Assim, finalizo este artigo. Procure baixar lista de exerccios de algoritmos e tente aplic-los em Shell Script.
Bons estudos!

Bibliografia
25

COSTA, Daniel Gouveia. Administrao de Redes com Scripts. 1 Edio. Rio de Janeiro, Editora
Brasport, 2007.
FORBELONE, Andr Luiz Villar & EBERSPACHER, Henri Frederico.Lgica de Programao A
construo de Algoritmos e Estrutura de Dados. 3 Edio. So Paulo, Editora Person, 2005.
JARGAS, Aurlio Marinho. Shell Script Profissional. 1 Edio. So Paulo, Editora Novatec, 2012.

Referncias

[1] FORBELONE, Andr Luiz Villar & EBERSPACHER, Henri Frederico.Lgica de Programao A
construo de Algoritmos e Estrutura de Dados. 3 Edio. Pg. 14.

[2] NEVES, Jlio Cezar. Curso de Shell Script. Linux Magazine Online. ltimo Acesso em jun/2013.

[3] Este algoritmo foi uma adaptao encontrada no site: Papo de Botequim IV Programao Shell
Linux. ltimo acesso em jan/2014.

[4] PINHO, Mrcio Sarroglia. Uso de Funes em C. ltimo acesso em jan/2014.

26