Como imprimir o valor de uma variável em um script de shell - Guia Prático

Introdução

A scripting em shell é uma ferramenta poderosa para automatizar tarefas em ambientes Linux. Uma das habilidades fundamentais na programação em shell é trabalhar com variáveis - locais de armazenamento temporário que contêm dados. Este tutorial irá guiá-lo através do processo de criação de variáveis e impressão de seus valores em scripts de shell. Ao final deste laboratório, você entenderá como declarar variáveis, acessar seus valores e incorporá-las em scripts de shell práticos.

Criando Seu Primeiro Script de Shell com Variáveis

Vamos começar criando um script de shell simples que demonstra como declarar e usar variáveis.

O que são Variáveis de Shell?

Variáveis de shell são locais de armazenamento nomeados que podem conter valores em scripts de shell. Elas permitem que você armazene e recupere dados como strings de texto, números, caminhos de arquivos e saídas de comandos. As variáveis tornam seus scripts mais flexíveis e reutilizáveis.

Criando Seu Primeiro Script

Vamos criar um arquivo de script de shell:

Abra o terminal WebIDE
Navegue até o diretório do projeto (se ainda não estiver lá):
```
cd ~/project
```
Crie um novo arquivo chamado myscript.sh usando o editor WebIDE:
- Clique no ícone "Novo Arquivo" no WebIDE
- Nomeie-o como myscript.sh
- Adicione o seguinte conteúdo ao arquivo:

#!/bin/bash

## Este é meu primeiro script de shell com variáveis

## Declarando uma variável
name="LabEx User"

## Imprimindo a variável
echo "Olá, $name!"

## Imprimindo a data atual usando uma variável
current_date=$(date)
echo "Hoje é: $current_date"

Salve o arquivo pressionando Ctrl+S ou clicando em Arquivo > Salvar
Torne o script executável com o seguinte comando:
```
chmod +x myscript.sh
```
Execute seu script:
```
./myscript.sh
```

Você deve ver uma saída semelhante a esta:

Hello, LabEx User!
Today is: Thu Jul 13 10:30:45 UTC 2023

Entendendo o Script

Vamos detalhar o que aconteceu em nosso script:

A primeira linha #!/bin/bash (chamada de shebang) diz ao sistema para usar o shell Bash para executar o script.
Criamos uma variável chamada name e atribuímos a ela o valor "LabEx User" usando name="LabEx User".
Imprimimos o valor da variável usando echo "Olá, $name!". O símbolo $ antes do nome da variável diz ao shell para substituir o valor da variável.
Criamos outra variável current_date e atribuímos a ela a saída do comando date usando $(date).
Imprimimos o valor da variável current_date.

Regras de Nomenclatura de Variáveis

Ao criar variáveis em scripts de shell, siga estas convenções de nomenclatura:

Os nomes das variáveis podem conter letras, números e sublinhados
Eles devem começar com uma letra ou sublinhado
Nenhum espaço é permitido em torno do sinal de igual ao atribuir valores
Os nomes das variáveis são sensíveis a maiúsculas e minúsculas (NAME, name e Name são três variáveis diferentes)

Tente modificar o script para incluir suas próprias variáveis e executá-lo novamente para ver os resultados.

Diferentes Maneiras de Imprimir Valores de Variáveis

Agora que você entende os conceitos básicos de criação de variáveis, vamos explorar diferentes métodos para imprimir seus valores em scripts de shell.

Usando Aspas Duplas

A maneira mais comum de imprimir variáveis é usando aspas duplas com o comando echo. As aspas duplas permitem que o shell interprete os nomes das variáveis e substitua seus valores.

Crie um novo arquivo chamado print_variables.sh:

Clique no ícone "Novo Arquivo" no WebIDE
Nomeie-o como print_variables.sh
Adicione o seguinte conteúdo:

#!/bin/bash

## Declarando variáveis
name="LabEx"
version=1.0
is_active=true

## Imprimindo variáveis com aspas duplas
echo "Nome da aplicação: $name"
echo "Versão: $version"
echo "Status ativo: $is_active"

## Imprimindo múltiplas variáveis em uma única instrução
echo "A aplicação $name versão $version está $is_active"

Salve o arquivo (Ctrl+S ou Arquivo > Salvar)
Torne-o executável:
```
chmod +x print_variables.sh
```
Execute o script:
```
./print_variables.sh
```

Você deve ver uma saída semelhante a:

Nome da aplicação: LabEx
Versão: 1.0
Status ativo: true
A aplicação LabEx versão 1.0 está true

