Comment supprimer les éléments correspondants d'un tableau Bash

Introduction

Ce tutoriel vous guidera à travers le processus de suppression d'éléments correspondants des tableaux Bash, une compétence fondamentale en programmation shell. Les tableaux vous permettent de stocker plusieurs valeurs dans une seule variable, ce qui les rend essentiels pour la gestion des collections de données dans vos scripts.

À la fin de ce tutoriel, vous comprendrez comment créer, manipuler et modifier efficacement les tableaux Bash, en mettant l'accent sur la suppression d'éléments spécifiques qui correspondent à certains critères. Ces compétences vous aideront à écrire des scripts Bash plus efficaces et plus puissants pour diverses tâches d'automatisation.

Création et utilisation des tableaux Bash

Avant d'apprendre à supprimer des éléments des tableaux, comprenons d'abord comment créer et utiliser les tableaux Bash.

Création de votre premier tableau

Ouvrez votre terminal dans l'environnement LabEx. Commençons par créer un simple tableau de fruits :

fruits=("apple" "banana" "cherry" "orange" "apple")

Cette commande crée un tableau nommé fruits contenant cinq éléments. Remarquez que "apple" apparaît deux fois - cela sera utile lorsque nous pratiquerons la suppression d'éléments correspondants plus tard.

Affichage des éléments du tableau

Pour afficher tous les éléments du tableau, utilisez :

echo "${fruits[@]}"

Vous devriez voir une sortie affichant tous les éléments :

apple banana cherry orange apple

