Algoritmos em Shell Script

Por /
Introdução / O Shell Script

Introdução

O estudo de algoritmos, é de fundamental importância para o desenvolvimento da lógica de programação e, consequentemente, o aprendizado e domínio de uma linguagem de programação.

Um algoritmo é uma sequência finita de instruções bem definidas e não ambíguas, ou seja, um conjunto de instruções executadas passo a passo, necessários para executar uma tarefa.

Outra definição muito interessante de algoritmo:

“Um algoritmo tem por objetivo, representar mais fielmente o raciocínio envolvido na lógica de programação e, desta forma, permitir-nos abstrair de uma série de detalhes computacionais, que podem ser acrescentados mais tarde.” [1]

Utiliza-se algoritmos para resolver problemas reais de forma abstrata com o auxílio de uma linguagem de programação ou até mesmo por fluxogramas, que são gráficos que demonstram a sequência operacional do desenvolvimento de um processo.

Este processo pode ser a troca de uma lâmpada, calcular a média aritmética de alunos, o espaço percorrido por um carro, entre outros.

A figura 1, mostra um exemplo de um algoritmo representado por um fluxograma:

Linux: Algoritmos em Shell Script

O Shell Script

O shell, nada mais é, do que um mediador entre o usuário e o kernel do sistema operacional. Este, interpreta a entrada de comandos por meio da linguagem bash, também conhecido como shell. O bash (Bourne Again Shell), é o shell mais utilizado em modo texto em sistemas GNU/Linux.

Shell Script é utilizado para combinar vários comandos em um único arquivo, onde este deverá ter permissão de execução. Estes scripts são frequentemente usado como ferramenta de configuração e instalação em sistemas operacionais.

Possui características de linguagens de programação, como:

  • Estrutura de decisão;
  • Estrutura de repetição;
  • Funções e argumentos;
  • Definições de variáveis.

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 também foi desenvolvido o Unix), foi durante muitos anos o shell padrão do sistema operacional Unix. É também chamado de Standard Shell por ter sido durante vários anos o único, e é até hoje o mais utilizado. Foi portado para praticamente todos os ambientes Unix e distribuições GNU/Linux.
  • Korn Shell (ksh): Desenvolvido por David Korn, também 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 usuários 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 número de seus adeptos é o que mais cresce em todo o mundo, seja porque ele é o Shell padrão do Linux, seja por sua grande diversidade de comandos, que incorpora inclusive diversos comandos característicos 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 histórico de comandos. A estruturação de seus comandos é bem similar à da Linguagem C. Seu grande pecado, foi ignorar a compatibilidade com o sh, partindo por um caminho próprio.
Variáveis / Operadores

Variáveis

Em lógica de programação, variáveis são espaços reservados na memória para armazenar um dado a ser utilizado em uma operação aritmética, lógica e em atribuições de valores.

O valor da variável pode mudar de acordo com o andamento do algoritmo como, por exemplo, no cálculo de um média anual para alunos de uma escola. Cada aluno terá suas notas, onde estas serão calculadas para a obtenção da média.

Algumas variáveis pode ter um valor fixo como a fórmula para o cálculo do raio de uma circunferência, onde Pi tem um valor aproximado de 3,1416… Aqui, Pi sempre terá este mesmo valor.

Antes de começar a criar variáveis, é importante seguir algumas dicas para nomeá-las:

1. Nome de variáveis não podem ser iguais a palavras reservadas, nem tampouco conter caracteres especiais (* & # @);

Exemplo: if, while, for.

2. Não inicie variáveis com números e sempre atribua nomes que facilite o trabalho futuro. Não atribua nomes a variáveis como a, b, c… Se o desenvolvedor do código não tiver o costume de comentar o seu código, esse tipo de nome não ajudará em nada a lembrar a utilidade da variável;

3. Cuidado com nomes muito extensos. Via de regra, o tamanho do nome de uma variável não deve ultrapassar 127 caracteres;

4. Não pode conter espaços em branco;

5. Padronize no quesito de letras maiúsculas ou minúsculas. Sempre procuro por nomes com letra em minúsculo.

Em shell, diferente de outras linguagens de programação, não faz-se necessário indicar o tipo da variável. Não é preciso informar se a variável será um número inteiro, real, caractere (string) ou lógico.

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 variável var é reconhecida pelo shell através do caractere $. Entre o nome de uma variável e o sinal de atribuição (=), não podem haver espaços em branco. Do contrário, ocasionará erros. A diferença entre as duas variáveis, é que uma é um número inteiro e a outra uma string caracterizada pelas aspas duplas.

Caso exista uma variável entre as aspas duplas, o valor desta será considerado. Se estiver entre aspas simples (”) será considerado o valor literal. E, por último, se a variável estiver entre crases (“), o comando do sistema será executado.

Existem variáveis 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 interação será vista no decorrer do artigo.

Variáveis Especiais:

  • $* → Todos os valores passados como argumentos;
  • $n → O valor do argumento na posição n;
  • $0 → Nome do script que está sendo executado;
  • $1-$9 → Parâmetros passados pela linha de comando;
  • $# → Total de parâmetros passados;
  • $? → Valor de retorno do último comando ou de todo o script;
  • $$ → Número do processo executado (PID).

Operadores

Abaixo, uma listagem de operadores lógicos, condicionais e aritméticos utilizados para escrever scripts em shell com estruturas de controles, funções, entre outros.

Operadores Aritméticos:

  • + → Adição
  • – → Subtração
  • * → Multiplicação
  • / → Divisão
  • ** → Exponenciação
  • % → Resto da divisão (mod)

Operadores de Comparação:

  • = → Igual (strings)
  • != → Desigualdade
  • < → Menor que
  • > → Maior que
  • <= → Menor ou Igual
  • >= → Maior ou igual

Operadores de Expressões Condicionais:

  • -lt → Número é menor que (LessThan)
  • -gt → Número é maior que (GreaterThan)
  • -le → Número é menor ou igual (LessEqual)
  • -ge → Número é maior ou igual (GreaterEqual)
  • -eq → Número é igual (EQual)
  • -ne → Número é diferente (NotEqual)
  • -a → E lógico (AND)
  • -o → OU lógico (OU)

Testes em Arquivos:

  • -d → Se for um diretório
  • -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 permissão de leitura
  • -w → Se o arquivo tem permissão 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 construção de algoritmos, é muito importante a organização do código. Para este artigo, será seguido um padrão para a criação 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 comentário e não deverá ser interpretada pelo shell.

Para iniciarmos o primeiro script, abra o terminal e, de acordo com a sua preferência, escolha um editor de textos para começar:

$ nano alg.001.sh

Dentro do editor de texto, vamos escrever nosso primeiro algoritmo. Este algoritmo terá a função de receber dois números do usuário e efetuar uma soma.

Algoritmo 001:

#!/bin/bash
#Autor: k666
#Data: 13/07/2013
#Algoritmo que recebe dois números pelo usuário e realiza a soma destesecho “Digite o primeiro número: ”
read num1
echo “Digite o segundo número: ”
read num2soma=$((num1+num2))echo “Total: $soma”

Salve o arquivo e, em seguida, lhe atribua a permissão de execução:

$ sudo chmod +x alg001.sh
$ ./alg001.sh

As variáveis foram declaradas junto ao código e foram utilizadas três. O comando echo é usado para imprimir informações na tela. O read, lê o conteúdo da variável.

Abaixo, serão apresentados mais exemplos de algoritmos. Proceda da mesma forma como mostrado anteriormente, sempre criando um novo arquivo de texto e após seu término, salve-o e lhe dê permissão de execução.

Algoritmo 002:

#!/bin/bash
#Autor: k666
#Data: 13/07/2013
#Algoritmo que calcula o desconto e total do valor de uma compraecho “Valor do produto:  ”
read valp
echo “Quantidade de produtos: ”
read qtd
echo “Informe o valor do desconto: ”
read desc#Cálculo do total inicial das compras
tcompra=$((valp*qtd))#Cálculo para saber o desconto
tdesc=$((tcompra*desc/100))

#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 variáveis, separados os cálculos para ficar mais fácil o aprendizado e evitar erros no resultado final.

A grande dificuldade que muitos enfrentam em aprender lógica de programação, é oriundo de uma base fraca na matemática. Nos dois exemplos utilizados, foram postos elementos da matemática para resolução de problemas do cotidiano.

Algoritmo 003:

#!/bin/bash
#Autor: k666
#Data: 13/07/2013
#Algoritmo que recebe três notas fornecidas pelo usuário e calcula a média final#Os valores das duas variáveis abaixo estão 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), mês (%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 variável pré-definida do sistema que exibe o usuário atual logado no sistema
echo “Bem-vindo usuário $USER”
#Realiza uma pausa de 3 segundos, ou mais você é que define,
#antes de executar o próximo 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 média 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 comentário direto no código, isso é importante, pois, com o decorrer do tempo, você termina esquecendo a funcionalidade de um código, principalmente quando este passa a ter muitas linhas.

À medida que os algoritmos forem aumentando de complexidade, apresentarei outros comandos do GNU/Linux junto com explicações.

Algoritmo 004:

#!/bin/bash
#Autor: k666
#Data: 13/07/2013
#Algoritmo que inverte o valor das variáveis
#Este valor deve ser informado pelo usuárioecho “Digite um valor qualquer:  ”
read var1
echo “Digite um outro valor qualquer: ”
read var2echo “Valores atuais das variáveis: ”
echo “var1 = $var1 | var2 = $var2 “#Será criada mais uma variável que armazenará um dos valores
#para realizar a troca

aux=”$var2″
var2=”$var1″
var1=”$aux”

#O echo sem nenhuma informação serve para pular uma linha
echo

echo “Valores invertidos das variáveis: ”
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 fórmula de conversão é: F=(9*C+160) / 5,
#sendo F a temperatura em Fahrenheit e C a temperatura em Celsius.echo “Informe a temperatura em graus Celsius:  ”
read celfah=$((9*$cel+160))echo “Temperatura em Fahrenheit: $fah”
Estrutura de seleção

Uma estrutura de seleção, permite a escolha de um grupo de ações a serem executadas quando determinada condição for satisfeita.

Em shell, utiliza-se o if, test e/ou case. O elemento test pode ser substituído por if [ condição ]. O if é bastante conhecido em outras linguagens de programação, bem como o case.

Estrutura do if:

if [ condição ]
then
< sequência de comandos >
fi

O comando if irá testar se a condição é verdadeira, caso sim, então (then), execute a sequência de comandos. A estrutura de seleção do if encerra com o fi.

É possível informar o que será feito, caso uma condição seja falsa:

if [ condição ]; then
< sequência de comandos >
else
< sequência de comandos >
fi

No exemplo anterior, caso a condição não seja verdadeira, será executado um outro bloco de comandos diferente do primeiro exemplo que não executaria nada, caso a condição fosse falsa.

Outro ponto a ser observado, é que o then está na primeira linha, junto com a condição. Isso é possível por meio do caractere ; que permite executar comandos em sequência.

Algoritmo 006:

#!/bin/bash
#Autor: k666
#Data: 20/07/2013
#Algoritmo que informa se o número é impar ou par
#O número será ímpar se o resto da divisão por 2 for igual a 1
#se for 0, o número é par.echo “Digite um número:  ”
read num#Efetuei o cálculo que retorno o resto da divisão de um número com
#o operador %. Atribuir o nome a variável de mod referente a modular (%)
#o if testa apenas variáveis por isso fiz o cálculo antes até por questão de organizaçãomod=$(($num%2))

if [ $mod -eq 1 ]
then
echo “O número $num é impar!”
else
echo “O número $num é par!”
fi

Abaixo, o mesmo algoritmo, porém, 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 número é impar ou par
#O número será ímpar se o resto da divisão por 2 for igual a 1
#se for 0, o número é par.echo “Digite um número:  ”
read nummod=$(($num%2))if test $mod -eq 1
then
echo “O número $num é impar!”
else
echo “O número $num é par!”
fi

Algoritmo 007:

#!/bin/bash #Autor: k666 #Data: 20/07/2013 #Algoritmo que recebe três números e os escreve em ordem crescente #e informar se estes são iguais

echo “Digite um número: ” read num1

echo “Digite o segundo número: ” read num2

echo “Digite o terceiro número: ” read num3

#Serão seis possibilidades possíveis para determinar qual
#número é maior que o outro. Aqui estou usando operadores relacionais
#-gt (maior que) e  -a (and que é o e lógico)if [ $num1 -gt $num2 -a $num1 -gt $num3 -a $num2 -gt $num3 ]
then
echo “Os números em ordem crescente são: $num3, $num2 e $num1”
elif [ $num2 -gt $num1 -a $num2 -gt $num3 -a $num1 -gt $num3 ]
then
echo “Os números em ordem crescente são: $num3, $num1 e $num2”
elif [ $num3 -gt $num1 -a $num3 -gt $num2 -a $num1 -gt $num2 ]
then
echo “Os números em ordem crescente são: $num2, $num1 e $num3”
elif [ $num1 -gt $num2 -a $num1 -gt $num3 -a $num3 -gt $num2 ]
then
echo “Os números em ordem crescente são: $num2, $num3 e $num1”
elif [ $num2 -gt $num1 -a $num2 -gt $num3 -a $num3 -gt $num1 ]
then
echo “Os números em ordem crescente são: $num1, $num3 e $num2”
elif [ $num3 -gt $num1 -a $num3 -gt $num2 -a $num2 -gt $num1 ]
then
echo “Os números em ordem crescente são: $num1, $num2 e $num3”
else
echo “Os números são iguais”
fi

Algoritmo 008:

#!/bin/bash
#Autor: k666
#Data: 13/07/2013
#Algoritmo que recebe três notas fornecidas pelo usuário e calcula a média final
#e informa se o aluno foi aprovado ou reprovado com a média com duas
#casas decimais#Os valores das duas variáveis abaixo estão 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), mês (%m), ano (%Y – quatro dígitos) e hora (%T – time)data=`date +%d/%m/%Y`
hora=`date +%T`echo “___________________________”

echo “Data atual: $data”
echo “Hora atual: $hora”

#O comando echo sem argumentos, permite pular uma linha
echo
echo -e “CALCULA MÉDIA 2013”
echo

#$USER é uma variável predefinida do sistema que exibe o usuário atual logado no sistema

echo “Bem-vindo usuário $USER”

echo “___________________________”

#Realiza uma pausa de 3 segundos, ou mais você é que define,
#antes de executar o próximo 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 variável media será utilizada para utilizar seu conteúdo
#na estrutura de decisão. O programa bc é utilizado como uma
#calculadora matemática onde o valor da variável é canalizado
#pelo pipe ( | ) para o bc e em seguida para o comando cut.
#O cut recorta uma informação que neste caso é um caractere
#com o parâmetro -c que pega apenas o primeiro para ser feito
#o teste condicional (if) já que este não aceita valores decimais

media=$(echo “scale=2;($nota1+$nota2+$nota3)/3” | bc -l | cut -c1)

#mf é a média final com o cálculo 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! Média final: $mf”
else
echo “O aluno $nome está reprovado. Média Final: $mf”
fi

Uma outra estrutura de seleção, é o case. A sua utilização é muito útil quando trabalhamos com múltiplas escolhas, como menus. Nos exemplos abaixo, essa compreensão ficará mais fácil 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 saudações: Bom dia, Boa tarde ou Boa noite.
#Além disso, informar a saudação junto com o nome do usuário#O comando date foi formatado de tal forma afim de pegar a penas a hora e não o minuto. Ex.: Suponha que seja 08:30, com o comando abaixo, só será obtido o 08hora=$(date +%H)#Entendendo as condições para a saudação:
#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 não casou com nenhum dos padrões 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:

#!/bin/bash
#Autor: k666
#Data: 14/01/2014
#Algoritmo que disponibilize uma lista de escolha para o usuário poder procurar, instalar ou remover
#um pacote de software para o sistema Debianecho “Escolha uma das opções abaixo: ”
echo ” (1) Procurar um pacote ”
echo ” (2) Instalar um pacote ”
echo ” (3) Remover um pacote ”
read op#Logo abaixo são apresentados os comandos para realizar as tarefas de procurar, instalar e remover pacotes
#no sistema Linux Debiancase $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 “Opção Inválida”
esac
exit

Algoritmo 010.1:

#!/bin/bash
#Autor: k666
#Data: 14/01/2014
#Algoritmo que disponibilize uma lista de escolha para o usuário poder procurar, instalar ou remover
#um pacote de software para o sistema Red Hatecho “Escolha uma das opções abaixo: ”
echo ” (1) Procurar um pacote ”
echo ” (2) Instalar um pacote ”
echo ” (3) Remover um pacote ”
read op#Logo abaixo são apresentados os comandos para realizar as tarefas de procurar, instalar e remover pacotes
#no sistema Linux Red Hatcase $op in
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 “Opção Inválida”
esac
exit
Estrutura de repetição

Até agora, criamos algoritmos que têm sua execução apenas uma vez. Para uma nova execução, é preciso acionar o script. Mas, e se fosse preciso calcular uma média para 50 alunos? Algo bastante trabalhoso, não acham?!

Pensando nisso, o Shell, como em outras linguagens de programação, dispõe das estruturas while (enquanto) e for (para).

O while faz um teste no início do algoritmo para dar continuidade, ou não, à execução do código. Já no caso do for, é informado um valor pré-definido de quantas vezes haverá a repetição do código.

Tanto na estrutura while quanto no for, teremos o elemento incrementador ou contador. A função deste, é fazer um incremento a cada iteração do código.

Este número é inteiro e pode ter iterações de 2 em 2, entre outras mediante a função do algoritmo. Este incremento assemelha-se a um ponteiro de relógio, onde a cada segundo é incrementado 1, até completar os 60 segundos complementando um minuto, dando a vez ao próximo ponteiro.

Abaixo, alguns algoritmos com essas duas estruturas:

Algoritmo 011:

#!/bin/bash
#Autor: k666
#Data: 15/01/2014
#Algoritmo que calcula a média anual de uma turma com 5 alunos#Iniciando a variável contador (con – pode ser o nome que achar melhor)
#e a variável utilizada para acumular (acm) as médias para que no final
#seja calculado a média da turma.con=1
acm=0#A média anual será armazenada na variável ma

#Caso for digitar um média com casas decimais,
#utilizar o ponto ao invés da vírgula. Ex: 2.4

while [ $con -lt 6 ]
do

echo -n “Digite a média anual do $conº aluno: ”
read ma

#No cálculo da variável acm estou utilizando a crase (“) para
#atribuir o valor do cálculo a esta. Uma outra forma de atribuição

acm=`echo “scale=2;$acm+$ma” | bc`
con=$(($con + 1))

done

#Calculo da média 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 “Média 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 variável contador (con)
con=0#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

#Cálculo de quantos IPs receberam o teste de ping
#também será usado para fazer uma comparação com o contador
#na estrutura de repetição
calc=$(($ipfim-ipini))

#O primeiro teste da estrutura while vai ser com o primeiro
#IP informado pelo usuário. Assim que o laço começar 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
#opção -c1 e será unida a viável $net e $test onde esta última
#contêm 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
#Algoritmo que imprime a tabuada de cinco#Aqui é atribuir o nome a variável contador de i e não
#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, porém, caso
#necessite usar um outro valor, basta substituir o 5while [ $i -le 10 ]
do#Aqui vai o cálculo da multiplicação. Quando i for 0, então será
#multiplicado por 5 e assim sucessivamente até que o contador (i)
#seja 10 e finalize a execução do laço.
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
#número fornecido pelo usuário
#O fatorial é calculado da seguinte forma:
#fatorial de 3: 3x2x1 = 6
#fatorial de 4: 4x3x2x1 = 24echo “Digite o número que queria saber o fatorial: ”
read num#Iniciando a variável fatorial(fat)
fat=1#O contador i inicia com o número 1 e o loop será
#executado mediante seu valor ser menor igual ao valor
#da variável $num

for ((i=1; i <= $num ; i++))
do

#Aqui é utilizada a variável $fat que será multiplicado
#pela variável $i(contador) até o fim do loop

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 então 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”#Variável 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 variável 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 variável $min e $seg tem : (dois pontos) para
#fazer a separação de minutos e segundos

echo “$min:$seg”
done
done
Funções

Conjunto de comandos agrupados em um bloco, que recebe um nome e através deste, pode ser ativado.

Por que utilizar funções?

  • Para permitir o reaproveitamento de código já construído (por você ou por outros programadores);
  • Para evitar que um trecho de código que seja repetido várias vezes dentro de um mesmo programa;
  • Para permitir a alteração de um trecho de código de uma forma mais rápida. Com o uso de uma função é preciso alterar apenas dentro da função que se deseja;
  • Para que os blocos do programa não fiquem grandes demais e, por consequência, mais difíceis de entender;
  • Para facilitar a leitura do programa-fonte de uma forma mais fácil;
  • Para separar o programa em partes (blocos) que possam ser logicamente compreendidos de forma isolada.[4]

A estrutura básica de uma função em Shell Script, é:

funcao ()
{}

E a chamada feita no código, é digitando o nome da mesma:

funcao

Dentro de um script. Declare primeiro as funções, ao invés de fazer isso no final, caso contrário, irá apresentar erros.

Alguns exemplos de funções:

Algoritmo 016:

#!/bin/bash
#Autor: k666
#Data: 21/01/2013
#Algoritmo que calcula a raiz quadrada
#O cálculo trata-se de número exatos por exemplo: raiz quadrada
#de 4 é 2: 16 é 4. O Shell, por si só, não calcula valores
#de ponto flutuante a não ser que haja interação com a calculadora
#bc como já visto em outros algoritmosraiz()
{echo “Digite um número: ”
read num#Iniciando o contador com 1 pois não existe divisão por zero
i=1

while [ $i -lt $num ]
do

#Variável calc significa cálculo e calc2, cálculo2
#A variável calc fará a divisão do número passado pelo
#usuário e o contador. Em seguida este valor será multiplicado
#por ele mesmo na variável calc2.

calc=$(($num / $i))
calc2=$(($calc * $calc ))

#Aqui é realizado o teste que caso seja verdadeiro a
#condição $calc2 for igual a $num, haverá uma interrupção
#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 usuário do sistema Linuxmenu()
{echo _____________________________
echo
echo CADASTRAR USUÁRIOS NO SISTEMA
echo _____________________________
echo
echo
echo ” 1 – Cadastrar ”
echo ” 2 – Procurar ”
echo ” 3 – Apagar ”
echo ” 0 – Sair “echo “Escolha uma das opções acima: ”
read op

case $op in
1) cadastrar ;;
2) procurar ;;
3) apagar ;;
0) exit ;;
*) Opção inválida ;;
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 usuário: ”
read login