Usando Chaves

Às vezes, você precisa ser mais preciso sobre onde um nome de variável começa e termina. As chaves ajudam com isso, delineando claramente o nome da variável.

Adicione as seguintes linhas ao seu script print_variables.sh:

## Usando chaves para definir claramente os limites da variável
app="${name}App"
echo "Nome completo da aplicação: $app"

## Isso evita confusão quando você deseja anexar texto diretamente ao valor de uma variável
echo "Nome da aplicação com texto: ${name}Text"

Salve e execute o script novamente:

./print_variables.sh

A saída adicional deve mostrar:

Nome completo da aplicação: LabExApp
Nome da aplicação com texto: LabExText

Usando Aspas Simples

Ao contrário das aspas duplas, as aspas simples impedem a substituição de variáveis e imprimem o texto literal.

Adicione estas linhas ao seu script:

## Usando aspas simples (sem substituição de variável)
echo 'Com aspas simples: $name não é substituído'

## Misturando tipos de aspas para saída complexa
echo "Este é o valor da variável: '$name'"

Salve e execute o script novamente. Você deve ver:

Com aspas simples: $name não é substituído
Este é o valor da variável: 'LabEx'

Usando printf para Saída Formatada

O comando printf oferece mais controle sobre a formatação da sua saída:

## Usando printf para saída formatada
printf "Nome: %s\nVersão: %.1f\n" "$name" "$version"

## Formatando números com printf
number=42.5678
printf "Número formatado: %.2f\n" $number

Salve e execute o script novamente. A saída adicional mostrará:

Nome: LabEx
Versão: 1.0
Número formatado: 42.57

Experimente os diferentes métodos de impressão para ver quais funcionam melhor para suas necessidades.

Criando um Script de Shell Prático com Entrada do Usuário

Agora, vamos criar um script de shell mais prático que recebe a entrada do usuário, armazena-a em variáveis e exibe os resultados.

Lendo a Entrada do Usuário

O comando read permite que seu script aceite a entrada dos usuários. Vamos criar um script de saudação simples:

Crie um novo arquivo chamado greeting.sh:
- Clique no ícone "Novo Arquivo" no WebIDE
- Nomeie-o como greeting.sh
- Adicione o seguinte conteúdo:

#!/bin/bash

## Script de saudação simples que recebe a entrada do usuário

## Solicita o nome do usuário
echo "Qual é o seu nome?"
read username

## Solicita a idade
echo "Quantos anos você tem?"
read age

## Exibe uma saudação com as informações fornecidas
echo "Olá, $username! Você tem $age anos de idade."

## Calcula o ano de nascimento (aproximadamente)
current_year=$(date +%Y)
birth_year=$((current_year - age))

echo "Você nasceu por volta do ano $birth_year."

## Adicionando uma mensagem personalizada com base na idade
if [ $age -lt 18 ]; then
  echo "Você é menor de idade."
elif [ $age -ge 18 ] && [ $age -lt 65 ]; then
  echo "Você é adulto."
else
  echo "Você é idoso."
fi

Salve o arquivo (Ctrl+S ou Arquivo > Salvar)
Torne-o executável:
```
chmod +x greeting.sh
```
Execute o script:
```
./greeting.sh
```
Quando solicitado, insira seu nome e idade. Você deve ver uma saída personalizada com base em sua entrada.

Entendendo os Componentes do Script

Vamos detalhar as partes principais deste script:

O comando read armazena a entrada do usuário em variáveis (username e age).
Usamos as variáveis em instruções echo para criar uma saída personalizada.
Realizamos aritmética usando a sintaxe $((expression)) para calcular o ano de nascimento.
Usamos instruções condicionais (if, elif, else) para fornecer mensagens diferentes com base no valor da idade.
Utilizamos o comando date com opções de formatação para obter o ano atual.

Tornando o Script Mais Interativo

Vamos aprimorar nosso script para torná-lo mais interativo e útil. Adicione o seguinte ao seu arquivo greeting.sh:

## Pergunta se o usuário deseja ver as informações atuais do sistema
echo "Você gostaria de ver algumas informações do sistema? (sim/não)"
read response

## Converte a resposta para minúsculas para facilitar a comparação
response_lower=$(echo "$response" | tr '[:upper:]' '[:lower:]')

if [ "$response_lower" = "yes" ] || [ "$response_lower" = "y" ]; then
  echo "Informações do sistema para o usuário $username:"
  echo "-------------------------------------"
  echo "Hostname: $(hostname)"
  echo "Versão do kernel: $(uname -r)"
  echo "Tempo de atividade do sistema: $(uptime -p)"
  echo "Informações da CPU: $(grep "model name" /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/^[ \t]*//')"
  echo "Memória disponível: $(free -h | grep Mem | awk '{print $7}')"
  echo "-------------------------------------"
