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.

http://olinux.uol.com.br/artigos/286/print_preview.html

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

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:

● -b arquivo - Verdadeiro se arquivo é um arquivo de bloco, como /dev/hda.

● -c arquivo - Verdadeiro se arquivo é um arquivo de caracter, como /dev/tty1.

● -d arquivo - Verdadeiro se arquivo é um diretório.

● -e arquivo - Verdadeiro se arquivo existe.

● -f arquivo - Verdadeiro se arquivo existe e é um arquivo comum.

● -s arquivo - Verdadeiro se arquivo existe e não é vazio.

● -h arquivo - Verdadeiro se arquivo é um link simbólico.

● -p arquivo - Verdadeiro se arquivo é um "named pipe" (fifo, lifo, etc).

● -S arquivo - Verdadeiro se arquivo é um "socket".

● -k arquivo - Verdadeiro se arquivo tem seu "sticky bit" ligado.

● -r arquivo - Verdadeiro se arquivo pode ser lido pelo usuário atual.

● -w arquivo - Verdadeiro se arquivo pode ser escrito pelo usuário atual.

● -x arquivo - Verdadeiro se arquivo pode ser executado pelo usuário atual.

● -O arquivo - Verdadeiro se arquivo pertence ao usuário atual.

● -G arquivo - Verdadeiro se arquivo pertence ao grupo do usuário atual.

● -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:

● -eq (equal): Igual;

● -ne (not-equal): Não Igual (diferente);

● -lt (less than): Menor que (<);

● -le (less than or equal): Menor ou igual ( <= );

● -gt (greater than): Maior que (>);

● -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

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-2000 Linux Solutions