Comment afficher les éléments d'un tableau Bash ligne par ligne

Introduction

Dans ce tutoriel, nous allons explorer les tableaux (arrays) Bash et apprendre à afficher chaque élément sur une nouvelle ligne - une exigence courante en script shell. Les tableaux Bash vous permettent de stocker plusieurs valeurs dans une seule variable, ce qui les rend essentiels pour organiser les données dans vos scripts.

À la fin de ce laboratoire (lab), vous comprendrez comment créer des tableaux, manipuler les éléments des tableaux et utiliser différentes techniques pour afficher le contenu des tableaux un élément par ligne. Ces compétences vous aideront à écrire des scripts shell plus efficaces et plus lisibles pour des tâches telles que le traitement de listes de fichiers, la gestion des sorties de commandes et l'automatisation des tâches d'administration système.

Création et compréhension des tableaux (arrays) Bash

Les tableaux (arrays) Bash vous permettent de stocker plusieurs valeurs dans une seule variable. Apprenons à les créer et à les manipuler.

Création de votre premier tableau

Ouvrez un terminal dans le WebIDE. Vous devriez être par défaut dans le répertoire /home/labex/project. Commençons par créer un simple script Bash :

Dans le WebIDE, créez un nouveau fichier appelé array_demo.sh en cliquant sur l'icône "Nouveau fichier" dans le panneau de l'explorateur ou en utilisant l'option de menu "Fichier > Nouveau fichier".
Ajoutez le contenu suivant au fichier :

#!/bin/bash

## Créer un tableau de fruits
fruits=("apple" "banana" "orange" "grape" "kiwi")

## Afficher le tableau entier
echo "All fruits: ${fruits[@]}"

## Afficher le premier élément (index 0)
echo "First fruit: ${fruits[0]}"

## Afficher le troisième élément (index 2)
echo "Third fruit: ${fruits[2]}"

## Afficher le nombre d'éléments dans le tableau
echo "Number of fruits: ${#fruits[@]}"

Enregistrez le fichier en appuyant sur Ctrl+S ou en utilisant l'option de menu "Fichier > Enregistrer".
Rendez le script exécutable en exécutant cette commande dans le terminal :

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

Exécutez le script :

./array_demo.sh

Vous devriez voir une sortie similaire à ceci :

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

Compréhension de la syntaxe des tableaux

Décortiquons la syntaxe des tableaux :

Création d'un tableau : fruits=("apple" "banana" "orange" "grape" "kiwi") Cela crée un tableau nommé fruits avec cinq éléments.
Accès à tous les éléments : ${fruits[@]} Le symbole @ fait référence à tous les éléments du tableau.
Accès à un élément spécifique : ${fruits[0]}, ${fruits[2]} Les tableaux en Bash sont indexés à partir de zéro, ce qui signifie que le premier élément est à l'index 0.
Obtention de la longueur du tableau : ${#fruits[@]} Le symbole # avant la référence au tableau renvoie le nombre d'éléments.

Différentes façons de créer des tableaux

Créons un nouveau script pour démontrer différentes façons de créer des tableaux :

Créez un nouveau fichier appelé array_creation.sh :

#!/bin/bash

## Méthode 1 : Déclaration directe
colors=("red" "green" "blue" "yellow")
echo "Colors array: ${colors[@]}"

## Méthode 2 : Attribution d'éléments individuels
shapes=()
shapes[0]="circle"
shapes[1]="square"
shapes[2]="triangle"
echo "Shapes array: ${shapes[@]}"

## Méthode 3 : Création d'un tableau à partir de la sortie d'une commande
files=($(ls /home/labex/project))
echo "Files in current directory: ${files[@]}"

## Méthode 4 : Création d'un tableau à partir d'une chaîne de caractères
data="one two three four"
numbers=($data)
echo "Numbers array: ${numbers[@]}"

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./array_creation.sh

Vous devriez voir une sortie montrant tous les différents tableaux que vous avez créés. La sortie exacte pour le tableau des fichiers dépendra des fichiers présents dans votre répertoire.

Ces exemples démontrent la flexibilité des tableaux Bash et comment vous pouvez les créer de différentes manières en fonction de vos besoins.

Manipulation des éléments de tableau (array)

Maintenant que nous savons comment créer des tableaux (arrays), apprenons à les manipuler en ajoutant, en supprimant et en modifiant des éléments.

Modification des éléments de tableau

Créons un nouveau script pour démontrer la manipulation de tableaux :

Dans le WebIDE, créez un nouveau fichier appelé array_manipulation.sh :

#!/bin/bash

## Créer un tableau initial
fruits=("apple" "banana" "orange")
echo "Initial array: ${fruits[@]}"

## Ajouter un élément à la fin du tableau
fruits+=("grape")
echo "After adding grape: ${fruits[@]}"

## Ajouter plusieurs éléments
fruits+=("kiwi" "mango")
echo "After adding kiwi and mango: ${fruits[@]}"

## Changer un élément
fruits[1]="blueberry"
echo "After changing banana to blueberry: ${fruits[@]}"

## Supprimer un élément (cela laisse une case vide)
unset fruits[2]
echo "After removing the third element: ${fruits[@]}"

## Afficher les indices du tableau
echo "Array indices: ${!fruits[@]}"

## Recréer le tableau pour supprimer les cases vides
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[@]}"

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./array_manipulation.sh

