Comparações são fundamentais em qualquer linguagem de programação, e no Shell Script não é diferente. Elas permitem que seus scripts tomem decisões baseadas em condições, como verificar se um número é maior que outro, se duas strings são iguais, ou se um arquivo existe. Nesta aula, vamos explorar os operadores de comparação numérica, de strings e de arquivos, além de aprender a combiná-los para criar condições mais complexas.

Entender esses operadores é essencial para construir scripts robustos e flexíveis. Utilizaremos o comando test e sua forma abreviada com colchetes [ ] para realizar as comparações. Vamos mergulhar em cada tipo de comparação com exemplos práticos.

Numéricas (-eq, -lt)

As comparações numéricas são usadas para comparar números inteiros. Os operadores mais comuns são: -eq (igual), -ne (diferente), -lt (menor que), -le (menor ou igual), -gt (maior que), -ge (maior ou igual).

Exemplo: verificar se a idade é maior ou igual a 18.

#!/bin/bash
idade=20
if [ $idade -ge 18 ]; then
    echo "Maior de idade"
else
    echo "Menor de idade"
fi

Outro exemplo: comparar dois números.

#!/bin/bash
a=10
b=20
if [ $a -lt $b ]; then
    echo "$a é menor que $b"
fi

É importante notar que esses operadores funcionam apenas com números inteiros. Para números de ponto flutuante, seria necessário usar ferramentas como bc ou awk.

Strings (=, !=)

Para comparar strings, usamos = para igualdade e != para diferença. Também existem operadores como -z (string vazia) e -n (string não vazia).

Exemplo: verificar se o nome do usuário é "admin".

#!/bin/bash
usuario="admin"
if [ "$usuario" = "admin" ]; then
    echo "Acesso permitido"
else
    echo "Acesso negado"
fi

Sempre coloque as variáveis entre aspas duplas para evitar problemas com espaços ou caracteres especiais. Exemplo com !=:

#!/bin/bash
senha="1234"
if [ "$senha" != "1234" ]; then
    echo "Senha incorreta"
fi

Para verificar se uma string é vazia:

#!/bin/bash
nome=""
if [ -z "$nome" ]; then
    echo "Nome não fornecido"
fi

Arquivos (-f, -d, -e)

O Shell Script oferece vários operadores para testar atributos de arquivos. Os mais comuns são: -e (arquivo existe), -f (arquivo regular existe), -d (diretório existe), -r (tem permissão de leitura), -w (tem permissão de escrita), -x (tem permissão de execução).

Exemplo: verificar se um arquivo existe e é regular.

#!/bin/bash
arquivo="/etc/passwd"
if [ -f "$arquivo" ]; then
    echo "Arquivo existe"
else
    echo "Arquivo não encontrado"
fi

Verificar se um diretório existe:

#!/bin/bash
diretorio="/home/usuario"
if [ -d "$diretorio" ]; then
    echo "Diretório existe"
else
    echo "Diretório não encontrado"
fi

Verificar se um arquivo ou diretório existe (qualquer tipo):

#!/bin/bash
caminho="/tmp/teste"
if [ -e "$caminho" ]; then
    echo "Caminho existe"
fi

Combinando

Podemos combinar múltiplas condições usando operadores lógicos: && (AND), || (OR) e ! (NOT). Eles podem ser usados dentro de um único test ou entre comandos.

Exemplo: verificar se o usuário é root E se o arquivo existe.

#!/bin/bash
if [ "$(whoami)" = "root" ] && [ -f "/etc/shadow" ]; then
    echo "Acesso root e arquivo existe"
fi

Usando OR:

#!/bin/bash
if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
    echo "Uso: script [opções]"
fi

Usando NOT:

#!/bin/bash
if [ ! -d "/tmp/backup" ]; then
    mkdir /tmp/backup
fi

Também podemos usar o comando [[ ]] (no Bash) que oferece mais recursos, como expressões regulares e operadores && e || dentro dos colchetes:

#!/bin/bash
if [[ "$1" =~ ^[0-9]+$ ]] && [ "$1" -gt 10 ]; then
    echo "Número maior que 10"
fi

Combinar comparações de tipos diferentes é comum e muito útil. Lembre-se de usar parênteses para agrupar condições quando necessário, embora no Bash isso seja feito com [[ ]] ou com sub-shells.

Boas práticas

Sempre coloque variáveis entre aspas duplas em comparações de strings e ao testar arquivos para evitar erros com espaços. Prefira [[ ]] em scripts Bash para maior flexibilidade. Use nomes de variáveis descritivos e comente seu código para facilitar a manutenção.

Referências

Exercícios

  1. Escreva um script que verifica se um número fornecido como argumento é par (use operador módulo %).

    ✓ Resposta:
    #!/bin/bash
if [ $(( $1 % 2 )) -eq 0 ]; then
    echo "Par"
else
    echo "Ímpar"
fi

  2. Escreva um script que verifica se o arquivo passado como argumento existe e é legível.

    ✓ Resposta:
    #!/bin/bash
if [ -f "$1" ] && [ -r "$1" ]; then
    echo "Arquivo existe e é legível"
else
    echo "Arquivo não existe ou não é legível"
fi

  3. Escreva um script que compara duas strings fornecidas como argumentos e imprime se são iguais ou diferentes.

    ✓ Resposta:
    #!/bin/bash
if [ "$1" = "$2" ]; then
    echo "Iguais"
else
    echo "Diferentes"
fi

  4. Escreva um script que verifica se um número está entre 10 e 20 (inclusive).

    ✓ Resposta:
    #!/bin/bash
if [ "$1" -ge 10 ] && [ "$1" -le 20 ]; then
    echo "Entre 10 e 20"
else
    echo "Fora do intervalo"
fi

  5. Escreva um script que verifica se o diretório atual é /tmp e se o usuário é root.

    ✓ Resposta:
    #!/bin/bash
if [ "$(pwd)" = "/tmp" ] && [ "$(whoami)" = "root" ]; then
    echo "Estamos em /tmp como root"
else
    echo "Condição não satisfeita"
fi