{"id":929,"date":"2014-07-04T12:25:14","date_gmt":"2014-07-04T15:25:14","guid":{"rendered":"http:\/\/www.viazap.com.br\/?p=929"},"modified":"2015-02-19T18:27:56","modified_gmt":"2015-02-19T20:27:56","slug":"algoritmos-em-shell-script","status":"publish","type":"post","link":"https:\/\/blog.clusterweb.com.br\/?p=929","title":{"rendered":"Algoritmos em Shell Script"},"content":{"rendered":"\n\n\n\n\n\n\n\n\n
Introdu\u00e7\u00e3o \/ O Shell Script<\/b><\/p>\n
\n

Introdu\u00e7\u00e3o<\/h1>\n

O estudo de algoritmos, \u00e9 de fundamental import\u00e2ncia para o desenvolvimento da l\u00f3gica de programa\u00e7\u00e3o e, consequentemente, o aprendizado e dom\u00ednio de uma linguagem de programa\u00e7\u00e3o.<\/p>\n

Um algoritmo \u00e9 uma sequ\u00eancia finita de instru\u00e7\u00f5es bem definidas e n\u00e3o amb\u00edguas, ou seja, um conjunto de instru\u00e7\u00f5es executadas passo a passo, necess\u00e1rios para executar uma tarefa.<\/p>\n

Outra defini\u00e7\u00e3o muito interessante de algoritmo:<\/p>\n

“Um algoritmo tem por objetivo, representar mais fielmente o racioc\u00ednio envolvido na l\u00f3gica de programa\u00e7\u00e3o e, desta forma, permitir-nos abstrair de uma s\u00e9rie de detalhes computacionais, que podem ser acrescentados mais tarde.” [1]<\/p><\/blockquote>\n

Utiliza-se algoritmos para resolver problemas reais de forma abstrata com o aux\u00edlio de uma linguagem de programa\u00e7\u00e3o ou at\u00e9 mesmo por fluxogramas, que s\u00e3o gr\u00e1ficos que demonstram a sequ\u00eancia operacional do desenvolvimento de um processo.<\/p>\n

Este processo pode ser a troca de uma l\u00e2mpada, calcular a m\u00e9dia aritm\u00e9tica de alunos, o espa\u00e7o percorrido por um carro, entre outros.<\/p>\n

A figura 1, mostra um exemplo de um algoritmo representado por um fluxograma:<\/p>\n

\"Linux:<\/div>\n

O Shell Script<\/h1>\n

O shell, nada mais \u00e9, do que um mediador entre o usu\u00e1rio e o kernel do sistema operacional. Este, interpreta a entrada de comandos por meio da linguagem bash, tamb\u00e9m conhecido como shell. O bash (Bourne Again Shell), \u00e9 o shell mais utilizado em modo texto em sistemas\u00a0GNU\/Linux<\/a>.<\/p>\n

Shell Script \u00e9 utilizado para combinar v\u00e1rios comandos em um \u00fanico arquivo, onde este dever\u00e1 ter permiss\u00e3o de execu\u00e7\u00e3o. Estes scripts s\u00e3o frequentemente usado como ferramenta de configura\u00e7\u00e3o e instala\u00e7\u00e3o em sistemas operacionais.<\/p>\n

Possui caracter\u00edsticas de linguagens de programa\u00e7\u00e3o, como:<\/p>\n

Vari\u00e1veis \/ Operadores<\/b><\/p>\n
\n

Vari\u00e1veis<\/h1>\n

Em l\u00f3gica de programa\u00e7\u00e3o, vari\u00e1veis s\u00e3o espa\u00e7os reservados na mem\u00f3ria para armazenar um dado a ser utilizado em uma opera\u00e7\u00e3o aritm\u00e9tica, l\u00f3gica e em atribui\u00e7\u00f5es de valores.<\/p>\n

O valor da vari\u00e1vel pode mudar de acordo com o andamento do algoritmo como, por exemplo, no c\u00e1lculo de um m\u00e9dia anual para alunos de uma escola. Cada aluno ter\u00e1 suas notas, onde estas ser\u00e3o calculadas para a obten\u00e7\u00e3o da m\u00e9dia.<\/p>\n

Algumas vari\u00e1veis pode ter um valor fixo como a f\u00f3rmula para o c\u00e1lculo do raio de uma circunfer\u00eancia, onde Pi tem um valor aproximado de 3,1416… Aqui, Pi sempre ter\u00e1 este mesmo valor.<\/p>\n

Antes de come\u00e7ar a criar vari\u00e1veis, \u00e9 importante seguir algumas dicas para nome\u00e1-las:<\/p>\n

1. Nome de vari\u00e1veis n\u00e3o podem ser iguais a palavras reservadas, nem tampouco conter caracteres especiais (* & # @);<\/p>\n

Exemplo: if, while, for.<\/p>\n

2. N\u00e3o inicie vari\u00e1veis com n\u00fameros e sempre atribua nomes que facilite o trabalho futuro. N\u00e3o atribua nomes a vari\u00e1veis como a, b, c… Se o desenvolvedor do c\u00f3digo n\u00e3o tiver o costume de comentar o seu c\u00f3digo, esse tipo de nome n\u00e3o ajudar\u00e1 em nada a lembrar a utilidade da vari\u00e1vel;<\/p>\n

3. Cuidado com nomes muito extensos. Via de regra, o tamanho do nome de uma vari\u00e1vel n\u00e3o deve ultrapassar 127 caracteres;<\/p>\n

4. N\u00e3o pode conter espa\u00e7os em branco;<\/p>\n

5. Padronize no quesito de letras mai\u00fasculas ou min\u00fasculas. Sempre procuro por nomes com letra em min\u00fasculo.<\/p>\n

Em shell, diferente de outras linguagens de programa\u00e7\u00e3o, n\u00e3o faz-se necess\u00e1rio indicar o tipo da vari\u00e1vel. N\u00e3o \u00e9 preciso informar se a vari\u00e1vel ser\u00e1 um n\u00famero inteiro, real, caractere (string) ou l\u00f3gico.<\/p>\n

Exemplo de programa em\u00a0C<\/em>:<\/p>\n

#include <stdio.h><\/span>
\nvoid main()
\n{
\nint contador;
\nfloat PrecoDoQuilo;
\ndouble TaxaDeCambio;
\nchar LetraDigitada;
\nint IdadeManoel, IdadeJoao, IdadeMaria;double\u00a0\u00a0TaxaDoDolar,
\nTaxaDoMarco,
\nTaxaDoPeso,
\nTaxaDoFranco;
\n…….
\n}<\/div>\n

Exemplo de um Shell Script:<\/p>\n

\n

#!bin\/bash<\/span><\/p>\n

var=”teste”<\/p>\n

num=3<\/p>\n

echo “$var $num”<\/p>\n<\/div>\n

Perceba que a vari\u00e1vel\u00a0var\u00a0\u00e9 reconhecida pelo shell atrav\u00e9s do caractere\u00a0$. Entre o nome de uma vari\u00e1vel e o sinal de atribui\u00e7\u00e3o (=), n\u00e3o podem haver espa\u00e7os em branco. Do contr\u00e1rio, ocasionar\u00e1 erros. A diferen\u00e7a entre as duas vari\u00e1veis, \u00e9 que uma \u00e9 um n\u00famero inteiro e a outra uma string caracterizada pelas aspas duplas.<\/p>\n

Caso exista uma vari\u00e1vel entre as aspas duplas, o valor desta ser\u00e1 considerado. Se estiver entre aspas simples (”) ser\u00e1 considerado o valor literal. E, por \u00faltimo, se a vari\u00e1vel estiver entre crases (“), o comando do sistema ser\u00e1 executado.<\/p>\n

Existem vari\u00e1veis pr\u00e9-definidas no sistema para serem utilizadas. Vale lembrar que ao trabalhar com Shell Script, pode-se interagir com comandos internos do sistema\u00a0GNU\/Linux<\/a>, como\u00a0cat,\u00a0tail,\u00a0ls, entre outros. Essa intera\u00e7\u00e3o ser\u00e1 vista no decorrer do artigo.<\/p>\n

Vari\u00e1veis Especiais:<\/p>\n

Primeiros algoritmos<\/b><\/p>\n
\n

Para a constru\u00e7\u00e3o de algoritmos, \u00e9 muito importante a organiza\u00e7\u00e3o do c\u00f3digo. Para este artigo, ser\u00e1 seguido um padr\u00e3o para a cria\u00e7\u00e3o dos algoritmos, como mostrado abaixo:<\/p>\n

#!\/bim\/bash
\n#Autor:
\n#Data:<\/span><\/div>\n

A primeira linha especifica o interpretador, que \u00e9 indicado pelos caracteres\u00a0#!, termo conhecido como shebang. O caractere\u00a0#, significa que a linha \u00e9 um coment\u00e1rio e n\u00e3o dever\u00e1 ser interpretada pelo shell.<\/p>\n

Para iniciarmos o primeiro script, abra o terminal e, de acordo com a sua prefer\u00eancia, escolha um editor de textos para come\u00e7ar:<\/p>\n

$ nano alg.001.sh<\/strong><\/p>\n

Dentro do editor de texto, vamos escrever nosso primeiro algoritmo. Este algoritmo ter\u00e1 a fun\u00e7\u00e3o de receber dois n\u00fameros do usu\u00e1rio e efetuar uma soma.<\/p>\n

Algoritmo 001:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 13\/07\/2013
\n#Algoritmo que recebe dois n\u00fameros pelo usu\u00e1rio e realiza a soma destes<\/span>echo “Digite o primeiro n\u00famero: ”
\nread num1
\necho “Digite o segundo n\u00famero: ”
\nread num2soma=$((num1+num2))echo “Total: $soma”<\/p>\n<\/div>\n

Salve o arquivo e, em seguida, lhe atribua a permiss\u00e3o de execu\u00e7\u00e3o:<\/p>\n

$ sudo chmod +x alg001.sh
\n$ .\/alg001.sh<\/strong><\/p>\n

As vari\u00e1veis foram declaradas junto ao c\u00f3digo e foram utilizadas tr\u00eas. O comando\u00a0echo\u00a0\u00e9 usado para imprimir informa\u00e7\u00f5es na tela. O\u00a0read, l\u00ea o conte\u00fado da vari\u00e1vel.<\/p>\n

Abaixo, ser\u00e3o apresentados mais exemplos de algoritmos. Proceda da mesma forma como mostrado anteriormente, sempre criando um novo arquivo de texto e ap\u00f3s seu t\u00e9rmino, salve-o e lhe d\u00ea permiss\u00e3o de execu\u00e7\u00e3o.<\/p>\n

Algoritmo 002:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 13\/07\/2013
\n#Algoritmo que calcula o desconto e total do valor de uma compra<\/span>echo “Valor do produto:\u00a0\u00a0”
\nread valp
\necho “Quantidade de produtos: ”
\nread qtd
\necho “Informe o valor do desconto: ”
\nread desc#C\u00e1lculo do total inicial das compras<\/span>
\ntcompra=$((valp*qtd))#C\u00e1lculo para saber o desconto<\/span>
\ntdesc=$((tcompra*desc\/100))<\/p>\n

#O valor final das compras ser\u00e1 o valor total menos os descontos<\/span>
\ntotal=$((tcompra-tdesc))<\/p>\n

echo “Total das Compras: $total”<\/p>\n<\/div>\n

Para este exemplo foram usadas seis vari\u00e1veis, separados os c\u00e1lculos para ficar mais f\u00e1cil o aprendizado e evitar erros no resultado final.<\/p>\n

A grande dificuldade que muitos enfrentam em aprender l\u00f3gica de programa\u00e7\u00e3o, \u00e9 oriundo de uma base fraca na matem\u00e1tica. Nos dois exemplos utilizados, foram postos elementos da matem\u00e1tica para resolu\u00e7\u00e3o de problemas do cotidiano.<\/p>\n

Algoritmo 003:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 13\/07\/2013
\n#Algoritmo que recebe tr\u00eas notas fornecidas pelo usu\u00e1rio e calcula a m\u00e9dia final<\/span><\/span>#Os valores das duas vari\u00e1veis abaixo est\u00e3o entre crases
\n#O comando date, sleep e clear fazem parte do sistema\u00a0GNU\/Linux<\/a>
\n#O comando date retorna a data e hora atual do sistema. Aqui foi utilizado o comando
\n#date para retornar separadamente o dia (%d), m\u00eas (%m), ano (%Y) e hora (%T – time)data=`date +%d\/%m\/%Y`
\nhora=`date +%T`echo “Data atual: $data”
\necho “Hora atual: $hora”<\/p>\n

#$USER \u00e9 uma vari\u00e1vel pr\u00e9-definida do sistema que exibe o usu\u00e1rio atual logado no sistema<\/span>
\necho “Bem-vindo usu\u00e1rio $USER”
\n#Realiza uma pausa de 3 segundos, ou mais voc\u00ea \u00e9 que define,
\n#antes de executar o pr\u00f3ximo comando<\/span>
\nsleep 3
\n#Comando que serve para limpar a tela<\/span>
\nclear<\/p>\n

echo “Informe o nome do aluno: ”
\nread nome
\necho “Digite a primeira nota\u00a0\u00a0”
\nread nota1
\necho “Digite a segunda nota\u00a0\u00a0”
\nread nota2
\necho “Digite a terceira nota\u00a0\u00a0”
\nread nota3<\/p>\n

media=$(((nota1+nota2+nota3)\/3))<\/p>\n

echo “A m\u00e9dia final do aluno $nome \u00e9: $media”<\/p>\n<\/div>\n

Neste \u00faltimo algoritmo, dei uma incrementada com comandos do sistema GNU\/Linux. Essa \u00e9 uma das grandes vantagens de trabalhar com Shell Script.<\/p>\n

Fiz o coment\u00e1rio direto no c\u00f3digo, isso \u00e9 importante, pois, com o decorrer do tempo, voc\u00ea termina esquecendo a funcionalidade de um c\u00f3digo, principalmente quando este passa a ter muitas linhas.<\/p>\n

\u00c0 medida que os algoritmos forem aumentando de complexidade, apresentarei outros comandos do GNU\/Linux junto com explica\u00e7\u00f5es.<\/p>\n

Algoritmo 004:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 13\/07\/2013
\n#Algoritmo que inverte o valor das vari\u00e1veis
\n#Este valor deve ser informado pelo usu\u00e1rio<\/span>echo “Digite um valor qualquer:\u00a0\u00a0”
\nread var1
\necho “Digite um outro valor qualquer: ”
\nread var2echo “Valores atuais das vari\u00e1veis: ”
\necho “var1 = $var1 | var2 = $var2 “#Ser\u00e1 criada mais uma vari\u00e1vel que armazenar\u00e1 um dos valores
\n#para realizar a troca<\/span><\/p>\n

aux=”$var2″
\nvar2=”$var1″
\nvar1=”$aux”<\/p>\n

#O echo sem nenhuma informa\u00e7\u00e3o serve para pular uma linha<\/span>
\necho<\/p>\n

echo “Valores invertidos das vari\u00e1veis: ”
\necho “var1 = $var1 | var2 = $var2 ”<\/p>\n<\/div>\n

Algoritmo 005:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 20\/07\/2013
\n#Algoritmo converte em graus Celsius e apresenta-a convertida
\n#em graus Fahrenheit. A f\u00f3rmula de convers\u00e3o \u00e9: F=(9*C+160) \/ 5,
\n#sendo F a temperatura em Fahrenheit e C a temperatura em Celsius.<\/span>echo “Informe a temperatura em graus Celsius:\u00a0\u00a0”
\nread celfah=$((9*$cel+160))echo “Temperatura em Fahrenheit: $fah”<\/p>\n<\/div>\n<\/div>\n<\/td>\n<\/tr>\n
Estrutura de sele\u00e7\u00e3o<\/b><\/p>\n
\n

Uma estrutura de sele\u00e7\u00e3o, permite a escolha de um grupo de a\u00e7\u00f5es a serem executadas quando determinada condi\u00e7\u00e3o for satisfeita.<\/p>\n

Em shell, utiliza-se o\u00a0if,\u00a0test\u00a0e\/ou\u00a0case. O elemento\u00a0test\u00a0pode ser substitu\u00eddo por\u00a0if [ condi\u00e7\u00e3o ]. O\u00a0if\u00a0\u00e9 bastante conhecido em outras linguagens de programa\u00e7\u00e3o, bem como o case.<\/p>\n

Estrutura do\u00a0if:<\/p>\n

if [ condi\u00e7\u00e3o ]
\nthen
\n< sequ\u00eancia de comandos >
\nfi<\/div>\n

O comando\u00a0if\u00a0ir\u00e1 testar se a condi\u00e7\u00e3o \u00e9 verdadeira, caso sim, ent\u00e3o (then), execute a sequ\u00eancia de comandos. A estrutura de sele\u00e7\u00e3o do\u00a0if\u00a0encerra com o\u00a0fi.<\/p>\n

\u00c9 poss\u00edvel informar o que ser\u00e1 feito, caso uma condi\u00e7\u00e3o seja falsa:<\/p>\n

if [ condi\u00e7\u00e3o ]; then
\n< sequ\u00eancia de comandos >
\nelse
\n< sequ\u00eancia de comandos >
\nfi<\/div>\n

No exemplo anterior, caso a condi\u00e7\u00e3o n\u00e3o seja verdadeira, ser\u00e1 executado um outro bloco de comandos diferente do primeiro exemplo que n\u00e3o executaria nada, caso a condi\u00e7\u00e3o fosse falsa.<\/p>\n

Outro ponto a ser observado, \u00e9 que o\u00a0then\u00a0est\u00e1 na primeira linha, junto com a condi\u00e7\u00e3o. Isso \u00e9 poss\u00edvel por meio do caractere\u00a0;\u00a0que permite executar comandos em sequ\u00eancia.<\/p>\n

Algoritmo 006:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 20\/07\/2013
\n#Algoritmo que informa se o n\u00famero \u00e9 impar ou par
\n#O n\u00famero ser\u00e1 \u00edmpar se o resto da divis\u00e3o por 2 for igual a 1
\n#se for 0, o n\u00famero \u00e9 par.<\/span>echo “Digite um n\u00famero:\u00a0\u00a0”
\nread num#Efetuei o c\u00e1lculo que retorno o resto da divis\u00e3o de um n\u00famero com
\n#o operador %. Atribuir o nome a vari\u00e1vel de mod referente a modular (%)
\n#o if testa apenas vari\u00e1veis por isso fiz o c\u00e1lculo antes at\u00e9 por quest\u00e3o de organiza\u00e7\u00e3o<\/span>mod=$(($num%2))<\/p>\n

if [ $mod -eq 1 ]
\nthen
\necho “O n\u00famero $num \u00e9 impar!”
\nelse
\necho “O n\u00famero $num \u00e9 par!”
\nfi<\/p>\n<\/div>\n

Abaixo, o mesmo algoritmo, por\u00e9m, utilizando o comando\u00a0test. O resultado final ser\u00e1 o mesmo.<\/p>\n

Algoritmo 006.1:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 20\/07\/2013
\n#Algoritmo que informa se o n\u00famero \u00e9 impar ou par
\n#O n\u00famero ser\u00e1 \u00edmpar se o resto da divis\u00e3o por 2 for igual a 1
\n#se for 0, o n\u00famero \u00e9 par.<\/span>echo “Digite um n\u00famero:\u00a0\u00a0”
\nread nummod=$(($num%2))if test $mod -eq 1
\nthen
\necho “O n\u00famero $num \u00e9 impar!”
\nelse
\necho “O n\u00famero $num \u00e9 par!”
\nfi<\/p>\n<\/div>\n

Algoritmo 007:<\/p>\n

#!\/bin\/bash #Autor: k666 #Data: 20\/07\/2013 #Algoritmo que recebe tr\u00eas n\u00fameros e os escreve em ordem crescente #e informar se estes s\u00e3o iguais<\/span><\/p>\n

echo “Digite um n\u00famero: ” read num1<\/p>\n

echo “Digite o segundo n\u00famero: ” read num2<\/p>\n

echo “Digite o terceiro n\u00famero: ” read num3<\/p>\n

#Ser\u00e3o seis possibilidades poss\u00edveis para determinar qual
\n#n\u00famero \u00e9 maior que o outro. Aqui estou usando operadores relacionais
\n#-gt (maior que) e\u00a0\u00a0-a (and que \u00e9 o e l\u00f3gico)<\/span>if [ $num1 -gt $num2 -a $num1 -gt $num3 -a $num2 -gt $num3 ]
\nthen
\necho “Os n\u00fameros em ordem crescente s\u00e3o: $num3, $num2 e $num1”
\nelif [ $num2 -gt $num1 -a $num2 -gt $num3 -a $num1 -gt $num3 ]
\nthen
\necho “Os n\u00fameros em ordem crescente s\u00e3o: $num3, $num1 e $num2”
\nelif [ $num3 -gt $num1 -a $num3 -gt $num2 -a $num1 -gt $num2 ]
\nthen
\necho “Os n\u00fameros em ordem crescente s\u00e3o: $num2, $num1 e $num3”
\nelif [ $num1 -gt $num2 -a $num1 -gt $num3 -a $num3 -gt $num2 ]
\nthen
\necho “Os n\u00fameros em ordem crescente s\u00e3o: $num2, $num3 e $num1”
\nelif [ $num2 -gt $num1 -a $num2 -gt $num3 -a $num3 -gt $num1 ]
\nthen
\necho “Os n\u00fameros em ordem crescente s\u00e3o: $num1, $num3 e $num2”
\nelif [ $num3 -gt $num1 -a $num3 -gt $num2 -a $num2 -gt $num1 ]
\nthen
\necho “Os n\u00fameros em ordem crescente s\u00e3o: $num1, $num2 e $num3”
\nelse
\necho “Os n\u00fameros s\u00e3o iguais”
\nfi<\/div>\n

Algoritmo 008:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 13\/07\/2013
\n#Algoritmo que recebe tr\u00eas notas fornecidas pelo usu\u00e1rio e calcula a m\u00e9dia final
\n#e informa se o aluno foi aprovado ou reprovado com a m\u00e9dia com duas
\n#casas decimais<\/span><\/span>#Os valores das duas vari\u00e1veis abaixo est\u00e3o entre crases
\n#O comando date, sleep e clear fazem parte do sistema\u00a0GNU\/Linux<\/a>
\n#O comando date retorna a data e hora atual do sistema. Aqui
\n#foi utilizado o comando date para retornar separadamente o
\n#dia (%d), m\u00eas (%m), ano (%Y – quatro d\u00edgitos) e hora (%T – time)data=`date +%d\/%m\/%Y`
\nhora=`date +%T`echo “___________________________”<\/p>\n

echo “Data atual: $data”
\necho “Hora atual: $hora”<\/p>\n

#O comando echo sem argumentos, permite pular uma linha<\/span>
\necho
\necho -e “CALCULA M\u00c9DIA 2013”
\necho<\/p>\n

#$USER \u00e9 uma vari\u00e1vel predefinida do sistema que exibe o usu\u00e1rio atual logado no sistema<\/span><\/p>\n

echo “Bem-vindo usu\u00e1rio $USER”<\/p>\n

echo “___________________________”<\/p>\n

#Realiza uma pausa de 3 segundos, ou mais voc\u00ea \u00e9 que define,
\n#antes de executar o pr\u00f3ximo comando<\/span><\/p>\n

echo
\necho “Informe o nome do aluno: ”
\nread nome
\necho “Digite a primeira nota\u00a0\u00a0”
\nread nota1
\necho “Digite a segunda nota\u00a0\u00a0”
\nread nota2
\necho “Digite a terceira nota\u00a0\u00a0”
\nread nota3<\/p>\n

#A vari\u00e1vel media ser\u00e1 utilizada para utilizar seu conte\u00fado
\n#na estrutura de decis\u00e3o. O programa bc \u00e9 utilizado como uma
\n#calculadora matem\u00e1tica onde o valor da vari\u00e1vel \u00e9 canalizado
\n#pelo pipe ( | ) para o bc e em seguida para o comando cut.
\n#O cut recorta uma informa\u00e7\u00e3o que neste caso \u00e9 um caractere
\n#com o par\u00e2metro -c que pega apenas o primeiro para ser feito
\n#o teste condicional (if) j\u00e1 que este n\u00e3o aceita valores decimais<\/span><\/p>\n

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

#mf \u00e9 a m\u00e9dia final com o c\u00e1lculo com as duas casas decimais como
\n#proposto no algoritmo<\/span><\/p>\n

mf=$(echo “scale=2;($nota1+$nota2+$nota3)\/3” | bc -l)<\/p>\n

if [ $media -ge 7 ]; then
\necho “O aluno $nome est\u00e1 aprovado! M\u00e9dia final: $mf”
\nelse
\necho “O aluno $nome est\u00e1 reprovado. M\u00e9dia Final: $mf”
\nfi<\/p>\n<\/div>\n

Uma outra estrutura de sele\u00e7\u00e3o, \u00e9 o\u00a0case. A sua utiliza\u00e7\u00e3o \u00e9 muito \u00fatil quando trabalhamos com m\u00faltiplas escolhas, como menus. Nos exemplos abaixo, essa compreens\u00e3o ficar\u00e1 mais f\u00e1cil de entender.<\/p>\n

Estrutura do comando\u00a0case:<\/p>\n

case $var in
\npadrao1) cmd1
\ncmd2
\ncmdn ;;
\npadrao2) cmd1
\ncmd2
\ncmdn ;;
\npadraon) cmd1
\ncmd2
\ncmdn ;;
\nesac<\/div>\n

