Nesta aula, o documento ensina sobre comandos condicionais em shell script, incluindo: 1) O comando "if" executa um bloco de código se uma condição for verdadeira e outro bloco se for falsa, avaliando o código de retorno de um comando. 2) O comando "test" também avalia condições, podendo comparar strings, verificar propriedades de arquivos e expressões aritméticas. 3) É importante usar aspas duplas ao referenciar variáveis dentro de condições para que o bash possa substitu

1. http://olinux.uol.com.br/artigos/286/print_preview.html
Curso de Shell - Aula III
Por: Alex Borro ( 27/03/2001 )
Introdução
Nesta terceira parte do nosso curso de shell script, vamos tratar de "condicionais".Condicionais são
comandos que avaliam uma expressão. Se ela for verdadeira, uma determinada rotina é executada.
Caso contrário, outra rotina pode ser executada.
O famoso "if"
O bash nos oferece, entre outros, o comando IF (ele é um comando embutido no bash e não um
programa como o "ls", o "cp" etc.). A forma mais simples de representar uma condicional utilizando o
IF, é da seguinte forma básica:
if [condição];
then comandos1;
else comandos2;
fi;
Se [condição] for verdadeira, os comandos1 são executados. Se for falsa, os comandos2 são
executados.Mas para o IF, o que é uma condição verdadeira ou uma falsa?
Como foi explicado na aula anterior, TODO comando em Unix tem um código de retorno. Geralmente o
código "0" (zero) significa que o comando foi executado perfeitamente e terminou bem. Códigos
maiores que zero significam que alguma coisa de errado ocorreu.
É assim que o IF verifica uma condição. Se o seu código de retorno for zero, então ela é considerada
verdadeira. Caso contrario, ela é falsa.Mas então a [condição] tem que ser um comando, certo?
Exatamente. Vamos exemplificar:
neo@matrix:~$ if ls /boot; then echo "O diretório existe."; else echo "Diretório inválido.";
fi;
System.map boot.0300 boot.b boot_message.txt chain.b config map os2_d.b
O diretório existe.
O que fizemos?
Logo após o if, nós colocamos um comando: "ls /boot". O que o IF faz? Ele executa esse comando (por
isso que temos a segunda linha começada por "System.map", que é o conteúdo do meu diretório /boot)
e avalia o seu código de saída. Como o "ls" foi executado corretamente, ele retorna zero, significando
verdadeiro para o IF, que executa o comando logo após o "then", ou seja, o echo "O diretório existe.",
mostrando essa mensagem no console.
Agora vamos colocar um diretório que não existe:
neo@matrix:~$ if ls /dir_invalido; then echo "O diretório existe."; else echo "Diretório
inválido."; fi;
/bin/ls: /dir_invalido: Arquivo ou diretório não encontrado
Diretório inválido.
A lógica é a mesma. Executa o "ls /dir_invalido", que retorna um código maior que zero. O IF avalia
como falso e executa o comando após o else: echo "Diretório inválido".
Nós poderíamos omitir a segunda linha dos dois exemplo (a que mostra o conteúdo de /boot no
primeiro exemplo e a mensagem de erro emitida pelo ls dizendo que /dir_invalido não existe no
segundo), apenas redirecionando as saídas para /dev/null, ou seja:
neo@matrix:~$ ls /boot 1> /dev/null 2> /dev/null
Nota: Tem um macete que possui o mesmo efeito. Em vez de colocar: "1> /dev/null 2> /dev/null"
podemos colocar "2&>1", que é menor e mais simples.

2. O comando "test"
Bom, aprendemos que o IF avalia a código de retorno de um comando. Mas muitas vezes, para não
dizer a maioria, nós queremos avaliar "expressões", ou seja, verificar se uma variável é igual a outra,
se ela esta vazia etc.
Para isso, nós temos outro comando chamado "test" (intuitivo o nome, não?). Ele funciona da seguinte
maneira: test [expressão].
O test pode testar operações de três tipos: strings, arquivos e aritméticas.
Expressões usando strings:
O test pode apenas comparar strings, ou seja, verificar se uma é igual a outra, e verificar se uma string
é vazia ou não. Vamos aos exemplos para facilitar o entendimento:
neo@matrix:~$ test "a" = "a"
neo@matrix:~$ echo $?
0
neo@matrix:~$ test "a" = "b"
neo@matrix:~$ echo $?
1
neo@matrix:~$ test "a" != "b"
neo@matrix:~$ echo $?
0
Aqui comparamos a string "a" com "b". Como era de se esperar, o primeiro retornou verdadeiro (zero),
pois a = a e o segundo retornou falso. No terceiro, o símbolo "!=" significa "diferente".
neo@matrix:~$ test -z "neo"
neo@matrix:~$ echo $?
1
neo@matrix:~$ test -z ""
neo@matrix:~$ echo $?
0
neo@matrix:~$ test -n "neo"
neo@matrix:~$ echo $?
0
neo@matrix:~$ test -n ""
neo@matrix:~$ echo $?
1
Acima temos os testes de vazio. A opção "-z" verifica se é vazio, e "-n" se não é vazio. No primeiro
caso, ele testa se "neo" é uma string vazia, retornando falso. Já no segundo caso, como "" é vazia,
retorna verdadeiro. O terceiro e quarto são semelhantes aos primeiros, mas com "-n".
Expressões com arquivos:
Os testes que podem ser feitos com arquivos são para verificar determinadas caracteristicas, como se
ele existe, se é executavel, se é um link simbólico, se é um diretório etc.
Alguns exemplos:
A opção "-e" verifica apenas se um arquivo existe e a opção "-d" verifica se o arquivo é um diretório.
A opção "-nt" verifica se o primeiro arquivo é mais novo que o segundo (nt = newer than) e "-ot"
verifica se o primeiro é mais velho que o segundo (od = older than):
neo@matrix:~$ test -e /vmlinuz
neo@matrix:~$ echo $?
0
neo@matrix:~$ test -d /vmlinuz
neo@matrix:~$ echo $?
1
neo@matrix:~$ test -e /usr
neo@matrix:~$ echo $?
0
neo@matrix:~$ test -d /usr
neo@matrix:~$ echo $?
0

