Como Imprimir Elementos de Array Bash, um por Linha

Introdução

Neste tutorial, exploraremos os arrays Bash e aprenderemos como imprimir cada elemento em uma nova linha - um requisito comum em scripts de shell. Os arrays Bash permitem que você armazene múltiplos valores em uma única variável, tornando-os essenciais para organizar dados em seus scripts.

Ao final deste laboratório, você entenderá como criar arrays, manipular elementos de array e usar diferentes técnicas para imprimir o conteúdo do array, um por linha. Essas habilidades ajudarão você a escrever scripts de shell mais eficientes e legíveis para tarefas como processamento de listas de arquivos, tratamento de saídas de comandos e automatização de tarefas de administração do sistema.

Criando e Compreendendo Arrays Bash

Arrays Bash permitem que você armazene múltiplos valores em uma única variável. Vamos aprender como criá-los e trabalhar com eles.

Criando Seu Primeiro Array

Abra um terminal no WebIDE. Você deve estar no diretório /home/labex/project por padrão. Vamos começar criando um script Bash simples:

1. No WebIDE, crie um novo arquivo chamado array_demo.sh clicando no ícone "New File" no painel do explorador ou usando a opção de menu "File > New File".

2. Adicione o seguinte conteúdo ao arquivo:

#!/bin/bash

## Create an array of fruits
fruits=("apple" "banana" "orange" "grape" "kiwi")

## Print the entire array
echo "All fruits: ${fruits[@]}"

## Print the first element (index 0)
echo "First fruit: ${fruits[0]}"

## Print the third element (index 2)
echo "Third fruit: ${fruits[2]}"

## Print the number of elements in the array
echo "Number of fruits: ${#fruits[@]}"

3. Salve o arquivo pressionando Ctrl+S ou usando a opção de menu "File > Save".

4. Agora, torne o script executável executando este comando no terminal:

chmod +x /home/labex/project/array_demo.sh

5. Execute o script:

./array_demo.sh

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

All fruits: apple banana orange grape kiwi
First fruit: apple
Third fruit: orange
Number of fruits: 5

Compreendendo a Sintaxe de Array

Vamos detalhar a sintaxe do array:

• Criando um array: fruits=("apple" "banana" "orange" "grape" "kiwi")
  Isso cria um array chamado fruits com cinco elementos.

• Acessando todos os elementos: ${fruits[@]}
  O símbolo @ se refere a todos os elementos do array.

• Acessando um elemento específico: ${fruits[0]}, ${fruits[2]}
  Arrays em Bash são indexados a partir de zero, o que significa que o primeiro elemento está no índice 0.

