Shell Script

Diego R. Frank, Leonardo Seibt

FIT - Faculdades de Informática de Taquara

Fundação Educacional Encosta Inferior do Nordeste
Av. Oscar Martins Rangel, 4500 - Taquara - RS - Brasil
difrank@terra.com.br, lseibt@terra.com.br
Resumo. Este artigo tem como finalidade introduzir o leitor, de forma básica,
no mundo do shell script. Apresenta definições a respeito do que é necessário
saber para estar apto a criar seus próprios shell scripts, ou seja, pode ser
visto como um mini-tutorial do mesmo. Não é a finalidade deste artigo
apresentar de forma completa o conceito de shell scripts, pois é um campo
muito vasto a percorrer. Para que se aprofunde no assunto deve-se conhecer
a fundo os comandos e possibilidades do sistema operacional.

1. Introdução
Quem usa linux conhece bem o interpretador de comandos sh, ou variações como o
bash (uma abreviação de Bourne-Again Shell – um dos mais usados atualmente). Esses
interpretadores são programas feitos para intermediar o usuário e seu sistema. O usuário
digita um comando e o interpretador o executa no sistema. Pode-se dizer que o shell é o
intermediário entre o usuário e o kernel. O que muita gente não sabe é que estes
interpretadores de comandos têm uma "poderosa" linguagem de script embutida nelas.
Diversas pessoas utilizam-se desta linguagem para facilitar a realização de inúmeras
tarefas administrativas no linux, ou até mesmo criar seus próprios programinhas.
Além de executar comandos do sistema, o shell também tem seus próprios
comandos, como IF, FOR e WHILE, e também possui variáveis e funções. Tudo isso
para tornar um pouco mais "espertas" e flexíveis essas chamadas de comandos feitas
pelo usuário. Como estas são as características de uma linguagem de programação, o
shell é uma ferramenta muito poderosa para desenvolver scripts e programinhas rápidos
para automatizar tarefas do dia-a-dia. Você poderá criar scripts para automatizar as
tarefas diárias de um servidor, para efetuar backup automático regularmente, procurar
textos, criar formatações, e muito mais.
Para os que vêm do mundo MSDOS, pense no shell scripts como um batch (dos
arquivos .BAT). O shell scripts é como um arquivo batch, porém muito melhor.
Uma das vantagens destes shell scripts é que eles não precisam ser compilados,
ou seja, basta apenas criar um arquivo texto qualquer, e inserir comandos à ele.

2. Passos para criação de um shell script

– Usa-se um editor de textos qualquer para criar o arquivo que conterá os diversos
comandos a serem executados. Para dar à este arquivo a definição de "shell script",
teremos que incluir uma linha no início do arquivo (#!/bin/bash).
– Depois de gravado o arquivo deve-se alterar seu atributos para que seja permitida sua
execução. Para isso usa-se o comando chmod como segue:
$ chmod +x nome_do_arquivo_de_script
– Após concluídos os passos anteriores o shell script está pronto para execução,
bastando para isso chamar o nome do script usando uma das formas que seguem:
bash nome_do_arquivo_de_script
sh nome_do_arquivo_de_script
./nome_do_arquivo_de_script

Exemplo de um programa shell script:

#!/bin/bash
echo 'Olá mundo!!!'

A primeira linha indica que todas as outras linhas abaixo deverão ser executadas
pelo bash (que se localiza em /bin/bash), e a segunda linha imprimirá na tela a frase
"Olá mundo!!!", utilizando o comando echo, que serve justamente para isto. Como se
pode ver, todos os comandos que são digitados diretamente na linha de comando,
poderão ser colocados no arquivo de shell script, criando uma série de comandos, e é
essa combinação de comandos que forma o chamado shell script.

3. Conceito de variáveis em shell script

Variáveis são estruturas que armazenam dados, uma espécie de atalho. O bash
reconhece uma variável quando ela começa com $, ou seja, a diferença entre 'palavra' e
'$palavra' é que a primeira é uma palavra qualquer, e a outra é uma variável. Para definir
uma variável, utiliza-se a seguinte sintaxe:
variavel="valor"

O 'valor' será atribuído a 'variável '. Valor pode ser uma frase, números, e até
outras variáveis e comandos. O valor pode ser expressado entre as aspas (""), apóstrofos
('') ou crases (``). As aspas vão interpretar as variáveis que estiverem dentro do valor, os
apóstrofos lerão o valor literalmente, sem interpretar nada, e as crases vão interpretar
um comando e retornar a sua saída para a variável. Como segue:
$ variavel="Eu estou logado como usuário $user"
$ echo $variavel
Eu estou logado como usuário cla3

$ variavel='Eu estou logado como usuário $user'

$ echo $variavel
Eu estou logado como usuário $user

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

$ echo $variavel
Meu diretório atual é o /home/cla

Para criar um script em que o usuário deva interagir com ele, é possível que se
queira que o próprio usuário defina uma variável, e para isso usa-se o comando read,
que dará uma pausa no script e ficarará esperando o usuário digitar algum valor e teclar
enter. Exemplo:
echo "Entre com o valor para a variável: "; read variavel

Se o usuário digitar 'O dia está lindo!')