Algoritmo 009 [3]:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 13\/07\/2013
\n#Algoritmo que quando executado informa as seguintes sauda\u00e7\u00f5es: Bom dia, Boa tarde ou Boa noite.
\n#Al\u00e9m disso, informar a sauda\u00e7\u00e3o junto com o nome do usu\u00e1rio<\/span><\/span>#O comando date foi formatado de tal forma afim de pegar a penas a hora e n\u00e3o o minuto. Ex.: Suponha que seja 08:30, com o comando abaixo, s\u00f3 ser\u00e1 obtido o 08hora=$(date +%H)#Entendendo as condi\u00e7\u00f5es para a sauda\u00e7\u00e3o:
\n#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;
\n#1[2-7]\u00a0\u00a0\u00a0\u00a0 – Significa um seguido da lista de dois a sete, ou seja, esta linha pegou 12, 13, … 17;
\n#*\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0– Significa tudo que n\u00e3o casou com nenhum dos padr\u00f5es anteriores.<\/span><\/p>\n

case $hora in
\n0? | 1[01]) echo “Bom Dia $USER”
\n;;
\n1[2-7]\u00a0\u00a0\u00a0\u00a0) echo “Boa Tarde $USER”
\n;;
\n*\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 ) echo “Boa Noite $USER”
\n;;
\nesac
\nexit<\/p>\n<\/div>\n

