Como Atribuir e Reatribuir Variáveis no Bash

ShellBeginner
Pratique Agora

Introdução

Este tutorial irá guiá-lo através do processo de atribuição e reatribuição de variáveis no Bash, a popular linguagem de scripting shell. Variáveis são blocos de construção fundamentais em scripts Bash que permitem armazenar e manipular dados. Neste laboratório prático, você aprenderá como declarar variáveis, atribuir valores a elas e usá-las em comandos e scripts. Ao final deste tutorial, você terá uma sólida compreensão de como trabalhar efetivamente com variáveis no Bash, permitindo que você escreva scripts mais poderosos e flexíveis.

Criando e Atribuindo Variáveis Bash

No Bash, variáveis permitem que você armazene dados que podem ser acessados e modificados posteriormente em seu script. Vamos começar criando uma variável simples e atribuindo um valor a ela.

Abra um novo terminal no ambiente LabEx. Você deve estar no diretório /home/labex/project.

Para atribuir um valor a uma variável no Bash, use a seguinte sintaxe:

variable_name=value

Observe que não deve haver espaços ao redor do sinal de igual.

Vamos criar nossa primeira variável:

  1. No terminal, digite o seguinte comando e pressione Enter:
name="John"
  1. Para exibir o valor da variável, use o comando echo com o nome da variável precedido por um cifrão ($):
echo $name

Você deve ver a seguinte saída:

John
  1. Você também pode usar aspas duplas ao redor do nome da variável:
echo "My name is $name"

Saída:

My name is John
  1. Para reatribuir um novo valor à mesma variável, simplesmente use o operador de atribuição (=) novamente:
name="Alice"
echo "My name is $name"

Saída:

My name is Alice

Regras de Nomenclatura de Variáveis

Ao criar variáveis no Bash, siga estas convenções de nomenclatura:

  • Nomes de variáveis podem conter letras, números e underscores (sublinhados)
  • Nomes de variáveis devem começar com uma letra ou underscore
  • Nomes de variáveis são case-sensitive (sensíveis a maiúsculas e minúsculas)
  • Nenhum espaço é permitido em nomes de variáveis

Vamos criar um arquivo para praticar com variáveis. No WebIDE, crie um novo arquivo chamado variables.sh no diretório do projeto:

  1. Clique no ícone "New File" (Novo Arquivo) no IDE
  2. Nomeie o arquivo variables.sh
  3. Adicione o seguinte código ao arquivo:
#!/bin/bash

## Assigning variables
first_name="John"
last_name="Doe"
age=25

## Displaying variables
echo "First name: $first_name"
echo "Last name: $last_name"
echo "Age: $age"

## Reassigning variables
first_name="Jane"
echo "Updated first name: $first_name"
  1. Salve o arquivo pressionando Ctrl+S ou clicando em File → Save (Arquivo → Salvar)

  2. Torne o script executável executando o seguinte comando no terminal:

chmod +x variables.sh
  1. Execute o script com:
./variables.sh

Você deve ver a seguinte saída:

First name: John
Last name: Doe
Age: 25
Updated first name: Jane

Isso demonstra como criar variáveis, atribuir valores a elas e reatribuir novos valores.

Trabalhando com Valores de Variáveis e Operações de String

Nesta etapa, exploraremos diferentes maneiras de trabalhar com valores de variáveis no Bash, incluindo operações de string e cálculos aritméticos.

Operações de String

O Bash oferece várias maneiras de manipular valores de string armazenados em variáveis.

  1. Crie um novo arquivo chamado string_operations.sh no diretório do projeto:
#!/bin/bash

## String concatenation
greeting="Hello"
name="World"
message="$greeting $name"
echo $message

