Shell: Comparação de Arrays e Detecção de Elementos Comuns

Introdução

Neste laboratório, você aprenderá como comparar arrays em scripts Shell. Arrays são estruturas de dados extremamente úteis para armazenar múltiplos valores, e compará-los é uma tarefa rotineira na programação. Você trabalhará com três arrays e desenvolverá um script para identificar os elementos comuns entre eles. Este processo ajudará você a consolidar conhecimentos sobre manipulação de arrays, laços de repetição (loops) e instruções condicionais em Shell Scripting.

Criar o arquivo do script

Primeiro, vamos criar um novo arquivo para o nosso script.

Abra o terminal no WebIDE. Você verá um prompt de comando terminando com o símbolo $.
Navegue até o diretório do projeto:

cd ~/project

Este comando altera o diretório atual para a pasta do projeto. O símbolo ~ representa o seu diretório pessoal (home), e /project é uma subpasta dentro dele.

Crie um novo arquivo chamado array-comparison.sh:

touch array-comparison.sh

O comando touch cria um arquivo vazio. Se o arquivo já existir, ele apenas atualizará a data de modificação do arquivo sem alterar seu conteúdo.

Abra o arquivo no editor do WebIDE. Você pode fazer isso clicando no nome do arquivo no explorador de arquivos localizado no lado esquerdo da interface do WebIDE.

Adicionar a shebang e inicializar os arrays

Agora, vamos começar a escrever nosso script adicionando a shebang e inicializando nossos arrays.

Adicione o seguinte conteúdo ao arquivo array-comparison.sh:

#!/bin/bash

## Initialize the arrays
a=(3 5 8 10 6)
b=(6 5 4 12)
c=(14 7 5 7)

Vamos analisar o que foi feito:

A primeira linha #!/bin/bash é chamada de shebang. Ela instrui o sistema a usar o interpretador Bash para executar este script. Esta linha é fundamental para qualquer script shell.
Em seguida, inicializamos três arrays: a, b e c. No Bash, os arrays são definidos colocando os elementos entre parênteses () e separando-os por espaços.
Cada array contém diferentes valores inteiros. Usaremos esses arrays para encontrar os elementos que se repetem entre eles.

Implementar o primeiro loop de comparação

Vamos implementar o primeiro loop de comparação para encontrar os elementos comuns entre os arrays a e b.

Adicione o seguinte código ao seu script:

## Initialize an array to store common elements between a and b
z=()

## Compare arrays a and b
for x in "${a[@]}"; do
  for y in "${b[@]}"; do
    if [ $x = $y ]; then
      z+=($x)
    fi
  done
done

echo "Common elements between a and b: ${z[@]}"

Explicando o código detalhadamente:

z=() inicializa um array vazio chamado z para armazenar os elementos comuns encontrados.
for x in "${a[@]}" é um loop que percorre cada elemento do array a. A sintaxe "${a[@]}" expande para todos os elementos do array.
Temos então um loop aninhado for y in "${b[@]}" que percorre cada elemento do array b.
if [ $x = $y ] verifica se o elemento atual de a é igual ao elemento atual de b.
Se forem iguais, adicionamos esse elemento ao array z usando o comando z+=($x).
Por fim, exibimos os elementos comuns usando echo "Common elements between a and b: ${z[@]}". A sintaxe ${z[@]} expande todos os elementos do array z.

Implementar o segundo loop de comparação

Agora, vamos implementar o segundo loop de comparação para encontrar os elementos comuns entre o array c e os elementos que já identificamos como comuns entre a e b (armazenados no array z).

Adicione o seguinte código ao seu script:

## Initialize an array to store common elements among a, b, and c
j=()

## Compare array c with the common elements found in z
for i in "${c[@]}"; do
  for k in "${z[@]}"; do
    if [ $i = $k ]; then
      j+=($i)
    fi
  done
done

echo "Common elements among a, b, and c: ${j[@]}"

Este código é similar ao loop anterior, mas com algumas diferenças importantes:

Inicializamos um novo array vazio j para armazenar os elementos comuns finais.
O loop externo for i in "${c[@]}" percorre os elementos do array c.
O loop interno for k in "${z[@]}" percorre os elementos comuns que encontramos entre a e b, que estão guardados no array z.
Comparamos os elementos de c com os de z e, se houver uma correspondência, adicionamos ao array j.
Finalmente, imprimimos os elementos que estão presentes em todos os três arrays.

Tornar o script executável e rodá-lo

Agora que concluímos nosso script, vamos dar permissão de execução e rodá-lo.

No terminal, torne o script executável:

chmod +x ~/project/array-comparison.sh

O comando chmod altera as permissões de um arquivo. A opção +x adiciona permissões de execução, permitindo que você rode o script.

Execute o script:

~/project/array-comparison.sh

Este comando executa o seu script. A parte ~/project/ especifica o caminho exato onde o script está localizado.

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

Common elements between a and b: 5 6
Common elements among a, b, and c: 5

Esta saída mostra que:

Os elementos comuns entre os arrays a e b são 5 e 6.
O único elemento comum entre todos os três arrays (a, b e c) é o 5.

Se você não vir essa saída ou encontrar um erro, verifique novamente o seu script em busca de erros de digitação ou partes ausentes.

Resumo

Neste laboratório, você aprendeu como comparar arrays em Shell Scripting. Você criou um script que identifica elementos comuns entre três arrays utilizando loops aninhados e estruturas condicionais. Este exercício demonstrou conceitos fundamentais, incluindo:

Criação e inicialização de arrays.
Uso de loops aninhados para comparar elementos de arrays.
Aplicação de condicionais para verificar igualdade.
Adição dinâmica de elementos em arrays.
Atribuição de permissões de execução e execução de scripts.

Essas habilidades são essenciais no Shell Scripting e podem ser aplicadas em tarefas de processamento de dados muito mais complexas no futuro. À medida que você continuar explorando scripts Shell, verá que a manipulação de arrays é uma ferramenta poderosa para lidar com conjuntos de dados de forma eficiente.

Lembre-se: a prática é fundamental para dominar esses conceitos. Tente modificar o script para trabalhar com arrays diferentes ou para encontrar elementos únicos em vez de comuns. Bons estudos e boa programação!

Comparando Arrays no Shell