Algoritmo 010:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 14\/01\/2014
\n#Algoritmo que disponibilize uma lista de escolha para o usu\u00e1rio poder procurar, instalar ou remover
\n#um pacote de software para o sistema Debian<\/span>echo “Escolha uma das op\u00e7\u00f5es abaixo: ”
\necho ” (1) Procurar um pacote ”
\necho ” (2) Instalar um pacote ”
\necho ” (3) Remover um pacote ”
\nread op#Logo abaixo s\u00e3o apresentados os comandos para realizar as tarefas de procurar, instalar e remover pacotes
\n#no sistema\u00a0Linux<\/a>\u00a0Debian<\/span>case $op in
\n1 ) echo -n “Informe o nome do pacote: ”
\nread pkg
\napt-cache search $pkg
\n;;
\n2 ) echo -n “Informe o nome do pacote: ”
\nread pkg
\napt-get install $pkg
\n;;
\n3 )\u00a0\u00a0echo -n “Informe o nome do pacote: ”
\nread pkg
\napt-get remove $pkg
\n;;
\n* ) echo “Op\u00e7\u00e3o Inv\u00e1lida”
\nesac
\nexit<\/p>\n<\/div>\n

Algoritmo 010.1:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 14\/01\/2014
\n#Algoritmo que disponibilize uma lista de escolha para o usu\u00e1rio poder procurar, instalar ou remover
\n#um pacote de software para o sistema Red Hat<\/span>echo “Escolha uma das op\u00e7\u00f5es abaixo: ”
\necho ” (1) Procurar um pacote ”
\necho ” (2) Instalar um pacote ”
\necho ” (3) Remover um pacote ”
\nread op#Logo abaixo s\u00e3o apresentados os comandos para realizar as tarefas de procurar, instalar e remover pacotes
\n#no sistema Linux Red Hat<\/span>case $op in
\n1 ) echo -n “Informe o nome do pacote: ”
\nread pkg
\nyum search $pkg
\n;;
\n2 ) echo -n “Informe o nome do pacote: ”
\nread pkg
\nyum install $pkg
\n;;
\n3 )\u00a0\u00a0echo -n “Informe o nome do pacote: ”
\nread pkg
\nyum remove $pkg
\n;;
\n* ) echo “Op\u00e7\u00e3o Inv\u00e1lida”
\nesac
\nexit<\/p>\n<\/div>\n<\/div>\n<\/td>\n<\/tr>\n
Estrutura de repeti\u00e7\u00e3o<\/b><\/p>\n
\n

