Ubuntu Condicionais

Até agora seus scripts faziam sempre a mesma coisa, linha após linha. Com condicionais, o script passa a tomar decisões: "se o arquivo existe, faça backup; senão, avise o usuário". Esta aula mostra o if e seus parceiros, parte por parte.

Antes, leia Primeiro Script e Variáveis e Argumentos. Os exemplos rodam na máquina fictícia notebook, com a usuária ana.

A ideia: todo comando diz se deu certo

Você já viu que todo comando devolve um código de saída: 0 quando deu certo e outro número quando deu errado. O if do Bash usa exatamente isso. Ele roda um comando e olha o código:

• Código 0 → o if considera verdadeiro e executa o bloco do then.
• Qualquer outro código → falso: pula para o else, se existir.

$ ls Documentos
acesso.log  notas.txt  projetos  relatorio.odt
$ echo $?
0                                                   « deu certo = verdadeiro
$ ls Fotos
ls: não é possível acessar 'Fotos': Arquivo ou diretório inexistente
$ echo $?
2                                                   « deu errado = falso

A estrutura do if

if COMANDO; then
  comandos se COMANDO deu certo
fi

if

"Se". Começa a decisão.

grep -q "^ana:" /etc/passwd

O comando testado. Aqui: procura a linha da usuária ana. O -q (quiet, "quieto") faz o grep não mostrar nada, só devolver o código.

; then

"Então". O ; separa o comando do then quando estão na mesma linha.

echo "a ana existe"

O que fazer quando o comando deu certo.

; fi

Fim do if. fi é if ao contrário.

$ if grep -q "^ana:" /etc/passwd; then echo "a ana existe"; fi
a ana existe
$ if grep -q "^joao:" /etc/passwd; then echo "o joao existe"; fi
$ echo $?
0

Na segunda vez, nada apareceu: o grep não achou o joao, devolveu 1, e o if pulou o echo. Repare que o echo $? mostra 0: um if sem else que não executou nada termina com sucesso.

Em scripts, escrevemos em várias linhas, com o bloco indentado (recuado com espaços). Assim fica mais fácil de ler:

#!/usr/bin/env bash
if grep -q "^ana:" /etc/passwd; then
  echo "A usuária ana existe."
fi

Testar condições: o comando [ ]

E quando você quer perguntar "este arquivo existe?" ou "este número é maior que 5?". Para isso existe o comando test, que tem um apelido: [. Isso mesmo: o colchete é um comando.

$ type [
[ é um comando interno do shell
$ test -f frutas.txt
$ echo $?
0                                                   « frutas.txt existe e é um arquivo
$ [ -f compras.txt ]
$ echo $?
1                                                   « compras.txt não existe

[

O comando de teste (o mesmo que test).

-f

O tipo de teste: "existe e é um arquivo comum".

"$arquivo"

O que está sendo testado. Sempre entre aspas.

]

Fecha o teste. É obrigatório e precisa de espaço antes.

Seu primeiro if com teste

#!/usr/bin/env bash
arquivo="$1"

if [ -f "$arquivo" ]; then
  echo "O arquivo $arquivo existe."
else
  echo "Não encontrei $arquivo."
fi

O else ("senão") é opcional: ele roda quando o teste dá falso.

$ chmod +x verifica.sh
$ ./verifica.sh frutas.txt
O arquivo frutas.txt existe.
$ ./verifica.sh compras.txt
Não encontrei compras.txt.

Os testes mais usados

Arquivos e pastas

Textos (strings)

Números inteiros

$ if [ 3 > 5 ]; then echo "3 é maior que 5?!"; fi
3 é maior que 5?!                                   « resposta errada…
$ ls 5
5                                                   « …e ainda criou um arquivo chamado "5"

Negar e combinar

Várias saídas: elif e else

elif é a junção de else if, "senão, se". O Bash testa de cima para baixo e executa só o primeiro bloco verdadeiro.

#!/usr/bin/env bash
nota="$1"

if [ "$nota" -ge 7 ]; then
  echo "Aprovado"
elif [ "$nota" -ge 5 ]; then
  echo "Recuperação"
else
  echo "Reprovado"
fi

$ ./nota.sh 8
Aprovado
$ ./nota.sh 5
Recuperação                                         « 5 não é ≥ 7, mas é ≥ 5
$ ./nota.sh 3
Reprovado

Formas diferentes de testar

O Bash tem quatro jeitos de escrever um teste. Todos funcionam; cada um tem seu ponto forte.

[[ ]]: o teste moderno do Bash

O colchete duplo é uma palavra-chave do Bash (não um comando). Ele aceita variáveis sem aspas, && e || por dentro e comparação com curingas:

$ arquivo="relatorio.pdf"
$ if [[ $arquivo == *.pdf ]]; then echo "é PDF"; fi
é PDF
$ if [[ -f frutas.txt && -r frutas.txt ]]; then echo "posso ler"; fi
posso ler

(( )): contas e comparações de números

Dentro de (( )), os sinais > < == funcionam como na matemática, sem $ nas variáveis:

$ x=10
$ if (( x > 5 )); then echo "maior que 5"; fi
maior que 5

&& e ||: o if de uma linha

Para decisões curtas, você nem precisa do if:

mkdir backup

Primeiro comando.

&& echo "criada"

"E então": só roda se o anterior deu certo.

|| echo "falhou"

"Ou então": só roda se o anterior deu errado.

$ mkdir backup && echo "pasta criada" || echo "falhou"
pasta criada
$ mkdir backup && echo "pasta criada" || echo "falhou"
mkdir: backup: Arquivo existe
falhou

Qual usar?

Escolher entre muitas opções: case

Quando uma variável pode ter vários valores, uma fila de elif fica longa. O case ("caso") compara o valor com uma lista de padrões:

#!/usr/bin/env bash
case "$1" in
  iniciar|start)
    echo "Iniciando o serviço..."
    ;;
  parar|stop)
    echo "Parando o serviço..."
    ;;
  status)
    echo "O serviço está rodando."
    ;;
  *)
    echo "Uso: $0 {iniciar|parar|status}"
    exit 1
    ;;