else
  echo "Sem problemas, $username. Tenha um ótimo dia!"
fi

Salve o arquivo e execute-o novamente:

./greeting.sh

Siga as instruções e digite "sim" quando for perguntado se você deseja ver as informações do sistema. Você deve ver informações detalhadas sobre o sistema.

Este script demonstra como:

Ler e processar a entrada do usuário
Armazenar e manipular variáveis
Realizar cálculos
Tomar decisões com base nos valores das variáveis
Executar comandos do sistema e armazenar suas saídas em variáveis
Exibir saída formatada para o usuário

Tente modificar o script para adicionar mais recursos interativos ou diferentes tipos de informações do sistema.

Criando um Script de Shell para Operações de Arquivos

Vamos aplicar nosso conhecimento de variáveis de shell para criar um script útil que realiza operações de arquivos. Este script demonstrará como as variáveis podem ajudar a automatizar tarefas de gerenciamento de arquivos.

Criando um Script de Backup

Vamos criar um script que faz um backup de arquivos em um diretório especificado:

Primeiro, vamos criar um diretório de teste e alguns arquivos de exemplo para trabalhar:

mkdir -p ~/project/test_files
echo "This is file 1" > ~/project/test_files/file1.txt
echo "This is file 2" > ~/project/test_files/file2.txt
echo "This is file 3" > ~/project/test_files/file3.txt

Agora, crie um novo arquivo chamado backup.sh:
- Clique no ícone "Novo Arquivo" no WebIDE
- Nomeie-o como backup.sh
- Adicione o seguinte conteúdo:

#!/bin/bash

## Um script para fazer backup de arquivos de um diretório de origem para um diretório de backup

## Definir variáveis para diretórios
source_dir="$HOME/project/test_files"
backup_dir="$HOME/project/backup"
date_stamp=$(date +"%Y%m%d_%H%M%S")
backup_name="backup_$date_stamp"

## Imprimir o propósito do script
echo "Script de Backup de Arquivos"
echo "==================="
echo "Diretório de origem: $source_dir"
echo "Diretório de backup: $backup_dir/$backup_name"

## Criar o diretório de backup se ele não existir
if [ ! -d "$backup_dir" ]; then
  echo "Criando diretório de backup: $backup_dir"
  mkdir -p "$backup_dir"
fi

## Criar um diretório de backup com carimbo de data/hora
mkdir -p "$backup_dir/$backup_name"

## Verificar se o diretório de origem existe
if [ ! -d "$source_dir" ]; then
  echo "Erro: O diretório de origem $source_dir não existe!"
  exit 1
fi

## Contar o número de arquivos no diretório de origem
file_count=$(ls -1 "$source_dir" | wc -l)
echo "Encontrados $file_count arquivos no diretório de origem."