At\u00e9 agora, criamos algoritmos que t\u00eam sua execu\u00e7\u00e3o apenas uma vez. Para uma nova execu\u00e7\u00e3o, \u00e9 preciso acionar o script. Mas, e se fosse preciso calcular uma m\u00e9dia para 50 alunos? Algo bastante trabalhoso, n\u00e3o acham?!<\/p>\n

Pensando nisso, o Shell, como em outras linguagens de programa\u00e7\u00e3o, disp\u00f5e das estruturas\u00a0while\u00a0(enquanto) e\u00a0for\u00a0(para).<\/p>\n

O\u00a0while\u00a0faz um teste no in\u00edcio do algoritmo para dar continuidade, ou n\u00e3o, \u00e0 execu\u00e7\u00e3o do c\u00f3digo. J\u00e1 no caso do\u00a0for, \u00e9 informado um valor pr\u00e9-definido de quantas vezes haver\u00e1 a repeti\u00e7\u00e3o do c\u00f3digo.<\/p>\n

Tanto na estrutura\u00a0while\u00a0quanto no\u00a0for, teremos o elemento incrementador ou contador. A fun\u00e7\u00e3o deste, \u00e9 fazer um incremento a cada itera\u00e7\u00e3o do c\u00f3digo.<\/p>\n

