Aula 2.2 — Variáveis e Interação

📦 Variáveis: Declaração, Atribuição e Uso

Variáveis são caixinhas com etiqueta que guardam valores para reutilizar ao longo do script. No Bash, não existe declaração de tipo: basta atribuir um valor com o sinal =. Para acessar o conteúdo, use o prefixo $ antes do nome.

variaveis.sh

#!/bin/bash # Declaração e atribuição — SEM espaços ao redor do = NOME="Maria Silva" IDADE=25 CURSO="Informática" # Uso: prefixe com $ echo "Aluna: $NOME" echo "Idade: $IDADE anos" echo "Curso: $CURSO" Aluna: Maria Silva Idade: 25 anos Curso: Informática

⚠️ Regra de ouro: ❌ NOME = "João" (com espaços) causa erro — o Bash interpreta NOME como um comando. Use sempre NOME="João" sem espaços ao redor do =.

❌ ERRADONOME = "João"
CURSO = "Linux"

✅ CERTONOME="João"
CURSO="Linux"

💡 Aspas simples vs duplas

Aspas duplas (") interpretam variáveis e substituições. Aspas simples (') tratam tudo como literal.

aspas.sh

NOME="Linux" echo "Sistema: $NOME" # interpreta → Sistema: Linux echo 'Sistema: $NOME' # literal → Sistema: $NOME

🏷️ Tipos de Variáveis no Bash

O Bash não exige declaração de tipo, mas é importante entender como os valores são tratados dependendo do contexto em que são usados.

Tipo	Exemplo	Observação
String	`NOME="Alice"`	Texto simples; use aspas se tiver espaços
Número inteiro	`PORTA=8080`	Sem aspas; use `$(( ))` para aritmética
Booleano (convenção)	`ATIVO="true"`	Bash usa strings ou exit codes, não tipo bool nativo
Captura de comando	`DATA=$(date)`	Guarda a saída de um comando

tipos.sh

#!/bin/bash # String SERVIDOR="192.168.1.10" # Número inteiro PORTA=22 TOTAL=$(( 10 + 5 )) # aritmética com $(( )) # Booleano por convenção ATIVO="true" echo "Servidor: $SERVIDOR:$PORTA" echo "Total: $TOTAL" Servidor: 192.168.1.10:22 Total: 15

⭐ Variáveis Especiais do Shell

O Bash define variáveis automáticas que fornecem informações sobre o ambiente de execução e os argumentos recebidos pelo script.

VARIÁVEIS DE AMBIENTE

Variável	Conteúdo
`$HOME`	Pasta home do usuário
`$USER`	Nome do usuário logado
`$PWD`	Diretório atual
`$SHELL`	Shell em uso
`$PATH`	Caminhos de busca de comandos

VARIÁVEIS DE SCRIPT

Variável	Conteúdo
`$0`	Nome do próprio script
`$1`, `$2`...	Argumentos posicionais
`$#`	Quantidade de argumentos
`$@`	Todos os argumentos
`$?`	Exit code do último comando
`$$`	PID do próprio script

argumentos.sh

#!/bin/bash # Uso: ./argumentos.sh João 25 echo "Script: $0" echo "1º argumento: $1" echo "2º argumento: $2" echo "Total de argumentos: $#" # Executando: usuario@servidor:~$ ./argumentos.sh João 25 Script: ./argumentos.sh 1º argumento: João 2º argumento: 25 Total de argumentos: 2

🎤 Leitura de Input com `read`

O comando read pausa o script e aguarda que o usuário digite algo, armazenando o valor em uma variável. É a principal forma de criar scripts interativos.

📥 Uso básico

read-basico.sh

#!/bin/bash echo "Digite seu nome:" read NOME echo "Olá, $NOME!" # Execução: Digite seu nome: João ← usuário digita Olá, João!

⚡ `read -p` — prompt na mesma linha

read-prompt.sh

#!/bin/bash # -p exibe o texto de prompt antes de aguardar input read -p "Seu nome: " NOME read -p "Seu curso: " CURSO echo "Bem-vindo, $NOME do curso $CURSO!"

🔒 `read -s` — entrada silenciosa (senha)

read-senha.sh

#!/bin/bash # -s oculta os caracteres digitados (ideal para senhas) read -p "Usuário: " USUARIO read -s -p "Senha: " SENHA echo # pula linha após senha oculta echo "Autenticando $USUARIO..."

💡 Dica: combine -s e -p juntos (read -s -p "Senha: " SENHA) para pedir a senha com prompt e sem eco. Sempre adicione um echo vazio logo após para pular a linha.

⚙️ Substituição de Comandos e `export`

🔄 Substituição com `$()` e backtick

A substituição de comandos captura a saída de um comando e a insere no lugar. A forma moderna é $(comando); a forma antiga usa backtick (`comando`), ainda válida mas menos legível.

substituicao.sh

#!/bin/bash # Forma moderna — recomendada HOJE=$(date +%d/%m/%Y) USUARIO=$(whoami) ESPACO=$(df -h / | tail -1 | awk '{print $5}') # Forma antiga com backtick (ainda funciona) HOSTNAME=`hostname` echo "Data: $HOJE | Usuário: $USUARIO" echo "Disco usado: $ESPACO | Host: $HOSTNAME" Data: 24/02/2026 | Usuário: aluno Disco usado: 45% | Host: linux-srv

🌍 `export` e variáveis de ambiente

Por padrão, variáveis criadas em um script são locais a ele. O comando export torna a variável visível para processos filhos (subshells e programas iniciados pelo script).

export.sh

#!/bin/bash # Exportar variável para subprocessos export AMBIENTE="producao" # Adicionar diretório ao PATH do sistema export PATH=$PATH:/opt/bin # Verificar valor exportado echo "Ambiente: $AMBIENTE" echo "PATH inclui /opt/bin agora" usuario@servidor:~$ printenv AMBIENTE producao

📌 Quando usar export? Use quando um programa externo ou script filho precisar ler a variável. Variáveis sem export são invisíveis fora do script atual.

🚦 Exit Codes — Códigos de Saída

Todo comando Linux retorna um exit code (código de saída) ao terminar: 0 indica sucesso; qualquer valor entre 1 e 255 indica algum tipo de erro ou condição especial. A variável especial $? sempre guarda o exit code do último comando executado.

exit-codes.sh

usuario@servidor:~$ touch arquivo.txt usuario@servidor:~$ echo $? 0 # sucesso! usuario@servidor:~$ ls /pasta_inexistente ls: cannot access '/pasta_inexistente': No such file or directory usuario@servidor:~$ echo $? 2 # erro!

Código	Significado
`0`	Sucesso — comando executou sem erros
`1`	Erro genérico
`2`	Uso incorreto do comando
`126`	Permissão negada (arquivo não executável)
`127`	Comando não encontrado
`130`	Processo cancelado pelo usuário (Ctrl+C)

📝 Usando exit code em scripts

script-exit.sh

#!/bin/bash # Salve o $? imediatamente após o comando de interesse grep "root" /etc/passwd RESULTADO=$? # salva antes que outro comando sobrescreva echo "grep retornou: $RESULTADO" # Sinalizando sucesso ou erro ao final do script exit 0 # 0 = tudo ok # exit 1 # descomente para sinalizar erro

⚠️ Armadilha comum: $? é sobrescrito a cada comando executado. Se precisar do exit code de um comando, salve-o em uma variável imediatamente: CODIGO=$?.

👤 Script Completo: Cadastro de Usuário

Veja todos os conceitos da aula combinados em um script real que coleta dados do usuário, usa variáveis especiais, exibe resumo e sinaliza o resultado com exit code.

cadastro.sh

#!/bin/bash ################################################## # cadastro.sh — Cadastro simples de usuário # Uso: ./cadastro.sh ################################################## DATA_HORA=$(date +"%d/%m/%Y %H:%M") clear echo "╔════════════════════════════╗" echo "║ CADASTRO DE USUÁRIO ║" echo "╚════════════════════════════╝" echo read -p "Nome completo: " NOME read -p "E-mail: " EMAIL read -s -p "Senha: " SENHA echo echo echo "=== RESUMO DO CADASTRO ===" echo "Nome: $NOME" echo "Email: $EMAIL" echo "Data: $DATA_HORA" echo "PID do script: $$" echo "Cadastro concluído com sucesso!" exit 0 # sinaliza sucesso

💡 Boas práticas: nomes de variáveis em MAIUSCULO por convenção; salve o $? imediatamente após o comando relevante; use exit 0 para indicar sucesso e exit 1 (ou outro valor) para erros.

🎯 Exercício — Arraste e Conecte

Arraste cada descrição para o comando ou conceito correto de variáveis e interação.

Descrição

Declara variável de string

Lê input do usuário com prompt

Mostra o código de saída do último comando

Usa variável dentro de string

Número de argumentos passados ao script

Adiciona diretório ao PATH do sistema

Comando / Conceito

NOME="João"

read -p "Digite seu nome: " NOME

echo $?

echo "Olá, $NOME!"

$#

export PATH=$PATH:/opt/bin

🛠️ Atividade Prática — Script de Cadastro de Usuário

⏱ ~35 min 💻 Ubuntu Server / Terminal 📸 Tirar screenshot da saída

1

Crie o script que pede nome e e-mail

No terminal: vim ~/scripts/cadastro.sh. Pressione i e escreva o shebang (#!/bin/bash), comentário de cabeçalho e dois read -p: um para NOME e outro para EMAIL. Salve com Esc :wq.

2

Valide se os campos estão preenchidos

Após o read de cada campo, adicione uma verificação simples: [ -z "$NOME" ] && echo "ERRO: Nome obrigatório!" && exit 1 Faça o mesmo para EMAIL. Isso usa operadores de string para checar campo vazio.

3

Exiba o resumo com as variáveis

Adicione ao final do script:

DATA=$(date +"%d/%m/%Y %H:%M")
echo "=== RESUMO ==="
echo "Nome:  $NOME"
echo "Email: $EMAIL"
echo "Data:  $DATA"

Use aspas duplas para garantir a interpretação das variáveis.

4

Use exit code para indicar sucesso

Na última linha do script, adicione exit 0. Dê permissão e execute: chmod +x ~/scripts/cadastro.sh && ~/scripts/cadastro.sh. Após a execução, execute echo $? e confirme que retorna 0.

5

Teste com argumentos posicionais

Crie uma versão alternativa que recebe nome via argumento:

NOME=$1
echo "Olá, $NOME! (via argumento $0)"
echo "Total de argumentos: $#"

Execute: ./cadastro.sh "João Silva" e verifique as variáveis especiais.

6

Use export para configurar ambiente

Adicione ao início do script:

export APP_ENV="dev"
export LOG_DIR="$HOME/logs"
mkdir -p "$LOG_DIR"
echo "Ambiente: $APP_ENV"

Verifique que printenv APP_ENV mostra o valor dentro do script e que a pasta de log foi criada.

📌 Para refletir: Variáveis transformam scripts estáticos em ferramentas dinâmicas. Com read, o mesmo script serve para dados diferentes a cada execução. Com exit codes, outros scripts e sistemas de monitoramento conseguem saber se tudo correu bem — a base da automação profissional.

❓ Verifique seu Conhecimento

Como se declara corretamente uma variável em Bash?

Avar nome = "João"

Bnome="João"

C$nome = "João"

Dset nome "João"

✓ Em Bash, sem espaços ao redor do =: nome="João". Para usar: $nome ou ${nome}.

Qual variável especial contém o código de saída do último comando?

A$0

B$#

C$?

D$@

✓ $? retorna 0 se o último comando teve sucesso, ou um valor diferente em caso de erro.

Qual comando lê uma entrada digitada pelo usuário e armazena em uma variável?

Aread nome

Binput nome

Cscan nome

Dget nome

✓ read variavel aguarda o usuário digitar e pressionar Enter. Use read -p "Mensagem: " var para exibir um prompt.

O que representa $1 em um script Bash?

AO nome do script

BO PID do script

CO total de argumentos passados

DO primeiro argumento passado na linha de comando

✓ $1 é o primeiro argumento, $2 o segundo... $0 é o nome do script, $# é a quantidade de argumentos.

📝 Variáveis e Interação com Usuário