## String length
text="Welcome to Bash scripting"
length=${#text}
echo "The length of '$text' is $length characters"

## Extracting substrings
substring=${text:0:7}
echo "Substring: $substring"

## Converting to uppercase and lowercase
uppercase=${text^^}
lowercase=${text,,}
echo "Uppercase: $uppercase"
echo "Lowercase: $lowercase"
  1. Salve o arquivo e torne-o executável:
chmod +x string_operations.sh
  1. Execute o script:
./string_operations.sh

Você deve ver uma saída semelhante a:

Hello World
The length of 'Welcome to Bash scripting' is 25 characters
Substring: Welcome
Uppercase: WELCOME TO BASH SCRIPTING
Lowercase: welcome to bash scripting

Operações Aritméticas

O Bash também permite que você execute operações aritméticas com variáveis.

  1. Crie um novo arquivo chamado arithmetic_operations.sh no diretório do projeto:
#!/bin/bash

## Assigning numeric values
x=5
y=3

## Basic arithmetic operations
sum=$((x + y))
difference=$((x - y))
product=$((x * y))
quotient=$((x / y))
remainder=$((x % y))

## Display results
echo "x = $x, y = $y"
echo "Sum: $x + $y = $sum"
echo "Difference: $x - $y = $difference"
echo "Product: $x * $y = $product"
echo "Quotient: $x / $y = $quotient"
echo "Remainder: $x % $y = $remainder"

## Increment and decrement
echo "Initial value of x: $x"
x=$((x + 1))
echo "After increment: $x"
x=$((x - 1))
echo "After decrement: $x"

## Compound assignment operators
x+=5
echo "After x+=5: $x"
x-=2
echo "After x-=2: $x"
  1. Salve o arquivo e torne-o executável:
chmod +x arithmetic_operations.sh
  1. Execute o script:
./arithmetic_operations.sh

Você deve ver uma saída semelhante a:

x = 5, y = 3
Sum: 5 + 3 = 8
Difference: 5 - 3 = 2
Product: 5 * 3 = 15
Quotient: 5 / 3 = 1
Remainder: 5 % 3 = 2
Initial value of x: 5
After increment: 6
After decrement: 5
After x+=5: 10
After x-=2: 8

Lendo a Entrada do Usuário em Variáveis

Variáveis também podem armazenar a entrada fornecida pelos usuários. Vamos criar um script que solicita a entrada do usuário:

  1. Crie um arquivo chamado user_input.sh:
#!/bin/bash

## Prompt the user for their name
echo "What is your name?"
read user_name

## Prompt the user for their age
echo "How old are you?"
read user_age

## Display the information
echo "Hello, $user_name! You are $user_age years old."

## Calculate birth year (approximate)
current_year=$(date +%Y)
birth_year=$((current_year - user_age))
echo "You were likely born in $birth_year."
  1. Salve o arquivo e torne-o executável:
chmod +x user_input.sh
  1. Execute o script:
./user_input.sh
  1. Quando solicitado, insira seu nome e idade. O script exibirá uma saudação e calculará seu ano de nascimento aproximado.

Esta etapa mostrou como executar várias operações com variáveis, incluindo manipulação de string, cálculos aritméticos e leitura da entrada do usuário.

Usando Variáveis em Scripts e Comandos

Nesta etapa, exploraremos como usar variáveis de forma eficaz em scripts e comandos Bash. Criaremos um script prático que demonstra o uso de variáveis em vários cenários.

Criando um Script Básico com Variáveis

Vamos criar um script que calcula o custo total de itens em um carrinho de compras:

  1. Crie um novo arquivo chamado shopping_cart.sh no diretório do projeto:
#!/bin/bash

## Initialize variables for items and their prices
item1="Laptop"
price1=999
item2="Headphones"
price2=149
item3="Mouse"
price3=25

## Calculate the total price
total=$((price1 + price2 + price3))

## Display the shopping cart
echo "Shopping Cart:"
echo "-------------"
echo "$item1: \$$price1"
echo "$item2: \$$price2"
echo "$item3: \$$price3"
echo "-------------"
echo "Total: \$$total"

## Apply a discount if the total is over $1000
discount_threshold=1000
discount_rate=10

if [ $total -gt $discount_threshold ]; then
  discount_amount=$((total * discount_rate / 100))
  discounted_total=$((total - discount_amount))
  echo "Discount (${discount_rate}%): -\$$discount_amount"
  echo "Final Total: \$$discounted_total"
fi
  1. Salve o arquivo e torne-o executável:
chmod +x shopping_cart.sh
  1. Execute o script:
./shopping_cart.sh

Você deve ver a seguinte saída:

Shopping Cart:
-------------
Laptop: $999
Headphones: $149
Mouse: $25
-------------
Total: $1173
Discount (10%): -$117
Final Total: $1056

Usando Variáveis com Substituição de Comando

A substituição de comando permite que você capture a saída de um comando e a armazene em uma variável. Vamos criar um script que demonstra isso:

  1. Crie um novo arquivo chamado system_info.sh:
#!/bin/bash

## Get current date and time
current_date=$(date +"%Y-%m-%d")
current_time=$(date +"%H:%M:%S")

## Get system information
hostname=$(hostname)
os_type=$(uname -s)
kernel_version=$(uname -r)
uptime_info=$(uptime -p)
memory_free=$(free -h | awk '/^Mem:/ {print $4}')
disk_free=$(df -h / | awk 'NR==2 {print $4}')

## Display the information
echo "System Information Report"
echo "========================="
echo "Date: $current_date"
echo "Time: $current_time"
echo "Hostname: $hostname"
echo "OS Type: $os_type"
echo "Kernel Version: $kernel_version"
echo "Uptime: $uptime_info"
echo "Free Memory: $memory_free"
echo "Free Disk Space: $disk_free"
  1. Salve o arquivo e torne-o executável:
chmod +x system_info.sh
  1. Execute o script:
./system_info.sh

Você deve ver uma saída semelhante à seguinte (com valores específicos do seu sistema):

System Information Report
=========================
Date: 2023-11-20
Time: 14:30:25
Hostname: labex
OS Type: Linux
Kernel Version: 5.15.0-1015-aws
Uptime: up 2 hours, 15 minutes
Free Memory: 1.2Gi
Free Disk Space: 15G

Usando Variáveis em Loops

Variáveis são particularmente úteis em loops. Vamos criar um script que demonstra isso:

  1. Crie um novo arquivo chamado countdown.sh:
#!/bin/bash

## Get countdown start value from user
echo "Enter a number to start countdown:"
read count

## Validate that input is a number
if [[ ! $count =~ ^[0-9]+$ ]]; then
  echo "Error: Please enter a valid number"
  exit 1
fi

## Perform countdown
echo "Starting countdown from $count:"
while [ $count -gt 0 ]; do
  echo $count
  count=$((count - 1))
  sleep 1
done

echo "Blast off!"
  1. Salve o arquivo e torne-o executável:
chmod +x countdown.sh
  1. Execute o script:
./countdown.sh
  1. Insira um número pequeno (como 5) quando solicitado.

O script fará a contagem regressiva a partir do número que você inseriu, imprimindo cada número e, em seguida, "Blast off!" no final.

Esses exemplos demonstram como as variáveis podem ser usadas em diferentes contextos dentro de scripts Bash, tornando-os mais dinâmicos e flexíveis.

Escopo de Variáveis e Variáveis Especiais

Nesta etapa final, exploraremos o escopo de variáveis no Bash e aprenderemos sobre variáveis especiais que o Bash fornece.

Compreendendo o Escopo de Variáveis

No Bash, as variáveis podem ter diferentes escopos, que determinam onde elas podem ser acessadas:

  1. Variáveis globais: São acessíveis em todo o script.
  2. Variáveis locais: São acessíveis apenas dentro de uma função ou bloco específico.

Vamos criar um script para demonstrar o escopo de variáveis:

  1. Crie um novo arquivo chamado variable_scope.sh:
#!/bin/bash

## Global variable
global_var="I am a global variable"

## Function that demonstrates variable scope
demo_scope() {
  ## Local variable
  local local_var="I am a local variable"

  ## Access global variable
  echo "Inside function: global_var = $global_var"

  ## Access local variable
  echo "Inside function: local_var = $local_var"

  ## Modify global variable
  global_var="Global variable modified"
}

## Main script
echo "Before function call: global_var = $global_var"

## This will fail because local_var doesn't exist yet
echo "Before function call: local_var = $local_var"

## Call the function
demo_scope

## After function call
echo "After function call: global_var = $global_var"

## This will fail because local_var is only accessible within the function
echo "After function call: local_var = $local_var"
  1. Salve o arquivo e torne-o executável:
chmod +x variable_scope.sh
  1. Execute o script:
./variable_scope.sh

Você deve ver uma saída semelhante a:

Before function call: global_var = I am a global variable
Before function call: local_var =
Inside function: global_var = I am a global variable
Inside function: local_var = I am a local variable
After function call: global_var = Global variable modified
After function call: local_var =

Observe que:

  • A variável global global_var é acessível dentro e fora da função.
  • A variável local local_var é acessível apenas dentro da função.
  • As alterações na variável global persistem após o término da função.

Trabalhando com Variáveis Especiais

O Bash fornece várias variáveis especiais que contêm informações específicas. Vamos explorar algumas delas:

  1. Crie um novo arquivo chamado special_variables.sh:
#!/bin/bash

## Special variables demonstration
echo "Script name: $0"
echo "Process ID: $$"
echo "Number of arguments: $#"
echo "All arguments: $@"
echo "Exit status of last command: $?"
echo "Current user: $USER"
echo "Current hostname: $HOSTNAME"
echo "Random number: $RANDOM"

## Function to demonstrate positional parameters
show_params() {
  echo "Function received $## parameters"
  echo "Parameter 1: $1"
  echo "Parameter 2: $2"
  echo "Parameter 3: $3"
}

## Call the function with parameters
echo -e "\nCalling function with parameters:"
show_params apple banana cherry

## Demonstrate positional parameters to the script
echo -e "\nScript positional parameters:"
echo "Parameter 1: $1"
echo "Parameter 2: $2"
echo "Parameter 3: $3"
  1. Salve o arquivo e torne-o executável:
chmod +x special_variables.sh
  1. Execute o script com alguns argumentos:
./special_variables.sh arg1 arg2 arg3

Você deve ver uma saída semelhante a:

Script name: ./special_variables.sh
Process ID: 12345
Number of arguments: 3
All arguments: arg1 arg2 arg3
Exit status of last command: 0
Current user: labex
Current hostname: labex
Random number: 23456

Calling function with parameters:
Function received 3 parameters
Parameter 1: apple
Parameter 2: banana
Parameter 3: cherry

Script positional parameters:
Parameter 1: arg1
Parameter 2: arg2
Parameter 3: arg3

Variáveis de Ambiente

As variáveis de ambiente são variáveis especiais que afetam o comportamento do shell e dos programas. Vamos criar um script para explorá-las:

  1. Crie um novo arquivo chamado environment_variables.sh:
#!/bin/bash

## Display common environment variables
echo "HOME directory: $HOME"
echo "Current user: $USER"
echo "Shell: $SHELL"
echo "Path: $PATH"
echo "Current working directory: $PWD"
echo "Terminal: $TERM"
echo "Language: $LANG"

## Creating and exporting a new environment variable
echo -e "\nCreating a new environment variable:"
MY_VAR="Hello from environment variable"
export MY_VAR
echo "MY_VAR = $MY_VAR"

## Demonstrate that child processes inherit environment variables
echo -e "\nAccessing environment variable from a child process:"
bash -c 'echo "Child process sees MY_VAR = $MY_VAR"'

## Remove the environment variable
echo -e "\nRemoving the environment variable:"
unset MY_VAR
echo "MY_VAR = $MY_VAR (should be empty)"
  1. Salve o arquivo e torne-o executável:
chmod +x environment_variables.sh
  1. Execute o script:
./environment_variables.sh

Você deve ver uma saída mostrando várias variáveis de ambiente e demonstrando como elas podem ser criadas, acessadas e removidas.

Esta etapa mostrou como o escopo de variáveis funciona no Bash e apresentou variáveis especiais que fornecem informações úteis em seus scripts.

Resumo

Neste laboratório, você aprendeu os fundamentos de como trabalhar com variáveis em scripts Bash. Você adquiriu experiência prática com:

  • Criar e atribuir valores a variáveis
  • Trabalhar com operações de strings e cálculos aritméticos
  • Usar variáveis em scripts e comandos
  • Compreender o escopo de variáveis e trabalhar com variáveis especiais

Essas habilidades formam a base da criação de scripts Bash e permitirão que você escreva scripts mais sofisticados e poderosos. As variáveis são uma ferramenta essencial para tornar seus scripts dinâmicos e reutilizáveis, permitindo que eles se adaptem a diferentes entradas e cenários.

Ao continuar sua jornada na criação de scripts Bash, lembre-se destes pontos-chave:

  • Sempre escolha nomes de variáveis descritivos
  • Esteja atento ao escopo das variáveis ao escrever funções
  • Use variáveis especiais para acessar informações úteis em seus scripts
  • Utilize variáveis de ambiente para configuração e personalização

Com essas habilidades, você está agora bem equipado para criar scripts Bash mais complexos para automatizar tarefas e gerenciar seu sistema.