Este n\u00famero \u00e9 inteiro e pode ter itera\u00e7\u00f5es de 2 em 2, entre outras mediante a fun\u00e7\u00e3o do algoritmo. Este incremento assemelha-se a um ponteiro de rel\u00f3gio, onde a cada segundo \u00e9 incrementado 1, at\u00e9 completar os 60 segundos complementando um minuto, dando a vez ao pr\u00f3ximo ponteiro.<\/p>\n

Abaixo, alguns algoritmos com essas duas estruturas:<\/p>\n

Algoritmo 011:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 15\/01\/2014
\n#Algoritmo que calcula a m\u00e9dia anual de uma turma com 5 alunos<\/span><\/span>#Iniciando a vari\u00e1vel contador (con – pode ser o nome que achar melhor)
\n#e a vari\u00e1vel utilizada para acumular (acm) as m\u00e9dias para que no final
\n#seja calculado a m\u00e9dia da turma.con=1
\nacm=0#A m\u00e9dia anual ser\u00e1 armazenada na vari\u00e1vel ma<\/span><\/p>\n

#Caso for digitar um m\u00e9dia com casas decimais,
\n#utilizar o ponto ao inv\u00e9s da v\u00edrgula. Ex: 2.4<\/p>\n

while [ $con -lt 6 ]
\ndo<\/p>\n

