Comando test no Linux (testar condições) [Guia Básico]

O comando test é uma grande ferramenta para testar condições. Com base na variável de retorno do comando test, lógicas de programação podem ser montadas para executar algo se uma condição for satisfeita ou não.

Ele pode testar condições em arquivos, permissões, textos, números, e até através de expressões e fornece o resultado através da variável de retorno $?.

Neste exemplo o comando test verifica se 1 é menor que 2 (-lt = less than – menor que):

$ test 1 -lt 2 
$ echo $?
0

Como a variável de retorno foi 0, o número 2 é menor que 1.

Neste outro exemplo ele testa com o “-d” se o arquivo /usr/src é um diretório:

$ test –d /usr/src
$ echo $?
0

As opções mais comuns do comando test são:

OpçãoPara que ServeExemplo
-d /diretorioVerifica se um arquivo é um diretório e se ele existe$ test -d /etc
-e arquivoVerifica se um arquivo existe, independente do seu tipo$ test -e /etc/passwd
-f arquivoVerifica se um arquivo existe e se ele é comum$ test -f /etc/passwd
-z arquivoVerifica se o arquivo está vazio$ test -z /etc/groups
-n “$variavel”Verifica se o tamanho de um texto é maior que zero$ test -n “$LIVRO”
-s arquivoVerifica se um arquivo existe e se seu tamanho é maior que zero$ test -s /etc/passwd
s1 = s2Verifica se um texto é igual a outro$ test “$LIVRO” = “Certificação Linux”
s1 != s2Verifica se um texto diferente de outro$ test “$LIVRO” != “Certificação Linux”
x -eq yVerifica se um número x é igual a y$ VAR=10 ; test $VAR -eq 10
x -gt yVerifica se um número x é maior que y$ VAR=10 ; test $VAR -gt 9
x -lt yVerifica se um número x é menor que y$ VAR=10 ; test $VAR -lt 11
x -ne yVerifica se um número não é igual y$ VAR=10 ; test $VAR -ne 11
x -ge yVerifica se um número x é maior ou igual a y$ VAR=10 ; test $VAR -ge 9
x -le yVerifica se um número x é menor ou igual a y$ VAR=10 ; test $VAR -le 11
expressão -a expressãoVerifica se ambas as expressões são verdadeiras$ test 10 -ge 9 -a 22 -gt 10; echo $?
expressão -o expressãoVerifica se uma OU expressão são verdadeiras$ test 10 -ge 11 -o 22 -gt 10; echo $?
arquivo1 -nt arquivo2Verifica se o arquivo1 foi modificado depois de arquivo2 (mais novo)$ test arquivo1 -nt arquivo2
arquivo1 -ot arquivo2Verifica se o arquivo1 foi modificado antes de arquivo2 (mais velho)$ text arquivo1 -ot arquivo2
-r arquivoVerifica se o arquivo tem permissão de leitura$ test -r aquivo
-w arquivoVerifica se o arquivo tem permissão de escrita$ test -w arquivo
-x arquivoVerifica se o arquivo tem permissão de execução$ test -x arquivo
-O arquivoVerifica se você é o dono do arquivo$ test -O arquivo

Uso de [  ] no lugar do “test”

O comando test pode ser abreviado com colchetes [  ]. Observe que deve haver um espaço entre a expressão e os colchetes:

$ [ 10 -ge 8 ]
$ echo $?
0

Operadores || e &&

Os operadores (pipe pipe) II e && servem para verificar se a expressão à direita retorna verdadeiro ou falso.

O operador && verifica se algo que está à sua direita é verdadeiro, e assim sendo executa o comando à sua esquerda.

Neste exemplo, forçamos o retorno verdadeiro com o comando “true” que sempre irá retornar verdadeiro:

$ true && echo "Deu certo"
Deu certo

Se usarmos o comando “false”, que sempre retorna falso, o operador && não vai executar o comando à esquerda:

$ false && echo "Deu certo"

O operador II verifica se algo que está à sua direita é falso, e assim sendo executa o comando à sua esquerda.

Neste exemplo, forçamos o retorno verdadeiro com o comando true. Neste caso, o II não irá executar nada.

$ true || echo "Deu certo"

Já agora, o forçando o retorno falso com o comando false, o II executa o comando echo:

$ false || echo "Deu certo"
Deu certo

Os operadores && e II também podem ser usados juntos:

$ test 100 -gt 99 && echo "SIM" || echo "NÃO"

Neste caso irá retornar SIM porque 100 é maior que 99.

Controle de fluxo com if (se)

Controles de fluxo (if) são comandos que testam algumas alternativas e, de acordo com o resultado, executam comandos.

A lógica do comando if é “se isso for verdadeiro, faça isso, se não, faça aquilo”. Veja o exemplo:

if [ $? = 0 ]; then 
echo ‘O comando foi completado com sucesso...’
else 
echo ‘O comando falhou.’
fi

Neste exemplo o if testa se o conteúdo da variável de retorno $? é 0. Caso positivo, executa o comando echo “O comando foi completado com sucesso…”. Se a condição for falsa, executa o comando echo “O comando falhou.”.

Diferente de outras linguagens, o if testa um comando e não uma condição. Assim sendo,  devemos utilizar o comando test em conjunto com o if. Geralmente escreve-se usando o atalho dos colchetes [  ] para o comando test.

