Dia 16/30 — Argumentos, Status de Saída e Lógica Básica em Scripts

Hoje é o Dia 16 do desafio de 30 dias estudando Linux, com foco na certificação Linux Essentials — LPI 010-160 e na construção de uma base prática para atuar com Suporte Técnico em TI.

Hoje o script deixa de ser uma lista fixa de comandos e começa a receber dados de quem o executa. Também vamos usar códigos de saída para entender sucesso ou falha.

📌 Metodologia do projeto:
Teoria → Exercício → Prática → Explicar → Revisar

🎯 Objetivos do dia

Objetivo LPI: 3.3 — Transformando comandos em scripts
Peso no exame: 4
Entender o conceito, executar os comandos no terminal e saber explicar o motivo de cada resultado.
Relacionar o conteúdo da prova com situações reais de suporte Linux.

💻 Ambiente recomendado: Debian/Ubuntu em máquina virtual ou máquina de estudos.
Evite praticar comandos destrutivos como rm e alterações administrativas no seu sistema principal.

🚀 UPLinux.com.br - prática complementar

Durante esta jornada, uso a plataforma UP Linux para revisar questões e executar desafios práticos:

👉 https://uplinux.com.br

Use a plataforma depois da leitura para reforçar o conteúdo com repetição espaçada e exercícios.

🧠 TEORIA

1. Argumentos posicionais

./script.sh primeiro segundo

Dentro do script:

Variável	Conteúdo
`$0`	nome usado para chamar o script
`$1`	primeiro argumento
`$2`	segundo argumento
`$#`	quantidade de argumentos
`$@`	todos os argumentos

2. Exit status

Todo comando retorna um número.

true
echo $?   # 0

false
echo $?   # diferente de 0

Convencionalmente:

0 = sucesso;
valor diferente de 0 = falha/condição não atendida.

3. `exit`

exit 0
exit 1

Um script pode terminar retornando explicitamente um código.

4. Teste simples com `if`

Embora o objetivo destaque argumentos, loops e status de saída, entender uma condição simples torna o laboratório mais real.

if [ -f "$1" ]; then
    echo "Arquivo existe"
else
    echo "Arquivo não existe"
    exit 1
fi

5. Quoting em scripts

Sempre que um argumento puder conter espaços, proteja a expansão:

cp "$1" "$2"

Isso evita que Relatorio Final.txt seja dividido em vários argumentos.

💻 PRÁTICA GUIADA

Crie:

mkdir -p ~/linux-lab/dia16
cd ~/linux-lab/dia16
cat > verifica.sh <<'EOF'
#!/bin/bash

echo "Script: $0"
echo "Quantidade de argumentos: $#"
echo "Primeiro argumento: $1"

if [ -f "$1" ]; then
    echo "OK: arquivo encontrado"
    exit 0
else
    echo "ERRO: arquivo não encontrado"
    exit 1
fi
EOF

chmod +x verifica.sh

Teste:

touch teste.txt
./verifica.sh teste.txt
echo $?

./verifica.sh inexistente.txt
echo $?

Teste nome com espaço:

touch "Relatorio Final.txt"
./verifica.sh "Relatorio Final.txt"

✏️ EXERCÍCIOS

Crie ola.sh que receba um nome em $1.
Faça o script mostrar quantos argumentos foram fornecidos.
Faça um script retornar exit 2 e confirme com echo $?.
Execute verifica.sh sem argumento e observe o comportamento.
Explique por que "$1" é mais seguro que $1 sem aspas.

🗣️ EXPLICAR COM SUAS PALAVRAS

Explique:

diferença entre $0 e $1;
significado de $# e $@;
por que 0 representa sucesso no shell;
como && e || aproveitam o exit status;
por que um script pode terminar antes do final usando exit.

🧪 MINI SIMULADO

1. O que contém $1?

✅ O primeiro argumento posicional.

2. O que contém $#?

✅ A quantidade de argumentos.

3. O que significa exit status 0?

✅ Sucesso.

4. Como ver o status do último comando?

✅ echo $?.

5. O que faz exit 1?

✅ Termina o script retornando status 1.

6. Por que escrever "$1"?

✅ Para preservar o argumento como uma unidade mesmo com espaços ou caracteres especiais.

7. $0 normalmente representa?

✅ O nome/caminho usado para chamar o script.

8. cmd1 && cmd2 executa cmd2 quando?

✅ Quando cmd1 retorna sucesso (0).

✅ CHECKLIST DO DIA

Sei usar $0, $1, $2, $# e $@
Entendo exit status
Sei consultar $?
Sei encerrar script com exit
Entendo a importância de "$1"
Consigo escrever um teste simples de existência de arquivo

📅 Próximo passo — Dia 17

No próximo dia: Loops for e revisão completa do Tópico 3.

📚 Referências

Regra da jornada: não apenas leia os comandos. Digite, observe a saída, provoque erros controlados e tente explicar o comportamento antes de consultar a resposta.