Licenciatura em

Informática de
Gestão/ TeSP de
Tecnologias e
S i s t e ma s O p e r a t i v o s
Programação de
Sistemas de
Informação

Atividade Prática 3 – Programação em BASH

Tópicos abordados:
– Programação em BASH
– Exercícios

1 Introdução

A bash é uma linguagem de script empregue na construção de pequenas

aplicações (shell scripts) de auxílio à administração de sistemas Linux/Unix. Os shell
scripts são normalmente utilizados para automatizar tarefas diárias tais como realização
de backups, gestão de contas, remoção automática de determinado tipo de recursos,
pesquisa de informação, etc.
Mais do que uma linguagem script, a bash é um interpretador de comandos.
Efetua a leitura de comandos introduzidos na linha de comando e interpreta-os, não
sendo necessário qualquer tipo de compilação prévia. Os interpretadores de comandos
são normalmente utilizados para efetuar a interface entre o utilizador e o sistema
operativo. No caso dos sistemas Linux/Unix, o interpretador de comandos afeto a cada
utilizador encontra-se no ficheiro /etc/passwd. Quando o utilizador introduz o nome
de uma aplicação (com permissões para execução), o interpretador de comandos afeto
ao utilizador verifica se a aplicação é um shell script ou um executável nativo. O
interpretador considera que está perante um shell script caso a primeira linha do ficheiro
contenha a seguinte estrutura:

#!<localização do interpretador de comandos>

Sistemas Operativos – Atividade Prática 3 1

 Esta linha, apesar de parecer um comentário, indica ao interpretador de comandos,
qual a aplicação que irá interpretar as linhas seguintes. No caso de um script em bash a
primeira linha seria:

#!/bin/bash

1.1 Exemplo: “Olá mundo!”

Este é o exemplo de um shell script que mostra no ecrã: "Olá mundo!"

#!/bin/bash
echo “Olá mundo!”
Figura 1 – Exemplo “Olá mundo!”

A primeira linha indica ao interpretador corrente que as restantes linhas deverão

ser interpretadas pela aplicação /bin/bash (shell bash). A segunda linha imprimirá no
ecrã a frase "Olá mundo!", utilizando o comando echo. Como pode constatar, todos os
comandos introduzidos diretamente na linha de comando podem ser incluídos num shell
script.

1.2 Atribuição de permissões de execução

Para que o ficheiro possa ser executado é necessário atribuir permissões de

execução, usando para o efeito o comando chmod.
so@linux:~ > chmod +x <nome_ficheiro_do_shell_script>
Figura 2 – Atribuição de permissões de execução

Neste momento o ficheiro já pode ser executado, introduzindo o seu nome na

linha de comando.
so@linux:~ > ./<nome_ficheiro_do_shell_script>
Figura 3 – Executar o shell script

2 Interpretador bash

A bash possui um conjunto de elementos típicos de uma linguagem de

programação (variáveis, estruturas de controlo e de repetição, funções, etc). As secções
seguintes apresentam os principais elementos que poderá utilizar na elaboração um shell
script.

Sistemas Operativos – Atividade Prática 3 2

 2.1 Comentários

# Isto é um comentário
echo “olá” # Isto também é um comentário
Figura 4 – Comentários

Com exceção da primeira linha (que indica qual o interpretador do shell script),
todos os caracteres à direita do carater # são considerados comentários.

2.2 Separador de comandos

É possível executar vários comandos numa linha desde que estejam separados
pelo carater ;.
echo “olá”; echo “aqui”
Figura 5 – Separador de comandos

2.3 Variáveis

A declaração de variáveis possui a seguinte sintaxe:

<nome_variável>=<valor>

Não são permitidos espaços, nem antes, nem depois do caracter =. Apenas
caracteres alfanuméricos podem ser utilizados como identificadores válidos de
variáveis. Os valores do tipo string que contenham espaços devem ser especificados
entre “”.

#!/bin/bash
var1=123
var2=ola
var_3=”olá mundo”
Figura 6 – Declaração explícita de variáveis

As variáveis são implicitamente declaradas e preenchidas durante uma operação

de leitura (read) ou quando se itera um ciclo.
#!/bin/bash
read var4
for var5 in 1 2 3
do
echo $var5
done
Figura 7 – Declaração de implícita de variáveis