echo $variavel
O dia está lindo!
 Existem diversas variáveis já definidas, as quais são usadas pelo sistema
operacional. Para visualizar estas variáveis digita-se o comando set no prompt de
comando. Algumas variáveis de sistema do linux:

Variável de Sistema Descrição

BASH=/bin/bash Nome do shell
BASH_VERSION='2.05b.0(1)-release' Versão do shell
COLUMNS=155 Número de colunas da tela
HOME=/home/leonardo Diretório home do usuário
LINES=51 Número de linhas da tela
LOGNAME=leonardo Nome do usuário logado
OSTYPE=linux-gnu Tipo do sistema operacional
PATH=/usr/bin:/bin:/usr/bin:/usr/local/bin Caminhos do PATH do usuário
PS1='[\u@\h \W]\$ ' Definição do prompt do shell
PWD=/home/leonardo Diretório corrente
SHELL=/bin/bash Nome do shell
USER=leonardo Nome do usuário logado

4. Construções condicionais
Construções condicionais ou de decisão são declarações que fazem com que
determinados códigos sejam executados dependendo de uma decisão. Estas estruturas
são muito importantes pois permitem que sejam tomadas algumas decisões durante a
execução de um script.

4.1. Expressões
As expressões de teste são comparáveis a expressões de comparação de outras
linguagens de programação. Estas expressões executam testes matemáticos, booleanos e
outros testes que indicam um estado de verdadeiro ou falso, dependendo da saída.
Para tipos diferentes de dados, existem operadores diferentes a serem utilizados,
que podem ser dos seguintes tipos:

4.1.1. Expressões inteiras

Expressões inteiras são aquelas que utilizam os operadores disponíveis para realizar
testes com dados do tipo inteiro, isto é, com números e variáveis numéricas.

Expressão Significado Verdadeiro se

X -eq Y X equal Y X=Y
X -ne Y X not equal Y X != Y
X -ge Y X greater or equal than Y X >= Y
X -gt Y X greater than Y X>Y
X -le Y X less or equal than Y X <= Y
X -lt Y X less than Y X<Y
4.1.2. Expressões de strings
As expressões de strings podem fazer testes para determinar se as strings são iguais,
diferentes, de tamanho igual a zero ou valores nulos (vazias ou não inicializadas). O
bash faz distinção entre strings de tamanho zero e vazias.

Expressão Significado Verdadeiro se

String String não é nula
-z String Zero lenght String tem tamanho zero
-n String No zero lenght Tamanho diferente de zero
String1 = String2 String1 igual a String2
String1 != String2 String1 diferente de String2

4.1.3. Expressões de arquivos

As expressões que testam arquivos podem verificar algumas informções sobre um
determinado arquivo ou compará-las com um segundo arquivo. A seguir apresentam-se
os operadores mais comuns usados nos testes de arquivos:

Expressão Verdadeiro se
-e arquivo Arquivo existe
-f arquivo Arquivo existe e é um arquivo normal
-r arquivo Arquivo pode ser lido
-w arquivo Arquivo pode ser gravado
-d arquivo Arquivo é um diretório
Arquivo1 -nt Arquivo2 Arquivo1 é mais novo que Arquivo2
Arquivo1 -ot Arquivo2 Arquivo1 é mais velho do que Arquivo2

4.1.4. Expressões booleanas

As expressões de teste suportam os operadores booleanos AND, OR e NOT. A tabela a
seguir apresenta estes opradores.