cat /etc/passwd | grep -i $login

sleep 4
clear

menu

}

apagar()
{

echo -n “Informe o login do usuário: ”
read login

echo -n “Apagar o diretório /home do usuário? (s ou n) ”
read op

if [ $op = “s” ]
then
userdel -r $login
else
userdel $login
fi
sleep 3
clear

menu

}

#Chamando a função

menu
Vetor (array)

As variáveis de ambiente podem ser com arrays, possibilitando a inserção de vários valores dentro de uma mesma variável. Outro nome dado ao array, em lógica de programação, é vetor.

Cada valor é referenciado em um índice representando uma posição reservada na memória.

O índice de um vetor, também é chamado de chave. É através dele que temos acesso a determinadas posições do vetor para realizarmos as tarefas de atribuição e consulta.

Estrutura:

variavel=(valor1 valor2 valor3 …)

Para acessar um elemento no vetor (array), use seu número de índice (entre colchetes), contando a partir de zero todo conjunto entre chaves.

Ex.: acessando o valor que está na posição zero do vetor:

echo ${variavel[0]}

Para mostrar todo o conteúdo 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 variável que irá armazenar os sites a serem testadoshosts=(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]}

#Após três segundos, a tela será limpa e testado o próximo site

sleep 3
clear

ping -c1 ${hosts[1]}

sleep 3
clear

ping -c1 ${hosts[2]}

Assim, finalizo este artigo. Procure baixar lista de exercícios de algoritmos e tente aplicá-los em Shell Script.

Autoria: Wagner Souza

Bons estudos!
Print Friendly, PDF & EmailVersão para Impressão
Rolar para cima