Sistemas Operativos – Atividade Prática 3 3

 Para aceder ao valor de uma variável, utiliza-se o nome da variável precedida do
caracter $.
#!/bin/bash
var1=”olá”
var2=$var1 # Atribui à variável 2 o valor da variável 1
echo var1 # Escreve a palavra var1 e não “olá” (falta o $)
echo $var1 # Escreve o valor da variável var1, ou seja, “olá”
echo ${var1} # Faz o mesmo que a linha anterior
echo “Teste $var1” # Escreve “Teste olá”
Figura 8 – Acesso ao valor de uma variável

Às variáveis de bash podem ser atribuídos números, caracteres, cadeias de

caracteres, outras variáveis e até comandos. Devem-se usar as aspas para indicar que o
conteúdo deverá ser interpretado, por exemplo, quando se incluem outras variáveis.

#!/bin/bash
frase="O meu nome no sistema é $USER"
# A linha seguinte irá escrever para o ecrã a string:
# O meu nome no sistema é so_xyy
echo $frase
Figura 9 – Declaração de variável interpretada

Por outro lado deve-se usar plicas para atribuir literalmente um valor à variável,
como se mostra a seguir:
#!/bin/bash
frase=’O meu nome no sistema é $USER’
# A linha seguinte irá escrever para o ecrã a string:
# O meu nome no sistema é $USER
echo $frase
Figura 10 – Declaração de variável literal

No caso de necessitar de incluir um comando na atribuição de uma variável, deve

envolver esse mesmo comando com acentos grave.
#!/bin/bash
pasta_actual=`pwd`
listagem="Listagem da pasta actual: `ls -la`"
echo $pasta_actual
echo $listagem
Figura 11 – Atribuição do resultado de um comando a uma variável

Sistemas Operativos – Atividade Prática 3 4

 2.4 Operadores

2.4.1 Aritméticos
+- Soma
-- Subtração
*- Multiplicação
/- Divisão
** - Exponencial
% - Módulo
Para avaliar uma expressão aritmética utiliza-se a função let. De seguida são
mostrados alguns exemplos.
#!/bin/bash
a=123
let a=$a+1
let “a=$a+1” # faz o mesmo que a linha anterior
let “a = $a + 1 ” # faz o mesmo que a linha anterior
let b=2**4
echo $a # a = 126
echo $b # b = 16
Figura 12 – Avaliação de expressões aritméticas

2.4.2 Lógicos
&& - E
|| - Ou

2.4.3 Comparação inteira

-eq - Igual
-ne - Diferente
-gt - Maior que
-ge - Maior ou igual a
-lt - Menor que
-le - Menor ou igual a

2.4.4 Comparação de strings

=- Igual
!= - Diferente
<- Menor que

Sistemas Operativos – Atividade Prática 3 5

 >- Maior que
-z - String nula, ou seja, tamanho = 0
-n - String não é nula

2.4.5 Ficheiros
-e - Devolve verdade caso o ficheiro exista
-f - Devolve verdade se o ficheiro é regular e não uma diretoria
-s - Devolve verdade se o ficheiro existe e o tamanho é maior que 0
-d - Devolve verdade caso se trate de uma diretoria
... (consultar a página de manual para obter a lista dos restantes operadores)

2.5 Estruturas de decisão

2.5.1 If
if [ condição ]
then
comandos no caso da condição1 ser verdadeira
elif [ condição2 ]
then
comandos no caso da condição2 ser verdadeira
then
elif [ condição3 ]
then
comandos no caso da condição3 ser verdadeira
else
comandos no caso de nenhuma das condições ser verdadeira
fi
Nota: a condição do if deverá ser precedida e seguida de um espaço.

2.5.2 Exemplos
#!/bin/bash
if [ 1 –eq 2 ]
then
echo 'As variáveis são iguais.'
else
echo 'As variáveis são diferentes.'
fi
Figura 13 – Estrutura if

Sistemas Operativos – Atividade Prática 3 6

 No exemplo anterior foi usado o operador (nativo da bash) –eq que compara o
valor de duas constantes. Como as constantes são diferentes o programa mostra a
mensagem “As variáveis são diferentes.”