• Obtendo o comprimento do array: ${#fruits[@]}
  O símbolo # antes da referência do array retorna o número de elementos.

Diferentes Maneiras de Criar Arrays

Vamos criar um novo script para demonstrar diferentes maneiras de criar arrays:

1. Crie um novo arquivo chamado array_creation.sh:

#!/bin/bash

## Method 1: Direct declaration
colors=("red" "green" "blue" "yellow")
echo "Colors array: ${colors[@]}"

## Method 2: Individual element assignment
shapes=()
shapes[0]="circle"
shapes[1]="square"
shapes[2]="triangle"
echo "Shapes array: ${shapes[@]}"

## Method 3: Create array from command output
files=($(ls /home/labex/project))
echo "Files in current directory: ${files[@]}"

## Method 4: Create array from a string
data="one two three four"
numbers=($data)
echo "Numbers array: ${numbers[@]}"

2. Salve o arquivo e torne-o executável:

chmod +x /home/labex/project/array_creation.sh

3. Execute o script:

./array_creation.sh

Você deve ver a saída mostrando todos os diferentes arrays que você criou. A saída exata para o array de arquivos dependerá de quais arquivos existem em seu diretório.

Esses exemplos demonstram a flexibilidade dos arrays Bash e como você pode criá-los de diferentes maneiras, dependendo de suas necessidades.

Manipulando Elementos de Array

Agora que sabemos como criar arrays, vamos aprender como manipulá-los adicionando, removendo e modificando elementos.

Modificando Elementos de Array

Vamos criar um novo script para demonstrar a manipulação de arrays:

1. No WebIDE, crie um novo arquivo chamado array_manipulation.sh:

#!/bin/bash

## Create an initial array
fruits=("apple" "banana" "orange")
echo "Initial array: ${fruits[@]}"

## Add an element to the end of the array
fruits+=("grape")
echo "After adding grape: ${fruits[@]}"

## Add multiple elements
fruits+=("kiwi" "mango")
echo "After adding kiwi and mango: ${fruits[@]}"

## Change an element
fruits[1]="blueberry"
echo "After changing banana to blueberry: ${fruits[@]}"

## Remove an element (this leaves an empty slot)
unset fruits[2]
echo "After removing the third element: ${fruits[@]}"

## Print array indices
echo "Array indices: ${!fruits[@]}"

## Recreate array to remove empty slots
new_fruits=()
for fruit in "${fruits[@]}"; do
  if [[ -n "$fruit" ]]; then
    new_fruits+=("$fruit")
  fi
done

fruits=("${new_fruits[@]}")
echo "After removing empty slots: ${fruits[@]}"

2. Salve o arquivo e torne-o executável:

chmod +x /home/labex/project/array_manipulation.sh

3. Execute o script:

./array_manipulation.sh

A saída deve mostrar como o array muda com cada operação:

Initial array: apple banana orange
After adding grape: apple banana orange grape
After adding kiwi and mango: apple banana orange grape kiwi mango
After changing banana to blueberry: apple blueberry orange grape kiwi mango
After removing the third element: apple blueberry  grape kiwi mango
Array indices: 0 1 3 4 5
After removing empty slots: apple blueberry grape kiwi mango

Fatiando Arrays

Vamos explorar como extrair porções de um array:

1. Crie um novo arquivo chamado array_slicing.sh:

#!/bin/bash

## Create a sample array
colors=("red" "orange" "yellow" "green" "blue" "indigo" "violet")
echo "Full array: ${colors[@]}"

## Extract a sub-array (starting index and length)
## Syntax: ${array[@]:start:length}
sub_array1=("${colors[@]:1:3}")
echo "Sub-array (indices 1-3): ${sub_array1[@]}"

## Extract from an index to the end
sub_array2=("${colors[@]:4}")
echo "Sub-array (from index 4 to end): ${sub_array2[@]}"

## Extract the last two elements
sub_array3=("${colors[@]: -2}") ## Note the space before -2
echo "Last two elements: ${sub_array3[@]}"

2. Salve o arquivo e torne-o executável:

chmod +x /home/labex/project/array_slicing.sh

3. Execute o script:

./array_slicing.sh

A saída demonstrará diferentes maneiras de fatiar arrays:

Full array: red orange yellow green blue indigo violet
Sub-array (indices 1-3): orange yellow green
Sub-array (from index 4 to end): blue indigo violet
Last two elements: indigo violet

Encontrando Elementos em Arrays

Vamos criar um script para demonstrar como pesquisar elementos em um array:

1. Crie um novo arquivo chamado array_searching.sh:

#!/bin/bash

## Create a sample array
fruits=("apple" "banana" "orange" "grape" "kiwi")
echo "Our fruits: ${fruits[@]}"

## Function to search for an element in an array
search_array() {
  local needle="$1"
  shift
  local haystack=("$@")

  for i in "${!haystack[@]}"; do
    if [[ "${haystack[$i]}" == "$needle" ]]; then
      echo "Found '$needle' at index $i"
      return 0
    fi
  done

  echo "'$needle' not found in the array"
  return 1
}

## Search for some fruits
search_array "orange" "${fruits[@]}"
search_array "banana" "${fruits[@]}"
search_array "watermelon" "${fruits[@]}"

2. Salve o arquivo e torne-o executável:

chmod +x /home/labex/project/array_searching.sh

3. Execute o script:

./array_searching.sh

A saída mostrará os resultados da pesquisa por diferentes elementos:

Our fruits: apple banana orange grape kiwi
Found 'orange' at index 2
Found 'banana' at index 1
'watermelon' not found in the array

Esses exemplos demonstram as operações comuns que você pode realizar em arrays Bash, que são habilidades essenciais para trabalhar com coleções de dados em seus scripts.

Imprimindo Elementos de Array, um por Linha

Neste passo, vamos focar no tópico principal do nosso laboratório: imprimir elementos de array, um por linha. Vamos explorar diferentes métodos para alcançar isso em Bash.

Método 1: Usando um Loop For

A maneira mais direta de imprimir elementos de array, um por linha, é usando um loop for:

1. Crie um novo arquivo chamado print_array_loop.sh:

#!/bin/bash

## Create a sample array
planets=("Mercury" "Venus" "Earth" "Mars" "Jupiter" "Saturn" "Uranus" "Neptune")

echo "Printing planets using a for loop:"
for planet in "${planets[@]}"; do
  echo "$planet"
done

2. Salve o arquivo e torne-o executável:

chmod +x /home/labex/project/print_array_loop.sh

3. Execute o script:

./print_array_loop.sh

A saída mostrará cada planeta em uma linha separada:

Printing planets using a for loop:
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Método 2: Usando o Comando printf

O comando printf é frequentemente mais eficiente do que usar um loop com echo:

1. Crie um novo arquivo chamado print_array_printf.sh:

#!/bin/bash

## Create a sample array
planets=("Mercury" "Venus" "Earth" "Mars" "Jupiter" "Saturn" "Uranus" "Neptune")

echo "Printing planets using printf:"
printf "%s\n" "${planets[@]}"

2. Salve o arquivo e torne-o executável:

chmod +x /home/labex/project/print_array_printf.sh

3. Execute o script:

./print_array_printf.sh

A saída será a mesma do método anterior:

Printing planets using printf:
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Método 3: Usando a Variável IFS

A variável Internal Field Separator (IFS) pode ser usada para controlar como os elementos do array são impressos:

1. Crie um novo arquivo chamado print_array_ifs.sh:

#!/bin/bash

## Create a sample array
planets=("Mercury" "Venus" "Earth" "Mars" "Jupiter" "Saturn" "Uranus" "Neptune")

echo "Printing planets using IFS:"
## Temporarily change IFS to newline
old_IFS="$IFS"
IFS=$'\n'
echo "${planets[*]}" ## Note: using * instead of @ with IFS
IFS="$old_IFS"       ## Restore original IFS

2. Salve o arquivo e torne-o executável:

chmod +x /home/labex/project/print_array_ifs.sh

3. Execute o script:

./print_array_ifs.sh

A saída mostrará novamente cada planeta em uma linha separada:

Printing planets using IFS:
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Método 4: Combinando Múltiplas Técnicas

Vamos combinar essas técnicas em um exemplo mais abrangente:

1. Crie um novo arquivo chamado print_array_combined.sh:

#!/bin/bash

## Create a sample array
planets=("Mercury" "Venus" "Earth" "Mars" "Jupiter" "Saturn" "Uranus" "Neptune")

echo "Using a for loop with index:"
for i in "${!planets[@]}"; do
  echo "Planet $i: ${planets[$i]}"
done

echo -e "\nUsing printf with formatting:"
printf "Planet: %s - %d letters\n" "${planets[@]}" "${#planets[@]}"

echo -e "\nSorted planets:"
printf "%s\n" "${planets[@]}" | sort

2. Salve o arquivo e torne-o executável:

chmod +x /home/labex/project/print_array_combined.sh

3. Execute o script:

./print_array_combined.sh

A saída mostrará diferentes maneiras de formatar e imprimir elementos de array:

Using a for loop with index:
Planet 0: Mercury
Planet 1: Venus
Planet 2: Earth
Planet 3: Mars
Planet 4: Jupiter
Planet 5: Saturn
Planet 6: Uranus
Planet 7: Neptune

Using printf with formatting:
Planet: Mercury - 8 letters
Planet: Venus - 5 letters
Planet: Earth - 5 letters
Planet: Mars - 4 letters
Planet: Jupiter - 7 letters
Planet: Saturn - 6 letters
Planet: Uranus - 7 letters
Planet: Neptune - 7 letters

Sorted planets:
Earth
Jupiter
Mars
Mercury
Neptune
Saturn
Uranus
Venus

Cada um desses métodos tem suas vantagens:

• O loop for é mais legível para iniciantes
• O método printf é mais eficiente para arrays grandes
• O método IFS é compacto, mas pode ser menos intuitivo
• Técnicas combinadas podem fornecer opções de formatação ricas

Escolha o método que melhor se adapta ao seu caso de uso específico e estilo de codificação.

Aplicações Práticas com Arrays

Nesta etapa final, vamos explorar aplicações do mundo real de arrays Bash e aplicar as técnicas que aprendemos para imprimir elementos, um por linha.

Processando uma Lista de Arquivos

Vamos criar um script que processa arquivos em um diretório:

1. Primeiro, vamos criar alguns arquivos de exemplo para trabalhar:

mkdir -p /home/labex/project/sample_files
touch /home/labex/project/sample_files/file1.txt
touch /home/labex/project/sample_files/file2.txt
touch /home/labex/project/sample_files/file3.txt
touch /home/labex/project/sample_files/image1.jpg
touch /home/labex/project/sample_files/image2.jpg

2. Crie um novo arquivo chamado process_files.sh:

#!/bin/bash

## Get a list of files in the directory
file_path="/home/labex/project/sample_files"
files=($(ls "$file_path"))

echo "All files in directory:"
printf "%s\n" "${files[@]}"

echo -e "\nProcessing text files only:"
text_files=()

## Filter for text files
for file in "${files[@]}"; do
  if [[ "$file" == *.txt ]]; then
    text_files+=("$file")
  fi
done

## Process each text file
if [ ${#text_files[@]} -eq 0 ]; then
  echo "No text files found."
else
  echo "Found ${#text_files[@]} text files:"
  for file in "${text_files[@]}"; do
    echo "Processing $file..."
    ## Here you would typically do something with each file
    echo "  - Adding content to $file"
    echo "This is sample content" > "$file_path/$file"
  done
fi

## Verify the content
echo -e "\nContent of text files:"
for file in "${text_files[@]}"; do
  echo "--- $file ---"
  cat "$file_path/$file"
  echo "------------"
done

3. Salve o arquivo e torne-o executável:

chmod +x /home/labex/project/process_files.sh

4. Execute o script:

./process_files.sh

A saída mostrará como processar e filtrar arquivos usando arrays:

All files in directory:
file1.txt
file2.txt
file3.txt
image1.jpg
image2.jpg

Processing text files only:
Found 3 text files:
Processing file1.txt...
  - Adding content to file1.txt
Processing file2.txt...
  - Adding content to file2.txt
Processing file3.txt...
  - Adding content to file3.txt

Content of text files:
--- file1.txt ---
This is sample content
------------
--- file2.txt ---
This is sample content
------------
--- file3.txt ---
This is sample content
------------

Criando um Sistema de Menu Simples

Arrays podem ser úteis para criar sistemas de menu em scripts:

1. Crie um novo arquivo chamado menu_system.sh:

#!/bin/bash

## Define menu options
options=("List Files" "Check Disk Space" "Display Date" "Display Users" "Exit")

while true; do
  echo -e "\nMenu Options:"
  ## Print menu with numbers
  for i in "${!options[@]}"; do
    echo "  $((i + 1)). ${options[$i]}"
  done

  ## Get user choice
  read -p "Enter your choice (1-${#options[@]}): " choice

  ## Convert to zero-based index
  ((choice--))

  ## Process choice
  case $choice in
    0) ## List Files
      echo -e "\nFiles in current directory:"
      ls -la /home/labex/project
      ;;
    1) ## Check Disk Space
      echo -e "\nDisk space usage:"
      df -h
      ;;
    2) ## Display Date
      echo -e "\nCurrent date and time:"
      date
      ;;
    3) ## Display Users
      echo -e "\nCurrently logged in users:"
      who
      ;;
    4) ## Exit
      echo "Exiting menu system. Goodbye!"
      exit 0
      ;;
    *)
      echo "Invalid choice. Please try again."
      ;;
  esac

  ## Pause before showing menu again
  read -p "Press Enter to continue..."