echo -n “Digite a m\u00e9dia anual do $con\u00ba aluno: ”
\nread ma<\/p>\n

#No c\u00e1lculo da vari\u00e1vel acm estou utilizando a crase (“) para
\n#atribuir o valor do c\u00e1lculo a esta. Uma outra forma de atribui\u00e7\u00e3o<\/span><\/p>\n

acm=`echo “scale=2;$acm+$ma” | bc`
\ncon=$(($con + 1))<\/p>\n

done<\/p>\n

#Calculo da m\u00e9dia anual da turma (mat). Estou utilizando o comando
\n#scale junto com a calculadora bc para obter resultados de valor
\n#decimal especificando duas casas decimais ou quantas voc\u00ea desejar<\/span><\/p>\n

mat=$(echo “scale=2;$acm\/5” | bc -l)<\/p>\n

echo “M\u00e9dia anual da turma $mat”<\/p>\n<\/div>\n

Algoritmo 012:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 15\/01\/2014
\n#Algoritmo que executa testes de ping para um range de IPs e ao
\n#final mostra a quantidade total de hosts.<\/span>echo “—————————————”
\necho ”\u00a0\u00a0 ALGORITMO TESTAR IP\u00a0\u00a0\u00a0\u00a0 ”
\necho “—————————————”
\necho#Iniciando a vari\u00e1vel contador (con)<\/span>
\ncon=0#Aqui deve ser informado a rede. Ex.: 192.168.1 ou 192.168.2 e assim por diante<\/span>
\necho -n “Informe a rede: ”
\nread net<\/p>\n