Outra forma de utilizar a estrutura if é indicada pela figura seguinte:

#!/bin/bash
if [ 1 –eq 2 ]; then
echo 'As variáveis são iguais.'
else
echo 'As variáveis são diferentes.'
fi
Figura 14 – Outra forma para a estrutura if

Note-se que no exemplo anterior utilizou-se o carater ; para terminar

prematuramente a condição do if.

2.5.3 Case
A estrutura case é similar à estrutura switch da linguagem C.

case variável in
const1) comando1; comando2 ;;
const2) comando3; comando4 ;;
*) comando_default ;;
esac

2.5.4 Exemplo
#!/bin/bash
echo "Digite um comando (who, list, ou cal)"
read comando
case "$comando" in
who)
echo "A executar who..."
who
;;
list)
echo "A executar ls..."
ls
;;
cal)
echo "A executar cal..."
cal
;;
*)
echo "Comando inválido. As escolhas possíveis
são:who,list,ou cal"
;;
esac
Figura 15 – Estrutura case

Sistemas Operativos – Atividade Prática 3 7

 Para terminar uma opção da estrutura case deve-se utiliza o caracter ; duas vezes,
ou seja, ;;.
case "$variavel" in
abc) echo "$variavel = abc" ;;
xyz) echo "$variavel = xyz" ;;
esac
Figura 16 – Terminação de cada opção de uma estrutura case

2.6 Estruturas de repetição

2.6.1 For
for variavel in lista_valores
do
comando1
comando2
done

2.6.2 Exemplos
#!/bin/bash
lista=`ls –a`
for i in $lista
do
echo $i
done
Figura 17 – Demonstração da estrutura for

#!/bin/bash
for i in *.c; do
cp $i ~/backup/
done
Figura 18 – Demonstração da estrutura for

No exemplo anterior, os caracteres “*.c” significam que é para todos os ficheiros

com a extensão “.c” na directoria actual. No interior do ciclo, para cada ficheiro é
realizada uma cópia para a directoria backup.

2.6.3 While
while [ condição ]
do
commandos;
done

Sistemas Operativos – Atividade Prática 3 8

2.6.4 Exemplos
#!/bin/bash
var=1
while [ $var -eq 1 ]
do
ls
var=0
done
Figura 19 – Demonstração da estrutura while

#!/bin/bash
var=3
while [ $var -ge 1 ]; do
ls
let "var=$var-1"
done
Figura 20 – Demonstração da estrutura while

3 Utilizar várias scripts numa só

Se precisarmos executar num shell script outro script externo para que esta faça
alguma função, sem que ter de reescrever todo o código, apenas necessitamos de incluir
o seguinte comando no shell script:

source <nome_ficheiro_bash_shell_script>

Desta forma será executada o shell script "nome_ficheiro_bash_shell_script"

durante a execução do script principal. Caso se pretenda utilizar uma outra shell, é
necessário substituir o "." pelo executável da shell. Por exemplo:

sh <path_ficheiro_script2> # será executado com a shell sh

tcsh <path_ficheiro_script3> # será executado com a shell tcsh

4 Variáveis especiais

4.1 Parâmetros posicionais

São chamados parâmetros posicionais aos argumentos que são passados a um

shell script via linha de comandos:
$0 Nome do script que está ser executada
$1-$9 Parâmetros passados na linha de comando
$# Número de parâmetros passados

Sistemas Operativos – Atividade Prática 3 9

 $? Valor de retorno do último comando ou de toda o shell script.
(Exemplo: o comando "exit 1" retorna o valor 1)
$@ Lista com todos os parâmetros passados na linha de comandos

Tabela 1 – Parâmetros posicionais

É possível encontrar muitas variáveis, já predefinidas, na página do manual do

bash (comando "man bash", no tópico Shell Variables).
#!/bin/bash
#chamar a função da seguinte forma: ./nome_script 1 2 3
echo "Numero de parâmetros: $#"
echo "$1"
echo "$2"
echo "$3"
Figura 21 – Utilização de parâmetros posicionais

A bash disponibiliza a função shift caso se pretenda percorrer a lista de