done

2. Salve o arquivo e torne-o executável:

chmod +x /home/labex/project/menu_system.sh

3. Execute o script:

./menu_system.sh

4. Você verá um sistema de menu. Tente selecionar diferentes opções para ver os resultados. Quando terminar, selecione a opção 5 para sair.

Processando a Saída de Comandos

Arrays são excelentes para processar a saída de comandos:

1. Crie um novo arquivo chamado process_command_output.sh:

#!/bin/bash

## Get a list of running processes
echo "Getting list of processes..."
processes=($(ps -e | awk '{print $4}' | tail -n +2))

echo "Found ${#processes[@]} processes"
echo -e "\nTop 10 processes:"
printf "%s\n" "${processes[@]:0:10}"

## Count unique processes
echo -e "\nCounting unique process names..."
declare -A process_count

for process in "${processes[@]}"; do
  ((process_count["$process"]++))
done

echo -e "\nProcess Count Summary:"
for process in "${!process_count[@]}"; do
  echo "$process: ${process_count["$process"]}"
done | sort -rn -k2 | head -10

2. Salve o arquivo e torne-o executável:

chmod +x /home/labex/project/process_command_output.sh

3. Execute o script:

./process_command_output.sh

A saída mostrará como processar a saída de comandos usando arrays. A saída exata variará dependendo dos processos em execução no seu sistema.