Expressão Significado
!expressão NOT expressão
Valor1 & Valor2 Valor1 AND Valor2
Expressão1 -a Expressão2 Expressão1 AND Expressão2
Valor1 || Valor2 Valor1 OR Valor2
Expressão1 -o Expressão2 Expressão1 OR Expressão2

4.2. Declaração IF
A declaração if executa determinadas linhas de comando, dependendo de uma
expressão condicional ser verdadeira ou falsa. A sintaxe da declaração if é mostrada a
seguir:
 if comandos_de_teste; then
comandos_consequentes;
[elif mais_comandos_de_teste; then
mais_comandos_consequentes; ]
[else consequentes_alternativos; ]
fi

4.3. Declaração CASE

Outro comando de estrutura condicional muito utilizado é o case. Sua sintaxe básica
está representada a seguir.
case palavra in
padrão [ | padrão ] ... ) comandos;;
esac

4.4. Declaração WHILE

A declaração while é usada para repetir comandos até que uma dada condição seja
avaliada como falsa. É usada quando não é possível prever ou calcular quantas
repetições o loop deve executar. A sintaxe é apresentada a seguir:
while expressão
do
comandos
done

4.5. Declaração FOR

A declaração for é utilizada basicamente para repetir comandos. Isto quer dizer que este
comando pode ser utilizado para percorrer listas de palavras e para processar cada
palavra em sequência. Isto é útil porque o controle de listas gera muito trabalho. Os
argumentos de linha de comando são um bom exemplo de listas de strings. A seguir
pode-se verificar a estrutura do comando for.
for name [ in word; ]
do
list;
done

5. Funções bash
O shell permite criar funções para substituir sequências de comandos que são
frequentemente utilizadas. Essas funções geralmente recebem um argumento, ou mais,
para que trabalhem esses dados.
A idéia é que o código em uma função deve ser criado de uma maneira que seja
útil em mais de uma circunstância. Do ponto de vista do bash, uma função de shell é
essencialmente um script dentro de outro script. As funções podem implementar as
mesmas rotinas que os scripts, com a vantagem adicional de que as funções
apropriadamente programadas podem ser reutilizadas em outros scripts.
Para declarar uma função, deve-se utilizar a palavra-chave function. As funções,
assim como os scripts, usam argumentos e esses são tratados da mesma forma no
código. Todo o código contido em uma função aparece entre chaves. A sintaxe básica
para declaração de uma função é apresentada a seguir.
function nome_da_funcao ()
{
comandos
}

6. Exemplo de programa em shell script

#!/bin/bash fi
# Exemplo Final de Script Shell done
Principal() { elif [ $var = "m" ]; then
echo "Exemplo Final sobre o uso de scripts shell" echo -n "Que diretório? "
echo "------------------------------------------" read dir
echo "Opções:" for x in `/bin/ls` $dir; do
echo y=`echo $x | tr '[:upper:]' '[:lower:]'`
echo "1. Trasformar nomes de arquivos" if [ ! -e $y ]; then
echo "2. Adicionar um usuário no sistema" mv $x $y
echo "3. Deletar um usuário no sistema" fi
echo "4. Fazer backup dos arquivos do /etc" done
echo "5. Sair do exemplo" fi
echo }
echo -n "Qual a opção desejada? " Adicionar() {
read opcao clear
case $opcao in echo -n "Qual o nome do usuário a se adicionar? "
1) Transformar ;; read nome
2) Adicionar ;; adduser nome
3) Deletar ;; Principal
4) Backup ;; }
5) exit ;; Deletar() {
*) "Opção desconhecida." ; echo ; Principal ;; clear
esac echo -n "Qual o nome do usuário a deletar? "
} read nome
Transformar() { userdel nome
echo -n "Para Maiúsculo ou minúsculo? [M/m] " Principal
read var }
if [ $var = "M" ]; then Backup() {
echo -n "Que diretório? " for x in `/bin/ls` /etc; do
read dir cp -R /etc/$x /etc/$x.bck
for x in `/bin/ls` $dir; do mv /etc/$x.bck /usr/backup
y=`echo $x | tr '[:lower:]' '[:upper:]'` done
if [ ! -e $y ]; then }
mv $x $y Principal
7. O programa Dialog – Caixas de diálogo
O Dialog original é antigo e não é mais desenvolvido, foi até a versão 0.3. Outros
programadores o adotaram e continuaram o desenvolvimento até a versão 0.7. Depois
surgiu o "cdialog" (ComeOn Dialog), como um Dialog melhorado, baseado no original.
O cdialog continuou evoluindo e acabou se tornando o oficial, sendo renomeado para
"dialog".
O Dialog é um programa para console (modo texto) que desenha caixas de
diálogo ("dialog boxes") na tela, similares as do modo gráfico, com botões, entradas
para texto e menu. Essas caixas são utilizadas para compor interfaces amigáveis com o
usuário, para que ele responda perguntas ou escolha opções.
O Dialog é um executável e recebe todos os parâmetros via linha de comando,
então ele geralmente é usado dentro de um Shell Script. Serve para fazer programas
interativos, que o usuário precisa operar durante sua execução. Tarefas comuns feitas
com o Dialog são escolher uma opção em um menu, escolher um arquivo, uma data, e
digitar frases ou senhas.
Com o Dialog é possível fazer programas em shell que se "parecem" com
programas gráficos, onde o usuário vê apenas telas e navega entre elas apertando os
botões de "OK" e "CANCELAR". Um exemplo clássico desse tipo de interface são os
programas de instalação de software.
Utilizando este conceito de telas, é possível "amarrar" o usuário ao programa,
lhe apresentando as opções disponíveis, sem que ele precise ter acesso direto à linha de
comando. Útil para logins restritos e para ajudar iniciantes.