#Informe o IP inicial do teste<\/span>
\necho -n “Informe o IP inicial: ”
\nread ipini<\/p>\n

#Informe o IP final do teste<\/span>
\necho -n “Informe o IP final: ”
\nread ipfim<\/p>\n

#C\u00e1lculo de quantos IPs receberam o teste de ping
\n#tamb\u00e9m ser\u00e1 usado para fazer uma compara\u00e7\u00e3o com o contador
\n#na estrutura de repeti\u00e7\u00e3o<\/span>
\ncalc=$(($ipfim-ipini))<\/p>\n

#O primeiro teste da estrutura while vai ser com o primeiro
\n#IP informado pelo usu\u00e1rio. Assim que o la\u00e7o come\u00e7ar a ser
\n#executado, este IP inicial ser\u00e1 somando com o contador
\n#at\u00e9 atingir o total de hosts que deve ser “pingado”<\/span>
\ntest=”$ipini”<\/p>\n

while [ $con -le $calc ]
\ndo<\/p>\n

#Aqui o comando ping executar\u00e1 um teste em cada host com a
\n#op\u00e7\u00e3o -c1 e ser\u00e1 unida a vi\u00e1vel $net e $test onde esta \u00faltima
\n#cont\u00eam o IP dentro do range a ser testado<\/span>
\necho `ping -c1 $net.$test`<\/p>\n

con=$(($con + 1))
\ntest=$(($ipini+$con))<\/p>\n

done<\/p>\n

sleep 2
\nclear
\necho “——————————–”
\necho ”\u00a0\u00a0\u00a0\u00a0FIM DOS TESTES\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 ”
\necho “——————————–”
\necho
\necho “-> Total de IPs testados: $con”<\/p>\n<\/div>\n

Algoritmo 013:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 17\/01\/2014
\n#Algoritmo que imprime a tabuada de cinco<\/span><\/span>#Aqui \u00e9 atribuir o nome a vari\u00e1vel contador de i e n\u00e3o
\n#de con como fiz em outro exemplos. Voc\u00ea pode atribuir
\n#o nome que desejar contanto que saiba a finalidade deste
\ni=0#Para este exemplo estou utilizando a tabuada de 5, por\u00e9m, caso
\n#necessite usar um outro valor, basta substituir o 5<\/span>while [ $i -le 10 ]
\ndo#Aqui vai o c\u00e1lculo da multiplica\u00e7\u00e3o. Quando i for 0, ent\u00e3o ser\u00e1
\n#multiplicado por 5 e assim sucessivamente at\u00e9 que o contador (i)
\n#seja 10 e finalize a execu\u00e7\u00e3o do la\u00e7o.<\/span>
\ncalc=$(($i*5))<\/p>\n

echo “$i X 5 = $calc”
\ni=$((i + 1))<\/p>\n

done<\/p>\n<\/div>\n

Algoritmo 014:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 17\/01\/2014
\n#Algoritmo que calcula o fatorial de um
\n#n\u00famero fornecido pelo usu\u00e1rio
\n#O fatorial \u00e9 calculado da seguinte forma:
\n#fatorial de 3: 3x2x1 = 6
\n#fatorial de 4: 4x3x2x1 = 24<\/span>echo “Digite o n\u00famero que queria saber o fatorial: ”
\nread num#Iniciando a vari\u00e1vel fatorial(fat)<\/span>
\nfat=1#O contador i inicia com o n\u00famero 1 e o loop ser\u00e1
\n#executado mediante seu valor ser menor igual ao valor
\n#da vari\u00e1vel $num<\/span><\/p>\n

for ((i=1; i <= $num ; i++))
\ndo<\/p>\n

#Aqui \u00e9 utilizada a vari\u00e1vel $fat que ser\u00e1 multiplicado
\n#pela vari\u00e1vel $i(contador) at\u00e9 o fim do loop<\/span><\/p>\n

fat=$(($fat*$i))<\/p>\n

done<\/p>\n

echo “O fatorial de $num \u00e9: $fat ”<\/p>\n<\/div>\n