esac

case "$1" in

"No caso do valor de $1…"

iniciar|start)

Um padrão. A barra | aqui significa "ou". O ) fecha o padrão.

;;

Fim deste caso. O case para aqui.

*)

Qualquer outra coisa (o "senão" do case).

esac

Fim do case (case ao contrário).

$ ./servico.sh iniciar
Iniciando o serviço...
$ ./servico.sh reiniciar
Uso: ./servico.sh {iniciar|parar|status}
$ echo $?
1                                                   « o script avisou que algo deu errado

Os padrões aceitam curingas: *.jpg|*.png) pega imagens, [sS]|[sS]im) pega "s", "S", "sim" e "Sim".

Exemplo completo: um backup que confere tudo antes

Este script junta o que você aprendeu. Ele confere se recebeu um argumento, se esse argumento é uma pasta, e só então compacta. Cada erro devolve um código diferente.

#!/usr/bin/env bash
# Uso: ./backup.sh PASTA

if [ $# -ne 1 ]; then
  echo "Uso: $0 PASTA" >&2
  exit 1
fi

origem="$1"

if [ ! -d "$origem" ]; then
  echo "Erro: '$origem' não é uma pasta." >&2
  exit 2
fi

destino="backup-$(date +%F).tar.gz"

if tar -czf "$destino" "$origem"; then
  echo "Backup criado: $destino"
else
  echo "Erro: o tar falhou." >&2
  exit 3
fi

• $# é a quantidade de argumentos; -ne 1 pergunta "é diferente de 1?".
• >&2 manda a mensagem para a saída de erros, como fazem os comandos de verdade.
• exit 1, exit 2… encerram o script com um código que quem chamou pode testar.
• O último if testa o próprio tar: se ele falhar, o script avisa.

$ ./backup.sh
Uso: ./backup.sh PASTA
$ echo $?
1
$ ./backup.sh frutas.txt
Erro: 'frutas.txt' não é uma pasta.
$ echo $?
2
$ ./backup.sh Documentos
Backup criado: backup-2026-10-15.tar.gz

Quando não funciona

$ if [ -f frutas.txt]; then echo ok; fi
bash: [: faltando `]'

$ if ["a" = "a"]; then echo ok; fi
[a: comando não encontrado

$ nome=""
$ if [ $nome = "ana" ]; then echo oi; fi
bash: [: =: esperava operador unário

$ ./nota.sh dez
./nota.sh: linha 4: [: dez: esperava número inteiro
./nota.sh: linha 6: [: dez: esperava número inteiro
Reprovado

$ if [ "ana" = "ana" ] then echo oi; fi
bash: erro de sintaxe próximo ao token inesperado `fi'

$ if [ -f frutas.txt ]; then echo ok
>

Referência rápida

Exercícios

Resumo

• O if roda um comando: código 0 é verdadeiro, qualquer outro é falso.
• [ ] é um comando: precisa de espaços e de variáveis entre aspas.
• Arquivos: -e -f -d -s -x; textos: = != -z -n; números: -eq -ne -lt -le -gt -ge.
• [[ ]] é o teste mais seguro no Bash; (( )) é o melhor para números.
• && e || fazem decisões de uma linha; case organiza muitas opções.