Controle de fluxo com case

O case é uma forma inteligente de se comparar o valor que algo com vários padrões.

Caso uma ocorrência for positiva, ele permite que se execute comandos.

Cada case é uma expressão que corresponde a um padrão.

O operador “)” termina uma lista de padrões e inicia uma lista de comandos.

O que separa um padrão de outro é “;;“.

Ao fim do case, deve-se terminar com a instrução esac (case ao contrário).

Exemplo de um script que dependendo do UID do usuário imprime uma mensagem diferente:

#!/bin/bash
ID=$(id -u)
case "$ID" in
   0)
      echo "Você é o root.";
      echo "Parabens!"
   ;;
   1000)
      echo "Você é o Uirá."
   ;;
   100[1-9])
      echo "Vocé é outro usuário"
esac
echo "fim";

Se o valor da variável ID for 0, irá imprimir uma mensagem de parabéns. Se for igual a 1000, imprime “você é o Uirá”. Se for entre 1001 e 1009, imprime “Você é outro usuário.

Se executado com o usuário uira, que tem o UID igual a 1000:

$ ./meucase 
Você é o Uirá.
fim

Se executado como root:

$ sudo ./meucase 
Você é o root.
Parabens!
fim

case é melhor do que usar várias vezes o comando “if” para comparar algo com vários padrões.

Loops com o comado for

$ for algo; do comando; comando2; done

O shell possui estruturas para testar condições e executar determinadas sequências de programas várias vezes (loop), até que a condição testada seja satisfeita.

Os três comandos que possibilitam isso são o for (até que), o while (enquanto for verdadeiro) e until (enquanto for falso).

O comando for permite que laços (loops) sejam feitos para que um ou mais comandos sejam executados até que uma determinada variável percorra todos os valores de uma dada lista. 

Veja um exemplo simples:

$ for numero in um dois três quatro cinco
do
echo "Contando: $numero"
done 
Contando: um
Contando: dois
Contando: três
Contando: quatro
Contando: cinco

O mesmo comando pode ser escrito em uma só linha:

$ for numero in um dois três quatro cinco; do echo "Contando: $numero"; done

Veja o exemplo:

$ ls -1 > lista_arquivos.txt

Pode-se agora usar o for para executar diversos comandos para cada arquivo da lista:

$ for i in $(cat lista_arquivos.txt); do cp $i $i.backup; mv $i.backup /tmp/backup; done;

Este laço atribui para a variável $i cada linha do arquivo lista_ar­quivos.txt.

A expressão $(comando) gera uma lista com resultado do comando. Tem o mesmo efeito que utilizar o comando entre crases: `comando`.

Em seguida ele executa os comandos para renomear e mover os arquivos até que a lista esteja completa.

Agora um exemplo um pouco mais complexo, com uso do for com if:

$ for i in `ls -1`; do if test -f $i;  then echo “$i é um arquivo “; else echo “$i não é um arquivo”; fi ; done
Desktop não é um arquivo
Documents não é um arquivo
Downloads não é um arquivo
HR_PROFESSOR.sql é um arquivo

Nesta linha, o resultado do comando ls -1 é colocado na variável $i; Depois cada linha da variável $i é testada para saber se é um arquivo; se for verdadeiro, será exibida uma frase e, se for falso, outra frase.

Loops com o comando while

$ while [ expressão ] ; do comando; comando; done

O while testa continuamente uma expressão, até que uma expressão tenha variável de retorno igual a zero ou verdadeiro.

Neste exemplo, a variável $i ganha o valor inicial igual a zero.

Enquando (while) a condição do comando test representado pelos [  ] retornar zero (verdadeiro), o laço do loop continuará a ser executado.

No laço a variável $i é incrementada, até que $i atinja a condição de não ser menor que 4:

$ i=0
$ while [ $i -lt 4 ]; do echo "conta $i" ; i=$[$i+1]; done
conta 0
conta 1
conta 2
conta 3

O while precisa ter uma condição de saída satisfeita, senão ficará em loop infinito.

Loops com o comando until

O comando until é o inverso ao comando while, mas ele executa algo enquanto o teste for falso, ou com valores diferentes de zero.

Sua sintaxe é:

until [CONDIÇÃO]
do
  [COMANDOS]
done

Exemplo:

#!/bin/bash
counter=0
until [ $counter -gt 3 ]
do
  echo Counter: $counter
  ((counter++))
done

Ao ser executado:

$ ./contador 
Counter: 0
Counter: 1
Counter: 2
Counter: 3

until é útil para fazer um script esperar até que um comando não retorne mais erro, uma vez que ele só é executado se o retorno do teste for diferente de zero.

O código zero de saída de um programa geralmente indica que ele foi executado com sucesso.

Neste exemplo, o comando until é usado para esperar até que o host consiga pingar o IP 8.8.8.8. Quando o comando ping conseguir pingar o host 8.8.8.8, ele retornará zero, fazendo com que o processamento deixe o loop:

#!/bin/bash
until ping -c 1 8.8.8.8 &>/dev/null
do
    echo "Esperando a rede..."
    sleep 1
done
echo "A rede está no ar"

Aprenda muito mais sobre Linux em nosso curso online. Você pode efetuar a matrícula aqui. Se você já tem uma conta, ou quer criar uma, basta entrar ou criar seu usuário aqui.

Gostou? Compartilhe