Lógica condicional com If Else

Introdução

Imagine que você está dirigindo um carro usando um GPS. O GPS não fornece apenas uma lista fixa de instruções; ele reage à estrada. Se houver trânsito, ele recalcula a rota. Se você perder uma saída, ele calcula uma nova rota.

Em scripts, chamamos isso de lógica condicional. Sem ela, um script é apenas uma lista de comandos executados às cegas. Com ela, o script pode verificar a situação atual e escolher o que fazer em seguida.

Essa é uma das bases da automação confiável. Os sistemas reais nem sempre estão no mesmo estado, portanto bons scripts precisam reagir em vez de fazer suposições.

Neste laboratório, você adicionará um “cérebro” aos seus scripts usando if e else.

Você ensinará seu script a:

1. Verificar a realidade: confirmar se um arquivo realmente existe antes de tentar abri-lo.
2. Tomar decisões: fazer uma coisa quando a resposta for “Sim” e outra quando for “Não”.
3. Verificar o ID: confirmar se o usuário tem permissão de root para executar o script.

Verificar se um arquivo existe

Um bom script age como um motorista cuidadoso: ele olha antes de avançar. Uma das verificações mais comuns no Linux é: “Este arquivo existe?”

Usamos a opção -f (verificação de arquivo) dentro de um bloco if. Pense no if como um segurança. Ele só permite que o código interno seja executado quando a condição é atendida.

Este é seu primeiro exemplo real de um script tomando uma decisão com base no estado do sistema. Isso representa um grande avanço em relação a “executar comandos em ordem” para “inspecionar o ambiente e então escolher uma ação”. Grande parte dos scripts de administração é construída exatamente sobre esse padrão.

Primeiro, acesse a pasta do projeto:

cd ~/project

Crie um novo script chamado check_file.sh:

nano check_file.sh

Digite este código. Vamos verificar se data.txt existe.

#!/bin/bash

FILE="data.txt"

if [ -f "$FILE" ]; then
  echo "$FILE exists."
fi

Entendendo a lógica:

• if [ ... ]; then: este é o segurança. Ele faz uma pergunta dentro dos colchetes.
• -f "$FILE": a pergunta: “data.txt é um arquivo real?”
• echo ...: a ação. Ela só acontece quando o segurança responde “Sim”.
• fi: “Finalizar If”. Isso informa ao Linux que a seção condicional terminou.

A forma com colchetes [ ... ] é a maneira comum do Bash de executar um teste. Neste caso, ela verifica uma propriedade de arquivo. O Linux e o Bash fornecem muitos operadores de teste desse tipo, e aprendê-los permite que os scripts raciocinem sobre arquivos, strings, números e permissões.

Salve (Ctrl+O) e saia (Ctrl+X).

Torne o script executável:

chmod +x check_file.sh

Teste 1: o arquivo invisível

Execute o script agora:

./check_file.sh

Nada acontece. Silêncio.

Por quê? Porque data.txt não existe. O segurança respondeu “Não”, então o comando echo foi completamente ignorado.

Teste 2: o arquivo visível

Agora, crie o arquivo:

touch data.txt

Execute o script novamente:

./check_file.sh

Agora o segurança responde “Sim”, e você verá:

data.txt exists.

Adicionar um bloco Else

O silêncio é confuso. Se um script não faz nada, você não sabe se ele falhou ou apenas terminou. Precisamos de um plano B.

Na lógica, isso é uma “bifurcação na estrada”.

• Caminho A (if): o arquivo existe. Ótimo.
• Caminho B (else): o arquivo está ausente. Vamos corrigir isso.

Vamos modificar nosso script para criar automaticamente o arquivo ausente.

Primeiro, exclua o arquivo de teste para realizarmos um teste de verdade:

rm data.txt

Abra seu script:

nano check_file.sh

Adicione o bloco else conforme mostrado abaixo:

#!/bin/bash

FILE="data.txt"

if [ -f "$FILE" ]; then
  echo "$FILE exists."
else
  echo "$FILE does not exist. Creating it now..."
  touch "$FILE"
fi

A lógica:

Se if for verdadeiro → execute a primeira parte.

Se if for falso → execute a parte else.

Esse tipo de script costuma estar mais próximo das operações reais do que um script que apenas exibe informações. Em vez de somente informar que algo está ausente, ele corrige a situação. Por isso, a lógica condicional é a base de muitos scripts de configuração e manutenção.

Salve e saia.

Testar a lógica

Execute o script. data.txt está ausente, portanto o script deve seguir o Caminho B:

./check_file.sh

Saída:

data.txt does not exist. Creating it now...

Execute-o novamente imediatamente. Agora data.txt existe, portanto o script deve seguir o Caminho A:

./check_file.sh

Saída:

data.txt exists.

Agora seu script é “idempotente” — uma palavra sofisticada que significa que você pode executá-lo 100 vezes e ele sempre garantirá o resultado correto (o arquivo existe) sem falhar.

Essa palavra aparece com frequência em DevOps. Uma ação idempotente pode ser repetida com segurança porque o estado final é mais importante do que quantas vezes o comando foi executado. Isso torna a automação mais confiável, especialmente quando os trabalhos são repetidos.

Verificar permissões de root

Algumas portas no Linux estão trancadas. Somente o superusuário (root) tem a chave. Se você tentar executar um script de manutenção do sistema como um usuário comum, ele falhará com “Permission Denied”.

Um script inteligente verifica sua identificação antes de tentar abrir a porta.

No Linux, cada usuário tem um número (UID).

• Root sempre tem UID 0.
• Usuários comuns geralmente têm UID 1000 ou superior.

Vamos escrever um script que verifica seu crachá de identificação.

Crie check_root.sh:

nano check_root.sh

Digite este código:

#!/bin/bash

if [ "$UID" -eq 0 ]; then
  echo "You are running this script as root."
else
  echo "You are running this script as a regular user."
fi

Entendendo o código:

• $UID: a variável que contém seu número de identificação atual.
• -eq: “igual a”. Usamos -eq para números e = para palavras.

Este é outro exemplo da sintaxe de testes. Ao comparar números dentro de [ ... ], o Bash usa operadores como -eq, -ne, -lt e -gt. Eles são diferentes das comparações de strings porque o shell precisa saber se está comparando palavras ou valores numéricos.

Salve e saia. Torne o script executável:

chmod +x check_root.sh

O teste

Como você está conectado como labex, é um usuário comum.

Execute o script normalmente:

./check_root.sh

O script identifica seu ID diferente de zero e exibe:

You are running this script as a regular user.

Agora, vamos pegar emprestada a capa do superusuário usando sudo:

sudo ./check_root.sh

sudo altera seu ID para 0 apenas durante a execução desse comando. O script percebe isso e responde:

You are running this script as root.

É assim que funcionam os scripts profissionais de instalação: eles se recusam a executar quando você não é root!

O objetivo não é exigir root para tudo, mas verificar os privilégios antes de tentar executar ações protegidas. Um script bem escrito falha logo no início com uma explicação clara, em vez de executar parcialmente e produzir erros de permissão confusos mais tarde.

Resumo

Você acabou de dar um cérebro aos seus scripts!

Neste laboratório, você aprendeu:

1. O segurança (if): fazer perguntas como “Este arquivo existe?” (-f).
2. A bifurcação (else): fornecer um plano alternativo quando a resposta for “Não”.
3. A verificação do ID: usar a comparação numérica (-eq) para confirmar as permissões do usuário.

Agora seus scripts não são mais apenas listas de comandos; são programas inteligentes que se adaptam ao ambiente.