Algoritmo 015:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 17\/01\/2014
\n#Algoritmo que simule uma contagem regressiva de 10 minutos, ou seja,
\n#mostre 10:00, e ent\u00e3o 9:59, 9:58, …, 9:00, 8:59 at\u00e9 0:00<\/span><\/span>#Serve apenas para exibir a contagem ser\u00e1 iniciada em 10:00
\necho “10:00”#Vari\u00e1vel min (minutos) e seg (segundos)
\n#O primeiro for ser\u00e1 utilizado para contar os minutos (min)<\/span>for ((min=9; min>=0; min–))
\ndo#O primeiro for ser\u00e1 utilizado para contar os segundos (seg)
\n#Este for significa que o minuto s\u00f3 mudar\u00e1 quando o loop do segundo
\n#chegar ao seu fim. Tanto na vari\u00e1vel min quanto seg vai decrementar
\n#(min– e seg–), ou seja, diminuir\u00e1 de 1 em 1<\/span><\/p>\n

for ((seg=59; seg>=0; seg–))
\ndo<\/p>\n

#Perceba que entre a vari\u00e1vel $min e $seg tem : (dois pontos) para
\n#fazer a separa\u00e7\u00e3o de minutos e segundos<\/span><\/p>\n

echo “$min:$seg”
\ndone
\ndone<\/p>\n<\/div>\n<\/div>\n<\/td>\n<\/tr>\n

Fun\u00e7\u00f5es<\/b><\/p>\n
\n

Conjunto de comandos agrupados em um bloco, que recebe um nome e atrav\u00e9s deste, pode ser ativado.<\/p>\n

Por que utilizar fun\u00e7\u00f5es?<\/p>\n

Vetor (array)<\/b><\/p>\n
\n

As vari\u00e1veis de ambiente podem ser com\u00a0arrays, possibilitando a inser\u00e7\u00e3o de v\u00e1rios valores dentro de uma mesma vari\u00e1vel. Outro nome dado ao\u00a0array, em l\u00f3gica de programa\u00e7\u00e3o, \u00e9 vetor.<\/p>\n

Cada valor \u00e9 referenciado em um \u00edndice representando uma posi\u00e7\u00e3o reservada na mem\u00f3ria.<\/p>\n

O \u00edndice de um vetor, tamb\u00e9m \u00e9 chamado de chave. \u00c9 atrav\u00e9s dele que temos acesso a determinadas posi\u00e7\u00f5es do vetor para realizarmos as tarefas de atribui\u00e7\u00e3o e consulta.<\/p>\n

Estrutura:<\/p>\n

variavel=(valor1 valor2 valor3 …)<\/div>\n

Para acessar um elemento no vetor (array), use seu n\u00famero de \u00edndice (entre colchetes), contando a partir de zero todo conjunto entre chaves.<\/p>\n

Ex.: acessando o valor que est\u00e1 na posi\u00e7\u00e3o zero do vetor:<\/p>\n

echo ${variavel[0]}<\/div>\n

Para mostrar todo o conte\u00fado do array, use o asterisco no lugar no \u00edndice:<\/p>\n

echo ${variavel[*]}<\/div>\n

Algoritmo 018:<\/p>\n

#!\/bin\/bash
\n#Autor: k666
\n#Data: 17\/01\/2014
\n#Algoritmo que executa teste de conectividade com um lista de hosts<\/span><\/span>#Declarando a vari\u00e1vel que ir\u00e1 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
\n#host armazenado\u00a0\u00a0no vetor<\/span><\/p>\n

ping -c1 ${hosts[0]}<\/p>\n

#Ap\u00f3s tr\u00eas segundos, a tela ser\u00e1 limpa e testado o pr\u00f3ximo site<\/span><\/p>\n

sleep 3
\nclear<\/p>\n

ping -c1 ${hosts[1]}<\/p>\n

sleep 3
\nclear<\/p>\n

ping -c1 ${hosts[2]}<\/p>\n<\/div>\n

Assim, finalizo este artigo. Procure baixar lista de exerc\u00edcios de algoritmos e tente aplic\u00e1-los em Shell Script.<\/p>\n

Autoria: Wagner Souza<\/p>\n

Bons estudos!<\/p>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n","protected":false},"excerpt":{"rendered":"

Introdu\u00e7\u00e3o \/ O Shell Script Introdu\u00e7\u00e3o O estudo de algoritmos, \u00e9 de fundamental import\u00e2ncia para o desenvolvimento da l\u00f3gica de programa\u00e7\u00e3o e, consequentemente, o aprendizado e dom\u00ednio de uma linguagem de programa\u00e7\u00e3o. Um algoritmo \u00e9 uma sequ\u00eancia finita de instru\u00e7\u00f5es bem definidas e n\u00e3o amb\u00edguas, ou seja, um conjunto de instru\u00e7\u00f5es executadas passo a passo, […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[42,51,501,548],"tags":[654,655,502],"class_list":["post-929","post","type-post","status-publish","format-standard","hentry","category-leitura-recomendada","category-linux-linuxrs","category-shell-script","category-ubuntu-2","tag-algoritmos","tag-em-shell","tag-script"],"_links":{"self":[{"href":"https:\/\/blog.clusterweb.com.br\/index.php?rest_route=\/wp\/v2\/posts\/929","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.clusterweb.com.br\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.clusterweb.com.br\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.clusterweb.com.br\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.clusterweb.com.br\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=929"}],"version-history":[{"count":3,"href":"https:\/\/blog.clusterweb.com.br\/index.php?rest_route=\/wp\/v2\/posts\/929\/revisions"}],"predecessor-version":[{"id":2367,"href":"https:\/\/blog.clusterweb.com.br\/index.php?rest_route=\/wp\/v2\/posts\/929\/revisions\/2367"}],"wp:attachment":[{"href":"https:\/\/blog.clusterweb.com.br\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=929"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.clusterweb.com.br\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=929"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.clusterweb.com.br\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=929"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}