Tableaux Associatifs Bash : Guide Complet pour le Scripting Shell

Introduction

Ce tutoriel vous guidera à travers le processus de compréhension et d'utilisation des tableaux associatifs (également appelés key-value arrays) en Bash dans vos scripts shell. Les tableaux associatifs sont des structures de données puissantes qui vous permettent de stocker et de récupérer des données en utilisant des clés descriptives au lieu d'indices numériques.

À la fin de ce tutoriel, vous serez capable de créer, manipuler et utiliser des tableaux associatifs dans vos scripts Bash pour organiser les données plus efficacement et résoudre des problèmes qui seraient difficiles avec les tableaux numériques traditionnels.

Création de votre premier tableau associatif Bash

Les tableaux associatifs Bash (également appelés key-value arrays) vous permettent d'associer des valeurs à des clés spécifiques, de manière similaire aux dictionnaires en Python ou aux objets en JavaScript. Cela les rend idéaux pour stocker des données structurées où les éléments sont identifiés par des noms plutôt que par des positions.

Syntaxe de base

Pour travailler avec des tableaux associatifs en Bash, vous devez d'abord les déclarer en utilisant l'option -A :

declare -A myarray

Ceci crée un tableau associatif vide nommé myarray. L'option -A indique spécifiquement à Bash qu'il s'agit d'un tableau associatif (clé-valeur).

Ajout d'éléments au tableau

Créons un tableau associatif pour stocker des informations sur différents fruits :

Ouvrez un nouveau terminal dans le WebIDE si ce n'est pas déjà fait.
Créez un nouveau fichier de script en cliquant sur "File > New File" dans le WebIDE.
Enregistrez le fichier sous le nom fruit_array.sh dans le répertoire /home/labex/project.
Ajoutez le code suivant au fichier :

#!/bin/bash

## Declare a key-value array
declare -A fruits

## Add elements to the array
fruits["apple"]="red"
fruits["banana"]="yellow"
fruits["grape"]="purple"
fruits["orange"]="orange"

## Print a specific element
echo "The color of an apple is ${fruits["apple"]}"

## Print all values
echo "All fruit colors: ${fruits[@]}"

## Print all keys
echo "All fruits: ${!fruits[@]}"

Enregistrez le fichier (Ctrl+S ou File > Save).
Rendez le script exécutable avec la commande suivante dans le terminal :

chmod +x fruit_array.sh

Exécutez le script :

./fruit_array.sh

Vous devriez voir une sortie similaire à celle-ci :

The color of an apple is red
All fruit colors: red yellow purple orange
All fruits: apple banana grape orange

Comprendre la sortie

${fruits["apple"]} : Cette syntaxe récupère la valeur associée à la clé "apple".
${fruits[@]} : Ceci renvoie toutes les valeurs du tableau.
${!fruits[@]} : Le symbole ! devant le nom du tableau renvoie toutes les clés du tableau.

Les tableaux associatifs Bash vous permettent d'accéder aux données directement en utilisant des noms significatifs plutôt que de devoir mémoriser des positions numériques, ce qui rend vos scripts plus lisibles et maintenables.

Manipulation des tableaux associatifs Bash

Maintenant que vous comprenez les bases des tableaux associatifs, explorons comment les manipuler. Dans cette étape, vous apprendrez à modifier les valeurs existantes, à ajouter de nouveaux éléments, à supprimer des éléments et à vérifier si une clé existe.

Création d'un nouveau script

Créez un nouveau fichier appelé array_operations.sh dans le répertoire /home/labex/project.
Ajoutez le code suivant au fichier :

#!/bin/bash

## Declare a key-value array
declare -A user_info

## Add initial elements
user_info["name"]="John Doe"
user_info["email"]="john@example.com"
user_info["age"]="30"
user_info["city"]="New York"

## Display initial array content
echo "--- Initial user information ---"
for key in "${!user_info[@]}"; do
  echo "$key: ${user_info[$key]}"
done

## Modify an existing value
user_info["age"]="31"

## Add a new key-value pair
user_info["country"]="USA"

## Check if a key exists
if [[ -v user_info["email"] ]]; then
  echo -e "\nEmail exists: ${user_info["email"]}"
else
  echo -e "\nEmail does not exist"
fi

## Remove an element
unset 'user_info[city]'