## Copiar os arquivos para o diretório de backup
echo "Copiando arquivos para o local de backup..."
cp -r "$source_dir"/* "$backup_dir/$backup_name"

## Verificar a operação de cópia
copied_count=$(ls -1 "$backup_dir/$backup_name" | wc -l)
echo "Copiados $copied_count arquivos para o diretório de backup."

## Verificar se todos os arquivos foram copiados com sucesso
if [ "$file_count" -eq "$copied_count" ]; then
  echo "Backup concluído com sucesso!"
else
  echo "Aviso: Nem todos os arquivos foram copiados. Verifique se há erros."
fi

## Listar o conteúdo do diretório de backup
echo "Conteúdo do diretório de backup:"
ls -la "$backup_dir/$backup_name"

## Exibir o tamanho total do backup
backup_size=$(du -sh "$backup_dir/$backup_name" | cut -f1)
echo "Tamanho total do backup: $backup_size"

Salve o arquivo (Ctrl+S ou Arquivo > Salvar)
Torne-o executável:
```
chmod +x backup.sh
```
Execute o script:
```
./backup.sh
```

Você deve ver a saída mostrando o processo de backup, incluindo:

Os diretórios de origem e backup
O número de arquivos encontrados
Confirmação da operação de cópia
O conteúdo do diretório de backup
O tamanho total do backup

Entendendo o Script

Este script de backup demonstra vários conceitos importantes:

Uso de variáveis: Usamos variáveis para armazenar caminhos de diretórios, carimbos de data/hora e contagens
Substituição de comando: Usamos a sintaxe $(command) para capturar a saída do comando em variáveis
Instruções condicionais: Usamos instruções if para verificar se os diretórios existem
Manipulação de strings: Criamos um nome de backup exclusivo usando o carimbo de data/hora
Variáveis de caminho: Usamos $HOME para referenciar o diretório home do usuário
Execução de comando: Usamos comandos de shell como mkdir, cp e ls dentro de nosso script
Códigos de saída: Usamos exit 1 para encerrar o script com um status de erro

Aprimorando o Script de Backup

Vamos modificar nosso script para aceitar um diretório de origem personalizado do usuário:

Abra backup.sh no editor
Substitua o conteúdo pelo seguinte:

#!/bin/bash

## Um script para fazer backup de arquivos de um diretório de origem para um diretório de backup

## Verificar se um diretório de origem foi fornecido
if [ $## -eq 0 ]; then
  ## Nenhum argumento fornecido, use o diretório padrão
  source_dir="$HOME/project/test_files"
  echo "Nenhum diretório de origem especificado, usando o padrão: $source_dir"
else
  ## Use o diretório fornecido
  source_dir="$1"
  echo "Usando o diretório de origem especificado: $source_dir"
fi

## Definir variáveis para diretórios
backup_dir="$HOME/project/backup"
date_stamp=$(date +"%Y%m%d_%H%M%S")
backup_name="backup_$date_stamp"

## Imprimir o propósito do script
echo "Script de Backup de Arquivos"
echo "==================="
echo "Diretório de origem: $source_dir"
echo "Diretório de backup: $backup_dir/$backup_name"

## Criar o diretório de backup se ele não existir
if [ ! -d "$backup_dir" ]; then
  echo "Criando diretório de backup: $backup_dir"
  mkdir -p "$backup_dir"
fi

## Criar um diretório de backup com carimbo de data/hora
mkdir -p "$backup_dir/$backup_name"

## Verificar se o diretório de origem existe
if [ ! -d "$source_dir" ]; then
  echo "Erro: O diretório de origem $source_dir não existe!"
  exit 1
fi

## Contar o número de arquivos no diretório de origem
file_count=$(ls -1 "$source_dir" | wc -l)
echo "Encontrados $file_count arquivos no diretório de origem."

## Copiar os arquivos para o diretório de backup
echo "Copiando arquivos para o local de backup..."
cp -r "$source_dir"/* "$backup_dir/$backup_name"

## Verificar a operação de cópia
copied_count=$(ls -1 "$backup_dir/$backup_name" | wc -l)
echo "Copiados $copied_count arquivos para o diretório de backup."

## Verificar se todos os arquivos foram copiados com sucesso
if [ "$file_count" -eq "$copied_count" ]; then
  echo "Backup concluído com sucesso!"
else
  echo "Aviso: Nem todos os arquivos foram copiados. Verifique se há erros."
fi

## Listar o conteúdo do diretório de backup
echo "Conteúdo do diretório de backup:"
ls -la "$backup_dir/$backup_name"

## Exibir o tamanho total do backup
backup_size=$(du -sh "$backup_dir/$backup_name" | cut -f1)
echo "Tamanho total do backup: $backup_size"

Salve o arquivo
Execute o script com um diretório personalizado:
```
./backup.sh ~/project
```

O script aprimorado agora demonstra:

Argumentos de linha de comando usando $1 (o primeiro argumento passado para o script)
Valores padrão quando nenhum argumento é fornecido
Verificação de parâmetros com $# (o número de argumentos)

Este script de backup é um exemplo prático de como as variáveis de shell podem ser usadas para criar ferramentas úteis e flexíveis para automatizar tarefas de gerenciamento de arquivos.

Resumo

Neste laboratório, você aprendeu as habilidades essenciais para trabalhar com variáveis em scripts de shell:

Criando e declarando variáveis de shell
Diferentes maneiras de imprimir valores de variáveis usando echo, printf e aspas
Lendo e processando a entrada do usuário
Realizando cálculos com variáveis de shell
Usando variáveis para operações de arquivos e tarefas de backup
Lidando com argumentos de linha de comando

Essas habilidades formam uma base sólida para a criação de scripts de shell e permitirão que você crie scripts mais dinâmicos e flexíveis para automatizar várias tarefas em um ambiente Linux. À medida que você continua sua jornada de criação de scripts de shell, você pode construir sobre esses conceitos para desenvolver scripts mais complexos para administração de sistemas, gerenciamento de arquivos e tarefas de processamento de dados.