parâmetros iterativamente. Esta função elimina o parâmetro $1, deslocando os restantes
parâmetros uma posição para a esquerda, i.e., o valor do parâmetro $2 passa para o
parâmetro $1, o $3 para $2 e assim sucessivamente.
#!/bin/bash
# chamar a função da seguinte forma: ./nome_script 1 2 3 4 5
echo "$@" # 1 2 3 4 5
shift
echo "$@" # 2 3 4 5
shift
echo "$@" # 3 4 5
# cada "shift" perde o parâmetro $1.
# "$@" contém os parâmetros restantes.
Figura 22 – Utilização da função shift

#!/bin/bash
# chamar a função da seguinte forma: ./nome_script 1 2 3 4 5
echo "Numero de parametros: $#"
cont=0
while [ $# -ne 0 ]; do
echo $1
shift
done
Figura 23 – Utilização da função shift

Sistemas Operativos – Atividade Prática 3 10

 5 Funções

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

Nome_funcao() {
comando1
comando2
...
}

A função funciona como um simples comando. Ao executar a função em qualquer

lugar do shell script, o comando 1, o comando 2 e restantes (…) serão executados. Para
chamar uma função basta utilizar o nome da função, ou seja:
adicionar() {
comando1
comando2
...
}

echo 'Utilização da função adicionar...'

adicionar
Figura 24 – Chamada de uma função

Exemplo da utilização de uma função:

#!/bin/bash
funcao_teste ()
{
echo "Esta é a funcao_teste."
echo "Função chamada com sucesso."
}
# Agora, já se pode chamar a função.
funcao_teste
Figura 25 – Utilização de uma função

5.1 Passagem de parâmetros para uma função

Tal como é possível passar parâmetros para um shell script também é possível
passar parâmetros para uma função. O modo como se obtêm esses parâmetros e o modo
como são passados é idêntico. O exemplo seguinte mostra as várias fases do uso de
parâmetros: a camada da função com a passagem dos parâmetros, a obtenção dos

Sistemas Operativos – Atividade Prática 3 11

parâmetros dentro da função, a devolução de um resultado depois de efectuados os
cálculos necessários dentro da função e por fim, a obtenção desse resultado.
#!/bin/bash
funcao_soma (){
let "total=$1+$2"
return $total
}
a=1
b=2
funcao_soma $a $b
echo "Resultado= $?"
Figura 26 – Chamada de uma função com parâmetros

6 Exemplo final

#!/bin/bash

Principal()
{
opcao=0
while [ $opcao -ne 9 ]
do
echo ""
echo ""
echo ""
echo "Exemplo em bash shell"
echo "------------------------------------------"
echo "Opcoes:"
echo
echo "1. Backup dos ficheiros .c"
echo "2. Listagem da pasta ~/backup"
echo "9. Sair"
echo
echo -n "Qual a opcao desejada? "
read opcao
case $opcao in
1) Backup ;;
2) Listar ;;
9) exit ;;
*) "Opcao desconhecida." ; echo ;;
esac
done
}

Backup()
{
if [ ! -d ~/backup/ ]
then
mkdir ~/backup
echo "Directoria de backup criada"
fi

echo "Backup em execucao..."

cont=0
for i in *.c
do

Sistemas Operativos – Atividade Prática 3 12

 echo "Ficheiro: $i"
cp $i ~/backup/
let "cont=$cont+1"
done
echo "."
echo "$cont ficheiro(s) copiado(s)."
}

Listar()
{
if [ -d ~/backup/ ]
then
echo '... a listar directoria: ~/backup'
lista=`ls -a ~backup/*.c`
for i in $lista
do
echo $i
done
echo "--OK--"
else
echo 'A directoria ~/backup nao existe'
fi
}

Principal
Figura 27 – Exemplo final

7 Exercícios

De forma a familiarizar-se com a programação BASH no SO Linux, são-lhe

propostos os seguintes exercícios:
1. Faça uma script que leia 2 strings e devolva a conjunção das duas no ecrã.
2. Faça uma script que leia a temperatura em graus fahrenheit e converta-os
para graus celsius, apresentando o resultado, nota C = (F-32)*5/9
3. Faça uma script que leia 2 números inteiros e informe o utilizador se os
números são iguais e no caso de não ser informe qual é o maior, primeiro ou
segundo, informando também o seu valor.

Sistemas Operativos – Atividade Prática 3 13