Esses exemplos demonstram como os arrays Bash podem ser usados em cenários do mundo real para resolver problemas práticos. A capacidade de processar listas de itens e imprimi-los em um formato legível é uma habilidade fundamental para a criação de scripts de shell.

Resumo

Neste laboratório, você aprendeu habilidades essenciais para trabalhar com arrays Bash:

1. Criando e Compreendendo Arrays

   • Declarando arrays com diferentes métodos
   • Acessando elementos e propriedades do array

2. Manipulando Elementos do Array

   • Adicionando, removendo e modificando elementos
   • Fatiando arrays e pesquisando elementos

3. Imprimindo Elementos de Array, um por Linha

   • Usando loops for para iterar através de arrays
   • Usando o comando printf para impressão eficiente
   • Aproveitando a variável IFS para formatação personalizada
   • Combinando técnicas para formatação avançada de saída

4. Aplicações Práticas

   • Processando listas de arquivos
   • Criando sistemas de menu
   • Processando a saída de comandos

Essas habilidades fornecem uma base sólida para usar arrays em seus scripts Bash. Agora você pode armazenar, manipular e exibir coleções de dados de forma eficiente, tornando seus scripts mais robustos e versáteis.

Lembre-se que a chave para dominar arrays Bash é a prática. Tente incorporar essas técnicas em seus próprios scripts e explore como elas podem ajudar a resolver problemas do mundo real de forma eficiente.