7.1. Parâmetros da linha de comandos

No Dialog, é obrigatório passar o texto e o tamanho da caixa, sempre. Com isso, a cada
chamada do programa, devem haver pelo menos 4 opções na linha de comando. O
formato genérico de chamada é:
dialog --tipo-da-caixa '<texto>' <altura> <largura> onde:
Texto - é a palavra ou frase que aparece no início da caixa, logo após a primeira
linha (borda superior). Passe uma string vazia '' caso não deseje texto. Caso o texto seja
maior que o tamanho da janela, ele será ajustado automaticamente, quebrando a linha.
Para colocar as quebras de linhas manualmente, insira o padrão '\n' (barra-ene) onde
desejar as quebras. Exemplo: 'Primeira linha.\nSegunda.'
Altura - é o número de linhas que serão utilizadas para desenhar a caixa,
inclusive a primeira e a última que fazem as bordas superior e inferior. Se informado o
número zero, o Dialog ajusta automaticamente a altura da caixa para caber o conteúdo.
Largura - é o número de colunas que serão utilizadas para desenhar a caixa,
inclusive a primeira e a última que fazem as bordas esquerda e direita. Se informado o
número zero, o Dialog ajusta automaticamente a largura da caixa para caber o conteúdo.
Na prática, é melhor deixar que o Dialog quebre o texto e ajuste o tamanho das
caixas automaticamente. Então nos exemplos desse documento não haverá quebras de
linha manuais (\n) e os tamanhos serão sempre especificados como "0 0" (zero zero).
7.2. Tipos de caixas de diálogo

Tipo O que o usuário vê

calendar Vê um calendário e escolhe uma data
checklist Vê uma lista de opções e escolhe várias
fselect Digita ou escolhe um arquivo
gauge Vê uma barra de progresso (porcentagem)
infobox Vê uma mensagem, sem botões
inputbox Digita um texto qualquer
menu Vê um menu e escolhe um item
msgbox Vê uma mensagem e clica o botão OK
passwordbox Digita uma senha
radiolist Vê uma lista de opções e escolhe uma
tailbox Vê a saída do comando tail -f
tailboxbg Vê a saída do comando tail -f (em segundo plano)
textbox Vê o conteúdo de um arquivo
timebox Escolhe um horário
yesno Vê uma pergunta e clica o botão YES ou NO

8. Referências
Treinamento, Equipe Conectiva (2001) “Administração de Sistemas Linux”, Primeira
Edição, Agosto.
Jargas, Aurélio Marinho (2003) “Dialog –tudo”, versão 5,
http://aurelio.net/shell/dialog/, Agosto.
Gite, Vivek G. (2002) “Linux Shell Scripting Tutorial (LSST) v1.05r3”,
http://www.freeos.com/guides/lsst/index.html, Abril.
Cisneiros, Hugo, (2004) “Programando em shell-script”,
http://www.devin.com.br/eitch/shell_script/, Agosto.