Pour afficher un élément spécifique, vous pouvez spécifier son index (n'oubliez pas que les indices de tableau commencent à 0 dans Bash) :

echo "${fruits[0]}" ## Affiche le premier élément : apple
echo "${fruits[1]}" ## Affiche le deuxième élément : banana

Vérification de la longueur du tableau

Pour savoir combien d'éléments se trouvent dans votre tableau :

echo "${#fruits[@]}"

Cela devrait afficher 5, qui est le nombre total d'éléments dans notre tableau de fruits.

Ajout d'éléments à un tableau

Vous pouvez ajouter de nouveaux éléments à un tableau existant en utilisant l'opérateur += :

fruits+=("grape")
echo "${fruits[@]}"

La sortie devrait maintenant inclure "grape" à la fin :

apple banana cherry orange apple grape

Création d'un fichier de travail

Créons un fichier où nous allons pratiquer nos opérations sur les tableaux. Dans le WebIDE, créez un nouveau fichier nommé array_operations.sh dans le répertoire /home/labex/project en cliquant sur l'icône "New File" dans le panneau de l'explorateur de fichiers.

Ajoutez le code suivant au fichier :

#!/bin/bash

## Define our fruits array
fruits=("apple" "banana" "cherry" "orange" "apple" "grape")

## Display all elements
echo "All fruits in the array:"
echo "${fruits[@]}"

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

## Display the first element
echo "First fruit: ${fruits[0]}"

Enregistrez le fichier (Ctrl+S ou en utilisant le menu) et rendez-le exécutable :

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

Maintenant, exécutez votre script :

./array_operations.sh

Vous devriez voir une sortie affichant les éléments du tableau, le nombre et le premier élément :

All fruits in the array:
apple banana cherry orange apple grape
Number of fruits: 6
First fruit: apple

Félicitations ! Vous avez créé votre premier tableau Bash et effectué des opérations de base dessus. Dans les prochaines étapes, nous allons apprendre à supprimer des éléments spécifiques des tableaux.

Suppression d'éléments à l'aide d'une boucle for et de unset

Maintenant que vous comprenez les bases des tableaux Bash, explorons comment supprimer des éléments correspondants d'un tableau. Nous commencerons par la méthode la plus simple utilisant une boucle for et la commande unset.

Comprendre la commande unset

La commande unset dans Bash vous permet de supprimer des éléments d'un tableau en spécifiant leurs indices. Par exemple, pour supprimer le premier élément de notre tableau fruits :

unset fruits[0]
echo "${fruits[@]}"

L'exécution de ceci affichera :

banana cherry orange apple grape

Remarquez que le premier "apple" a été supprimé, mais les indices du tableau ne sont pas automatiquement réordonnés. Cela signifie qu'après avoir supprimé un élément, le tableau peut avoir des "trous" dans sa séquence d'indices.

Suppression d'éléments correspondants avec une boucle for

Créons un nouveau script pour supprimer toutes les occurrences de "apple" de notre tableau fruits. Dans le WebIDE, créez un nouveau fichier nommé remove_elements.sh dans le répertoire /home/labex/project :

#!/bin/bash

## Define our fruits array
fruits=("apple" "banana" "cherry" "orange" "apple" "grape")

echo "Original array: ${fruits[@]}"

## Loop through the array indices in reverse order
for ((i = ${#fruits[@]} - 1; i >= 0; i--)); do
  if [ "${fruits[$i]}" == "apple" ]; then
    unset "fruits[$i]"
  fi
done

## Print the modified array
echo "Array after removing 'apple': ${fruits[@]}"

## Reindex the array to remove gaps (optional)
fruits=("${fruits[@]}")
echo "Array after reindexing: ${fruits[@]}"

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./remove_elements.sh

Vous devriez voir une sortie similaire à :

Original array: apple banana cherry orange apple grape
Array after removing 'apple': banana cherry orange grape
Array after reindexing: banana cherry orange grape

Comprendre le code

Examinons ce que fait notre script :

1. Nous avons défini un tableau appelé fruits avec différents noms de fruits, y compris deux instances de "apple".
2. Nous avons parcouru les indices du tableau en ordre inverse (pour éviter les problèmes de décalage d'index lors de la suppression d'éléments).
3. Pour chaque élément, nous avons vérifié s'il était égal à "apple" et l'avons supprimé si c'était le cas.
4. Après avoir supprimé tous les éléments correspondants, nous avons réindexé le tableau pour éliminer tout écart dans la séquence d'indices.

Remarquez que nous avons parcouru le tableau en ordre inverse. Ceci est important lors de la suppression d'éléments car si nous supprimions des éléments tout en itérant vers l'avant, les indices des éléments restants seraient décalés, ce qui pourrait nous amener à sauter certains éléments.

Expérimenter avec différentes valeurs

Modifions notre script pour permettre la suppression de tout fruit spécifié par l'utilisateur. Modifiez le fichier remove_elements.sh pour qu'il ressemble à ceci :

#!/bin/bash

## Define our fruits array
fruits=("apple" "banana" "cherry" "orange" "apple" "grape")

## If no argument provided, default to removing "apple"
fruit_to_remove=${1:-"apple"}

echo "Original array: ${fruits[@]}"
echo "Removing: $fruit_to_remove"

## Loop through the array indices in reverse order
for ((i = ${#fruits[@]} - 1; i >= 0; i--)); do
  if [ "${fruits[$i]}" == "$fruit_to_remove" ]; then
    unset "fruits[$i]"
  fi
done

## Print the modified array
echo "Array after removing '$fruit_to_remove': ${fruits[@]}"

## Reindex the array to remove gaps
fruits=("${fruits[@]}")
echo "Array after reindexing: ${fruits[@]}"

Enregistrez le fichier et exécutez-le avec différents arguments :

./remove_elements.sh banana

Vous devriez voir une sortie montrant que "banana" a été supprimé :

Original array: apple banana cherry orange apple grape
Removing: banana
Array after removing 'banana': apple cherry orange apple grape
Array after reindexing: apple cherry orange apple grape

Essayez avec d'autres noms de fruits dans notre tableau :

./remove_elements.sh orange

Excellent travail ! Vous avez appris à supprimer des éléments correspondants d'un tableau Bash en utilisant une boucle for et la commande unset. Dans la prochaine étape, nous explorerons d'autres méthodes pour supprimer des éléments des tableaux.

Méthodes alternatives pour la suppression d'éléments

Bien que la boucle for avec unset soit une approche courante pour supprimer des éléments des tableaux, Bash offre d'autres méthodes qui peuvent être plus concises ou efficaces dans certaines situations. Explorons deux approches alternatives.

Méthode 1 : Création d'un nouveau tableau avec des éléments filtrés

Au lieu de supprimer des éléments d'un tableau existant, nous pouvons créer un nouveau tableau qui inclut uniquement les éléments que nous souhaitons conserver. Cette approche évite d'avoir à réindexer le tableau après la suppression d'éléments.

Créez un nouveau fichier nommé filter_array.sh dans le répertoire /home/labex/project :

#!/bin/bash

## Define our fruits array
fruits=("apple" "banana" "cherry" "orange" "apple" "grape")

## If no argument provided, default to removing "apple"
fruit_to_remove=${1:-"apple"}

echo "Original array: ${fruits[@]}"
echo "Removing: $fruit_to_remove"

## Create a new array without the matching elements
declare -a filtered_fruits
for fruit in "${fruits[@]}"; do
  if [ "$fruit" != "$fruit_to_remove" ]; then
    filtered_fruits+=("$fruit")
  fi
done

## Print the filtered array
echo "Array after removing '$fruit_to_remove': ${filtered_fruits[@]}"

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./filter_array.sh

Vous devriez voir une sortie comme :

Original array: apple banana cherry orange apple grape
Removing: apple
Array after removing 'apple': banana cherry orange grape

Méthode 2 : Utilisation du modèle de remplacement de tableau

Bash fournit une syntaxe d'expansion de paramètre puissante qui peut être utilisée pour filtrer les tableaux. Implémentons cette méthode dans un nouveau script.

Créez un fichier nommé pattern_remove.sh dans le répertoire /home/labex/project :

#!/bin/bash

## Define our fruits array
fruits=("apple" "banana" "cherry" "orange" "apple" "grape")

## If no argument provided, default to removing "apple"
fruit_to_remove=${1:-"apple"}

echo "Original array: ${fruits[@]}"
echo "Removing: $fruit_to_remove"

## Create a temporary array to store valid indices
declare -a indices=()
for i in "${!fruits[@]}"; do
  if [ "${fruits[$i]}" != "$fruit_to_remove" ]; then
    indices+=("$i")
  fi
done

## Create the filtered array using the valid indices
declare -a filtered_fruits=()
for i in "${indices[@]}"; do
  filtered_fruits+=("${fruits[$i]}")
done

## Print the filtered array
echo "Array after removing '$fruit_to_remove': ${filtered_fruits[@]}"

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script :

./pattern_remove.sh grape

Vous devriez voir une sortie avec "grape" supprimé :

Original array: apple banana cherry orange apple grape
Removing: grape
Array after removing 'grape': apple banana cherry orange apple

Comparaison des méthodes

Créons un script récapitulatif qui compare les trois méthodes. Créez un fichier nommé compare_methods.sh dans le répertoire /home/labex/project :

#!/bin/bash

## Define our test array
fruits=("apple" "banana" "cherry" "orange" "apple" "grape")
fruit_to_remove=${1:-"apple"}

echo "Original array: ${fruits[@]}"
echo "Removing: $fruit_to_remove"
echo ""

## Method 1: Using for loop and unset
echo "Method 1: Using for loop and unset"
declare -a fruits_copy=("${fruits[@]}")
for ((i = ${#fruits_copy[@]} - 1; i >= 0; i--)); do
  if [ "${fruits_copy[$i]}" == "$fruit_to_remove" ]; then
    unset "fruits_copy[$i]"
  fi
done
fruits_copy=("${fruits_copy[@]}")
echo "Result: ${fruits_copy[@]}"
echo ""

## Method 2: Creating a new filtered array
echo "Method 2: Creating a new filtered array"
declare -a filtered_fruits=()
for fruit in "${fruits[@]}"; do
  if [ "$fruit" != "$fruit_to_remove" ]; then
    filtered_fruits+=("$fruit")
  fi
done
echo "Result: ${filtered_fruits[@]}"
echo ""

## Method 3: Using array indices
echo "Method 3: Using array indices"
declare -a indices_filtered=()
for i in "${!fruits[@]}"; do
  if [ "${fruits[$i]}" != "$fruit_to_remove" ]; then
    indices_filtered+=("${fruits[$i]}")
  fi
done
echo "Result: ${indices_filtered[@]}"

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script avec différents fruits à supprimer :

./compare_methods.sh banana

Vous devriez voir une comparaison des trois méthodes :

Original array: apple banana cherry orange apple grape
Removing: banana

Method 1: Using for loop and unset
Result: apple cherry orange apple grape

Method 2: Creating a new filtered array
Result: apple cherry orange apple grape

Method 3: Using array indices
Result: apple cherry orange apple grape

Les trois méthodes atteignent le même objectif, mais chacune a ses avantages :

• Méthode 1 (boucle for avec unset) modifie le tableau d'origine en place
• Méthode 2 (création d'un nouveau tableau) est souvent plus claire et évite les problèmes de décalage d'index
• Méthode 3 (utilisation des indices de tableau) peut être utile lorsque vous devez conserver le tableau d'origine

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

Exercice pratique : Création d'un script de nettoyage de fichiers

Maintenant que vous comprenez les différentes méthodes de suppression d'éléments des tableaux Bash, appliquons ces connaissances à une situation pratique. Nous allons créer un script qui aide à nettoyer un répertoire en filtrant des types de fichiers spécifiques.

Le défi du nettoyage de fichiers

Imaginez que vous avez un répertoire contenant différents types de fichiers (fichiers texte, images, documents) et que vous souhaitez supprimer sélectivement certains types de fichiers. Nous utiliserons un tableau Bash pour gérer ces fichiers et appliquer nos connaissances en matière de filtrage de tableaux.

Étape 1 : Configuration d'un répertoire de test avec des exemples de fichiers

Tout d'abord, créons un répertoire de test avec quelques exemples de fichiers. Ouvrez votre terminal et exécutez :

mkdir -p /home/labex/project/test_files
cd /home/labex/project/test_files

## Create some sample files
touch file1.txt file2.txt document1.pdf document2.pdf image1.jpg image2.jpg script.sh config.yaml

Vérifiez que les fichiers ont été créés :

ls -la

Vous devriez voir la liste des exemples de fichiers que nous venons de créer.

Étape 2 : Création du script de nettoyage de fichiers

Créons maintenant notre script qui utilisera les opérations de tableau pour filtrer les fichiers. Créez un nouveau fichier nommé cleanup_files.sh dans le répertoire /home/labex/project :

#!/bin/bash

## Directory to scan
target_dir=${1:-"/home/labex/project/test_files"}
## File extension to filter out
extension_to_remove=${2:-"txt"}

echo "Scanning directory: $target_dir"
echo "Will remove files with extension: $extension_to_remove"

## Change to the target directory
cd "$target_dir" || {
  echo "Directory not found!"
  exit 1
}

## Get all files in the directory
all_files=(*)

echo "All files: ${all_files[@]}"

## Create an array to store files to keep
declare -a files_to_keep=()

## Filter out files with the specified extension
for file in "${all_files[@]}"; do
  if [[ "$file" != *.$extension_to_remove ]]; then
    files_to_keep+=("$file")
  fi
done

echo "Files to keep: ${files_to_keep[@]}"

## Create an array of files to remove
declare -a files_to_remove=()
for file in "${all_files[@]}"; do
  if [[ "$file" == *.$extension_to_remove ]]; then
    files_to_remove+=("$file")
  fi
done

echo "Files that would be removed: ${files_to_remove[@]}"

## Ask for confirmation before removing
echo
echo "This script is in simulation mode and won't actually delete any files."
echo "In a real scenario, you would ask for confirmation before deletion:"
echo "read -p 'Are you sure you want to remove these files? (y/n): ' confirm"
echo "if [ \"\$confirm\" == \"y\" ]; then rm \"\${files_to_remove[@]}\"; fi"

Enregistrez le fichier et rendez-le exécutable :

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

Étape 3 : Exécution du script de nettoyage de fichiers

Exécutons maintenant notre script pour voir comment il identifie et filtre les fichiers :

./cleanup_files.sh

Cela devrait afficher une sortie indiquant quels fichiers seraient supprimés (ceux avec l'extension .txt).

Essayez-le avec différentes extensions de fichiers :

./cleanup_files.sh /home/labex/project/test_files pdf

Cela affichera les fichiers avec l'extension .pdf comme ceux qui seraient supprimés.

Étape 4 : Amélioration du script avec le traitement par lots

Améliorons notre script pour gérer plusieurs extensions de fichiers à la fois. Créez un nouveau fichier nommé advanced_cleanup.sh dans le répertoire /home/labex/project :

#!/bin/bash

## Directory to scan
target_dir=${1:-"/home/labex/project/test_files"}

## Default extensions to remove
extensions=("txt" "pdf")

## Override default extensions if provided as arguments
if [ $## -gt 1 ]; then
  extensions=("${@:2}")
fi

echo "Scanning directory: $target_dir"
echo "Will filter files with these extensions: ${extensions[@]}"

## Change to the target directory
cd "$target_dir" || {
  echo "Directory not found!"
  exit 1
}

## Get all files in the directory
all_files=(*)

echo "All files: ${all_files[@]}"

## Create an array to store files to keep
declare -a files_to_keep=()

## Create an array to store files to remove
declare -a files_to_remove=()

## Process each file
for file in "${all_files[@]}"; do
  ## Extract the file extension
  file_ext="${file##*.}"

  ## Check if the file extension is in our list
  should_remove=false
  for ext in "${extensions[@]}"; do
    if [ "$file_ext" == "$ext" ]; then
      should_remove=true
      break
    fi
  done

  ## Add to appropriate array based on whether it should be removed
  if [ "$should_remove" == true ]; then
    files_to_remove+=("$file")
  else
    files_to_keep+=("$file")
  fi
done

echo "Files to keep: ${files_to_keep[@]}"
echo "Files that would be removed: ${files_to_remove[@]}"

echo
echo "This script is in simulation mode and won't actually delete any files."
echo "In a real scenario, you would ask for confirmation before deletion."

Enregistrez le fichier et rendez-le exécutable :

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

Exécutez le script avancé avec différentes combinaisons d'extensions :

./advanced_cleanup.sh /home/labex/project/test_files txt jpg

Cela identifiera les fichiers .txt et .jpg pour la suppression.

Comprendre ce que nous avons fait

Dans cet exercice pratique, nous avons :

1. Créé un environnement de test avec différents types de fichiers
2. Construit un script de base qui utilise le filtrage de tableaux pour identifier les fichiers avec des extensions spécifiques
3. Amélioré le script pour gérer plusieurs extensions de fichiers
4. Démontré comment utiliser les tableaux Bash dans un scénario réel

Cet exemple montre comment les techniques de manipulation de tableaux que nous avons apprises peuvent être appliquées à des problèmes pratiques, tels que la gestion des fichiers et les tâches de nettoyage. La capacité de filtrer les tableaux est un outil puissant dans votre boîte à outils de script Bash.

Résumé

Félicitations pour avoir terminé ce tutoriel sur la suppression d'éléments correspondants des tableaux Bash. Vous avez acquis des compétences précieuses qui amélioreront vos capacités de script shell :

• Création et manipulation de tableaux Bash
• Suppression d'éléments des tableaux à l'aide de la boucle for et de la méthode unset
• Approches alternatives pour le filtrage des éléments de tableau
• Application des techniques de filtrage de tableaux aux tâches de gestion de fichiers réelles

Ces compétences constituent une partie essentielle de votre boîte à outils de script Bash et peuvent être appliquées à diverses tâches d'automatisation, opérations de traitement de données et tâches d'administration système.

Quelques points clés à retenir de ce tutoriel :

• Les tableaux Bash offrent un moyen pratique de stocker et de traiter des collections de données
• Lors de la suppression d'éléments d'un tableau, soyez attentif au décalage des index
• Différentes méthodes de filtrage des tableaux présentent des avantages différents selon votre cas d'utilisation
• Les techniques de manipulation de tableaux peuvent être appliquées pour résoudre des problèmes pratiques comme la gestion des fichiers

Au fur et à mesure que vous poursuivez votre parcours avec le script Bash, ces compétences de manipulation de tableaux s'avéreront inestimables pour écrire des scripts plus efficaces et plus puissants. N'hésitez pas à vous référer à ce tutoriel chaque fois que vous avez besoin de rafraîchir vos connaissances sur le travail avec les tableaux Bash.