La sortie devrait montrer comment le tableau change avec chaque opération :

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

Extraction de sous-tableaux (slicing)

Explorons comment extraire des parties d'un tableau :

Créez un nouveau fichier appelé array_slicing.sh :

#!/bin/bash

## Créer un tableau d'exemple
colors=("red" "orange" "yellow" "green" "blue" "indigo" "violet")
echo "Full array: ${colors[@]}"

## Extraire un sous-tableau (index de départ et longueur)
## Syntaxe : ${array[@]:start:length}
sub_array1=("${colors[@]:1:3}")
echo "Sub-array (indices 1-3): ${sub_array1[@]}"

## Extraire depuis un index jusqu'à la fin
sub_array2=("${colors[@]:4}")
echo "Sub-array (from index 4 to end): ${sub_array2[@]}"

## Extraire les deux derniers éléments
sub_array3=("${colors[@]: -2}") ## Notez l'espace avant -2
echo "Last two elements: ${sub_array3[@]}"

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./array_slicing.sh

La sortie démontrera différentes façons d'extraire des sous-tableaux :

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

Recherche d'éléments dans des tableaux

Créons un script pour démontrer comment rechercher des éléments dans un tableau :

Créez un nouveau fichier appelé array_searching.sh :

#!/bin/bash

## Créer un tableau d'exemple
fruits=("apple" "banana" "orange" "grape" "kiwi")
echo "Our fruits: ${fruits[@]}"

## Fonction pour rechercher un élément dans un tableau
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
}

## Rechercher certains fruits
search_array "orange" "${fruits[@]}"
search_array "banana" "${fruits[@]}"
search_array "watermelon" "${fruits[@]}"

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./array_searching.sh

La sortie montrera les résultats de la recherche de différents éléments :

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

Ces exemples démontrent les opérations courantes que vous pouvez effectuer sur les tableaux Bash, qui sont des compétences essentielles pour travailler avec des collections de données dans vos scripts.

Affichage des éléments d'un tableau ligne par ligne

Dans cette étape, nous allons nous concentrer sur le sujet principal de notre laboratoire (lab) : l'affichage des éléments d'un tableau ligne par ligne. Nous allons explorer différentes méthodes pour y parvenir en Bash.

Méthode 1 : Utilisation d'une boucle for

La manière la plus directe d'afficher les éléments d'un tableau ligne par ligne consiste à utiliser une boucle for :

Créez un nouveau fichier appelé print_array_loop.sh :

#!/bin/bash

## Créer un tableau d'exemple
planets=("Mercury" "Venus" "Earth" "Mars" "Jupiter" "Saturn" "Uranus" "Neptune")

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

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./print_array_loop.sh

La sortie affichera chaque planète sur une ligne distincte :

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

Méthode 2 : Utilisation de la commande printf

La commande printf est souvent plus efficace que l'utilisation d'une boucle avec echo :

Créez un nouveau fichier appelé print_array_printf.sh :

#!/bin/bash

## Créer un tableau d'exemple
planets=("Mercury" "Venus" "Earth" "Mars" "Jupiter" "Saturn" "Uranus" "Neptune")

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

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./print_array_printf.sh

La sortie sera la même que pour la méthode précédente :

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

Méthode 3 : Utilisation de la variable IFS

La variable Internal Field Separator (IFS) peut être utilisée pour contrôler la manière dont les éléments d'un tableau sont affichés :

Créez un nouveau fichier appelé print_array_ifs.sh :

#!/bin/bash

## Créer un tableau d'exemple
planets=("Mercury" "Venus" "Earth" "Mars" "Jupiter" "Saturn" "Uranus" "Neptune")

echo "Printing planets using IFS:"
## Changer temporairement IFS en saut de ligne
old_IFS="$IFS"
IFS=$'\n'
echo "${planets[*]}" ## Note : utilisation de * au lieu de @ avec IFS
IFS="$old_IFS"       ## Restaurer l'IFS original

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./print_array_ifs.sh

La sortie affichera à nouveau chaque planète sur une ligne distincte :

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

Méthode 4 : Combinaison de plusieurs techniques

Combinons ces techniques dans un exemple plus complet :

Créez un nouveau fichier appelé print_array_combined.sh :

#!/bin/bash

## Créer un tableau d'exemple
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

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./print_array_combined.sh

La sortie montrera différentes façons de formater et d'afficher les éléments d'un tableau :

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

Chacune de ces méthodes a ses avantages :