3. neo@matrix:~$ test /usr -nt /vmlinuz
neo@matrix:~$ echo $?
0
neo@matrix:~$ test /usr -ot /vmlinuz
neo@matrix:~$ echo $?
1
O comando "test" (continuação)
A seguir, temos uma lista de várias opções disponíveis:
q -b arquivo - Verdadeiro se arquivo é um arquivo de bloco, como /dev/hda.
q -c arquivo - Verdadeiro se arquivo é um arquivo de caracter, como /dev/tty1.
q -d arquivo - Verdadeiro se arquivo é um diretório.
q -e arquivo - Verdadeiro se arquivo existe.
q -f arquivo - Verdadeiro se arquivo existe e é um arquivo comum.
q -s arquivo - Verdadeiro se arquivo existe e não é vazio.
q -h arquivo - Verdadeiro se arquivo é um link simbólico.
q -p arquivo - Verdadeiro se arquivo é um "named pipe" (fifo, lifo, etc).
q -S arquivo - Verdadeiro se arquivo é um "socket".
q -k arquivo - Verdadeiro se arquivo tem seu "sticky bit" ligado.
q -r arquivo - Verdadeiro se arquivo pode ser lido pelo usuário atual.
q -w arquivo - Verdadeiro se arquivo pode ser escrito pelo usuário atual.
q -x arquivo - Verdadeiro se arquivo pode ser executado pelo usuário atual.
q -O arquivo - Verdadeiro se arquivo pertence ao usuário atual.
q -G arquivo - Verdadeiro se arquivo pertence ao grupo do usuário atual.
q -N arquivo - Verdadeiro se arquivo foi modificado desde a ultima vez que foi lido.
Expressões Aritméticas
Expressões aritméticas consistem com comparar dois números, verificando se são iguais, ou se o
primeiro é maior que o segundo etc.
Infelizmente não podemos apenas utilizar os símbolos conhecidos para igual (=), maior que (>), menor
que (<) etc. Temos que usar operadores reconhecidos pelo "test". Assim, não podemos fazer: "test 1 =
1", devemos utilizar o operador "-eq" (equal): "test 1 -eq 1". A seguir, temos uma lista dos operadores:
q -eq (equal): Igual;
q -ne (not-equal): Não Igual (diferente);
q -lt (less than): Menor que (<);
q -le (less than or equal): Menor ou igual ( <= );
q -gt (greater than): Maior que (>);
q -ge (greater than or equal): Maior ou igual (>=);
Alguns exemplos:
neo@matrix:~$ test 1 -lt 2
neo@matrix:~$ echo $?
0
neo@matrix:~$ test 1 -gt 2
neo@matrix:~$ echo $?
1
neo@matrix:~$ test 2 -gt 1
neo@matrix:~$ echo $?
0
neo@matrix:~$ test 2 -ge 2
neo@matrix:~$ echo $?
0

4. Para finalizar, vamos fazer duas considerações. A primeira é de que o comando "test" pode ser
substituido por um par de colchetes [ ]. Assim, o comando test "a" = "b" pode ser escrito como [ "a"
= "b" ] .
Essa segunda nomenclatura fica mais fácil e simples, principalmente quando estamos utilizando IF:
if [ -e /vmlinuz ]; é mais intuitivo e simples que if test -e /vmlinuz; .
A segunda consideração é que, obviamente, podemos utilizar variáveis no lugar dos argumentos (caso
contrário, ficaria difícil utilizar comandos de condicionais em shell script). Assim, se tivermos duas
variaveis, valor1=5 e valor2=8:
[ "$valor1" = "$valor2" ] , [ "$valor1" -lt "$valor2" ] etc.
É importante colocarmos os valores entre aspas duplas ("), pois assim o bash pode substituir o que se
encontra dentro dessas aspas. Se colocarmos entre aspas simples ('), impedimos o bash de alterar o
que se encontra dentro delas. Se não utilizarmos as aspas duplas, vamos ter problemas, principalmente
ao trabalharmos com string.
Por exemplo, queremos comparar dois nomes, que se encontram em duas variaveis:nome1="fulano de
tal" e nome2="ciclano".Montando nossa expressão condicional: [ "$nome1" = "$nome2" ].O bash irá
expandir isso para: [ "fulano de tal" = "ciclano" ], ficando claramente definidos o primeiro e o segundo
argumento.
Agora, se não usarmos aspas: [ $nome1 = $nome2 ]. O bash irá expandir isso para: [ fulano de tal =
ciclano ]. Perceba que os argumentos se misturam e o bash não vai saber o que comparar.Por isso é
importante colocarmos os argumentos entre aspas duplas.
Conclusão
Resumindo, aprendemos na aula de hoje como utilizar comandos condicionais. Isso será fundamental
nas proximas aulas, onde iremos tratar os comandos de laço, como o while. Não perca!
Copyright (C) 1999- 2 0 0 0 Linux Solutions