## Display the modified array
echo -e "\n--- Modified user information ---"
for key in "${!user_info[@]}"; do
  echo "$key: ${user_info[$key]}"
done

## Count the number of elements
echo -e "\nNumber of elements: ${#user_info[@]}"

Enregistrez le fichier (Ctrl+S ou File > Save).
Rendez le script exécutable :

chmod +x array_operations.sh

Exécutez le script :

./array_operations.sh

Vous devriez voir une sortie similaire à celle-ci :

--- Initial user information ---
name: John Doe
email: john@example.com
age: 30
city: New York

Email exists: john@example.com

--- Modified user information ---
name: John Doe
country: USA
email: john@example.com
age: 31

Number of elements: 4

Explication des opérations clés

Modification des valeurs : Affectez simplement une nouvelle valeur à une clé existante : user_info["age"]="31"
Ajout de nouveaux éléments : Utilisez la même syntaxe que l'affectation initiale : user_info["country"]="USA"
Vérification de l'existence d'une clé : Utilisez l'opérateur de test -v : [[ -v user_info["email"] ]]
Suppression d'éléments : Utilisez la commande unset : unset 'user_info[city]'
Comptage des éléments : Utilisez ${#array[@]} pour obtenir le nombre d'éléments
Itération à travers les éléments : Utilisez une boucle for avec ${!array[@]} pour obtenir toutes les clés

Remarquez comment la paire clé-valeur city est supprimée dans la sortie modifiée, et une nouvelle paire clé-valeur country a été ajoutée. De plus, la valeur age a été mise à jour de 30 à 31.

Ces opérations sont essentielles lorsque vous travaillez avec des données dynamiques dans vos scripts, vous permettant de mettre à jour les informations selon vos besoins.

Création d'un gestionnaire de configuration pratique

Maintenant que vous savez comment créer et manipuler des tableaux associatifs, construisons quelque chose de pratique. Dans cette étape, vous allez créer un gestionnaire de configuration simple qui charge les paramètres à partir d'un fichier de configuration, les stocke dans un tableau associatif et vous permet d'y accéder.

Étape 1 : Créer un fichier de configuration

Tout d'abord, créons un fichier de configuration avec quelques paramètres d'exemple :

Créez un nouveau fichier appelé app_config.txt dans le répertoire /home/labex/project.
Ajoutez le contenu suivant au fichier :

database_host=localhost
database_port=3306
database_user=admin
database_password=secret123
app_name=MyAwesomeApp
debug_mode=true
max_connections=100

Enregistrez le fichier

Étape 2 : Créer le script du gestionnaire de configuration

Maintenant, créons un script qui lira ce fichier de configuration et stockera son contenu dans un tableau associatif :

Créez un nouveau fichier appelé config_manager.sh dans le répertoire /home/labex/project.
Ajoutez le code suivant au fichier :

#!/bin/bash

## Define the path to the configuration file
CONFIG_FILE="/home/labex/project/app_config.txt"

## Declare a key-value array for the configuration
declare -A config

## Function to load configuration from file
load_config() {
  local file=$1

  ## Check if the file exists
  if [[ ! -f "$file" ]]; then
    echo "Error: Configuration file '$file' not found."
    return 1
  fi

  ## Read the file line by line
  while IFS='=' read -r key value; do
    ## Skip empty lines and comments
    if [[ -z "$key" || "$key" == \#* ]]; then
      continue
    fi

    ## Store the key-value pair in the array
    config["$key"]="$value"
  done < "$file"

  echo "Configuration loaded successfully from '$file'"
  return 0
}

## Function to get a configuration value
get_config() {
  local key=$1
  local default=$2

  ## Check if the key exists
  if [[ -v config["$key"] ]]; then
    echo "${config["$key"]}"
  else
    echo "$default"
  fi
}

## Function to display all configuration
display_config() {
  echo "--- Configuration Settings ---"
  for key in "${!config[@]}"; do
    echo "$key = ${config[$key]}"
  done
}

## Load the configuration
load_config "$CONFIG_FILE"

## Display all configuration settings
display_config

## Example of getting specific configuration values
echo -e "\n--- Example Usage ---"
db_host=$(get_config "database_host" "127.0.0.1")
db_port=$(get_config "database_port" "5432")
db_user=$(get_config "database_user" "root")
db_pass=$(get_config "database_password" "")
app_name=$(get_config "app_name" "DefaultApp")
debug_mode=$(get_config "debug_mode" "false")

echo "Database connection: $db_user@$db_host:$db_port"
echo "Application name: $app_name"
echo "Debug mode: $debug_mode"

## Example of getting a non-existent value (will use default)
timeout=$(get_config "connection_timeout" "30")
echo "Connection timeout: $timeout (default value used)"

Enregistrez le fichier (Ctrl+S ou File > Save).
Rendez le script exécutable :

chmod +x config_manager.sh

Exécutez le script :

./config_manager.sh

Vous devriez voir une sortie similaire à celle-ci :

Configuration loaded successfully from '/home/labex/project/app_config.txt'
--- Configuration Settings ---
database_host = localhost
database_port = 3306
database_user = admin
database_password = secret123
app_name = MyAwesomeApp
debug_mode = true
max_connections = 100

--- Example Usage ---
Database connection: admin@localhost:3306
Application name: MyAwesomeApp
Debug mode: true
Connection timeout: 30 (default value used)

Comprendre le gestionnaire de configuration

Le script que vous avez créé fait plusieurs choses importantes :

Il lit les paires clé-valeur à partir d'un fichier de configuration.
Il stocke ces paires dans un tableau associatif.
Il fournit des fonctions pour :
- Charger la configuration à partir d'un fichier.
- Obtenir des valeurs de configuration spécifiques avec des valeurs par défaut de repli.
- Afficher tous les paramètres de configuration.

Ce modèle est couramment utilisé dans les applications du monde réel pour gérer les paramètres de configuration. Les principaux avantages sont :

Configuration centralisée : Tous les paramètres sont au même endroit.
Valeurs par défaut : Si un paramètre est manquant, une valeur par défaut peut être utilisée.
Accès facile : Les paramètres peuvent être accessibles par leur nom.
Flexibilité : La configuration peut être mise à jour sans modifier le script.

Cet exemple montre comment les tableaux associatifs peuvent être utilisés pour résoudre des problèmes pratiques en script shell. Vous pourriez l'étendre en ajoutant des fonctions pour enregistrer les modifications dans le fichier de configuration ou pour valider les paramètres.

Dans cette dernière étape, nous allons créer un script pratique piloté par menu qui utilise des tableaux associatifs pour stocker et traiter les sélections de l'utilisateur. Cet exemple montre comment les tableaux associatifs peuvent être utilisés pour créer des applications en ligne de commande plus interactives et conviviales.

Créez un nouveau fichier appelé menu_system.sh dans le répertoire /home/labex/project.
Ajoutez le code suivant au fichier :

#!/bin/bash

## Declare a key-value array for menu options
declare -A menu_options
menu_options["1"]="Display system information"
menu_options["2"]="Check disk usage"
menu_options["3"]="List running processes"
menu_options["4"]="View network connections"
menu_options["q"]="Quit"

## Declare a key-value array for commands to execute
declare -A menu_commands
menu_commands["1"]="display_system_info"
menu_commands["2"]="check_disk_usage"
menu_commands["3"]="list_processes"
menu_commands["4"]="view_network"

## Function to display system information
display_system_info() {
  echo -e "\n--- System Information ---"
  echo "Hostname: $(hostname)"
  echo "Kernel version: $(uname -r)"
  echo "System uptime: $(uptime -p)"
  echo "CPU information: $(grep 'model name' /proc/cpuinfo | head -1 | cut -d ':' -f 2 | xargs)"
  echo "Total memory: $(free -h | grep Mem | awk '{print $2}')"
}

## Function to check disk usage
check_disk_usage() {
  echo -e "\n--- Disk Usage ---"
  df -h | grep -v tmp
}

## Function to list running processes
list_processes() {
  echo -e "\n--- Top 10 Processes by Memory Usage ---"
  ps aux --sort=-%mem | head -11
}

## Function to view network connections
view_network() {
  echo -e "\n--- Active Network Connections ---"
  netstat -tuln | grep LISTEN
}

## Function to display the menu
display_menu() {
  echo -e "\n=== System Utility Menu ==="
  for key in 1 2 3 4 q; do
    echo "$key. ${menu_options[$key]}"
  done
  echo -e "\nPlease enter your choice:"
}

## Main loop
while true; do
  ## Display the menu
  display_menu

  ## Read user choice
  read -r choice

  ## Check if choice is valid
  if [[ -v menu_options["$choice"] ]]; then
    ## Exit if user chose quit
    if [[ "$choice" == "q" ]]; then
      echo "Exiting. Goodbye!"
      exit 0
    fi

    ## Execute the corresponding command
    if [[ -v menu_commands["$choice"] ]]; then
      ## Call the function associated with the choice
      ${menu_commands["$choice"]}
    fi
  else
    echo "Invalid option. Please try again."
  fi

  ## Pause for user to read output
  echo -e "\nPress Enter to continue..."
  read -r
done

Enregistrez le fichier (Ctrl+S ou File > Save).
Rendez le script exécutable :

chmod +x menu_system.sh

Exécutez le script :

./menu_system.sh

Essayez les différentes options de menu en entrant le numéro correspondant, puis appuyez sur Entrée lorsque vous y êtes invité pour revenir au menu. Entrez q pour quitter le programme lorsque vous avez terminé.

Ce script démontre plusieurs utilisations avancées des tableaux associatifs :

Options de menu : Le tableau menu_options mappe les numéros d'option au texte descriptif.
Mappage des commandes : Le tableau menu_commands mappe les numéros d'option aux noms de fonctions.
Exécution dynamique : Le script utilise la valeur d'un tableau pour déterminer quelle fonction appeler.

Les avantages de l'utilisation des tableaux associatifs dans ce système de menu incluent :

Maintenabilité : L'ajout ou la modification des options de menu ne nécessite que la mise à jour des tableaux.
Lisibilité : Le code montre clairement quelle commande correspond à quelle option de menu.
Flexibilité : Vous pouvez facilement réorganiser les éléments de menu sans modifier les appels de fonction.

Ce modèle est utile pour créer des outils en ligne de commande interactifs qui sont faciles à maintenir et à étendre.

Points clés à retenir

Tout au long de ce tutoriel, vous avez appris :

Comment créer et initialiser des tableaux associatifs en Bash.
Comment accéder, modifier et supprimer des éléments des tableaux associatifs.
Comment itérer à travers les clés et les valeurs dans un tableau associatif.
Comment utiliser les tableaux associatifs pour stocker des données de configuration.
Comment créer un système de menu interactif à l'aide de tableaux associatifs.

Ces techniques peuvent être appliquées à un large éventail de tâches de script shell, du stockage de données simple aux applications interactives complexes.

Résumé

Dans ce tutoriel, vous avez exploré la puissance et la polyvalence des tableaux associatifs Bash. En commençant par les bases, vous avez appris à créer et à accéder aux tableaux associatifs, puis vous avez progressé vers des opérations plus avancées telles que la modification, l'ajout et la suppression d'éléments.

Vous avez appliqué ces connaissances pour créer des exemples pratiques, notamment un gestionnaire de configuration qui lit les paramètres à partir d'un fichier et un script utilitaire piloté par menu qui démontre comment les tableaux associatifs peuvent être utilisés pour créer des applications en ligne de commande interactives.

Les tableaux associatifs offrent un moyen puissant d'organiser et d'accéder aux données dans vos scripts Bash. La possibilité d'utiliser des clés descriptives au lieu d'indices numériques rend vos scripts plus lisibles et maintenables, en particulier lorsque vous traitez des structures de données complexes.

Maintenant que vous avez une solide compréhension des tableaux associatifs en Bash, vous pouvez les utiliser pour améliorer vos scripts shell et résoudre un large éventail de défis de programmation plus efficacement.

Utilisation des Tableaux Associatifs Bash en Scripting Shell

Introduction

Création de votre premier tableau associatif Bash

Syntaxe de base

Ajout d'éléments au tableau

Comprendre la sortie

Manipulation des tableaux associatifs Bash

Création d'un nouveau script

Explication des opérations clés

Création d'un gestionnaire de configuration pratique

Étape 1 : Créer un fichier de configuration

Étape 2 : Créer le script du gestionnaire de configuration

Comprendre le gestionnaire de configuration

Construction d'un script piloté par menu avec des tableaux associatifs

Création du système de menu

Comprendre le système de menu

Points clés à retenir

Résumé