La boucle for est la plus lisible pour les débutants.
La méthode avec printf est plus efficace pour les grands tableaux.
La méthode avec IFS est compacte mais peut être moins intuitive.
Les techniques combinées peuvent offrir de nombreuses options de formatage.

Choisissez la méthode qui convient le mieux à votre cas d'utilisation spécifique et à votre style de codage.

Applications pratiques avec les tableaux (arrays)

Dans cette étape finale, nous allons explorer les applications réelles des tableaux Bash et appliquer les techniques que nous avons apprises pour afficher les éléments ligne par ligne.

Traitement d'une liste de fichiers

Créons un script qui traite les fichiers dans un répertoire :

Tout d'abord, créons quelques fichiers d'exemple avec lesquels travailler :

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

Créez un nouveau fichier appelé process_files.sh :

#!/bin/bash

## Obtenir une liste des fichiers dans le répertoire
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=()

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

## Traiter chaque fichier texte
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..."
    ## Ici, vous feriez généralement quelque chose avec chaque fichier
    echo "  - Adding content to $file"
    echo "This is sample content" > "$file_path/$file"
  done
fi

## Vérifier le contenu
echo -e "\nContent of text files:"
for file in "${text_files[@]}"; do
  echo "--- $file ---"
  cat "$file_path/$file"
  echo "------------"
done

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./process_files.sh

La sortie montrera comment traiter et filtrer les fichiers à l'aide de tableaux :

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
------------

Les tableaux peuvent être utiles pour créer des systèmes de menu dans les scripts :

Créez un nouveau fichier appelé menu_system.sh :

#!/bin/bash

## Définir les options du menu
options=("List Files" "Check Disk Space" "Display Date" "Display Users" "Exit")

while true; do
  echo -e "\nMenu Options:"
  ## Afficher le menu avec des numéros
  for i in "${!options[@]}"; do
    echo "  $((i + 1)). ${options[$i]}"
  done

  ## Obtenir le choix de l'utilisateur
  read -p "Enter your choice (1-${#options[@]}): " choice

  ## Convertir en index basé sur zéro
  ((choice--))

  ## Traiter le choix
  case $choice in
    0) ## Lister les fichiers
      echo -e "\nFiles in current directory:"
      ls -la /home/labex/project
      ;;
    1) ## Vérifier l'espace disque
      echo -e "\nDisk space usage:"
      df -h
      ;;
    2) ## Afficher la date
      echo -e "\nCurrent date and time:"
      date
      ;;
    3) ## Afficher les utilisateurs
      echo -e "\nCurrently logged in users:"
      who
      ;;
    4) ## Quitter
      echo "Exiting menu system. Goodbye!"
      exit 0
      ;;
    *)
      echo "Invalid choice. Please try again."
      ;;
  esac

  ## Pause avant de montrer le menu à nouveau
  read -p "Press Enter to continue..."
done

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./menu_system.sh

Vous verrez un système de menu. Essayez de sélectionner différentes options pour voir les résultats. Lorsque vous avez terminé, sélectionnez l'option 5 pour quitter.

Traitement de la sortie de commandes

Les tableaux sont excellents pour traiter la sortie de commandes :

Créez un nouveau fichier appelé process_command_output.sh :

#!/bin/bash

## Obtenir une liste des processus en cours d'exécution
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}"

## Compter les processus uniques
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

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./process_command_output.sh

La sortie montrera comment traiter la sortie de commandes à l'aide de tableaux. La sortie exacte variera en fonction des processus en cours d'exécution sur votre système.

Ces exemples démontrent comment les tableaux Bash peuvent être utilisés dans des scénarios réels pour résoudre des problèmes pratiques. La capacité à traiter des listes d'éléments et à les afficher dans un format lisible est une compétence fondamentale pour la programmation en shell.

Résumé

Dans ce laboratoire (lab), vous avez appris les compétences essentielles pour travailler avec les tableaux (arrays) Bash :

Création et compréhension des tableaux
- Déclaration de tableaux avec différentes méthodes
- Accès aux éléments et aux propriétés des tableaux
Manipulation des éléments de tableau
- Ajout, suppression et modification d'éléments
- Découpage de tableaux et recherche d'éléments
Affichage des éléments de tableau ligne par ligne
- Utilisation de boucles for pour parcourir les tableaux
- Utilisation de la commande printf pour un affichage efficace
- Exploitation de la variable IFS pour un formatage personnalisé
- Combinaison de techniques pour un formatage avancé de la sortie
Applications pratiques
- Traitement de listes de fichiers
- Création de systèmes de menu
- Traitement de la sortie de commandes

Ces compétences fournissent une solide base pour utiliser les tableaux dans vos scripts Bash. Vous pouvez maintenant stocker, manipuler et afficher efficacement des collections de données, rendant vos scripts plus robustes et polyvalents.

N'oubliez pas que la clé pour maîtriser les tableaux Bash est la pratique. Essayez d'intégrer ces techniques dans vos propres scripts et explorez comment elles peuvent vous aider à résoudre efficacement des problèmes réels.