Dépannage des Variables Non Définies en Bash : Guide Complet

Introduction

Les variables non définies dans les scripts Bash peuvent entraîner des comportements et des erreurs inattendus. Dans ce tutoriel, nous allons explorer les fondamentaux des variables shell, apprendre à identifier quand les variables sont non définies (unbound), et mettre en œuvre des stratégies efficaces pour les gérer. À la fin de ce lab, vous serez capable d'écrire des scripts Bash plus fiables qui gèrent les problèmes de variables avec élégance.

Création de votre premier script avec des variables shell

Les variables shell sont des emplacements de stockage nommés qui contiennent des valeurs dans vos scripts Bash. Dans cette étape, nous allons créer un script simple pour comprendre comment les variables fonctionnent et voir comment elles sont utilisées.

Comprendre les variables shell

Les variables en Bash vous permettent de stocker des données qui peuvent être référencées et manipulées tout au long de votre script. Elles sont essentielles pour écrire des scripts flexibles et réutilisables.

Commençons par créer un nouveau fichier de script dans notre répertoire de projet :

Ouvrez le WebIDE et créez un nouveau fichier nommé variables.sh dans le répertoire /home/labex/project
Ajoutez le contenu suivant au fichier :

#!/bin/bash

## Déclaration des variables
name="LabEx User"
age=25
current_date=$(date)

## Accès aux variables
echo "Hello, my name is $name"
echo "I am $age years old"
echo "Today is: $current_date"

## Les variables avec des espaces nécessitent des guillemets
greeting="Welcome to Bash scripting"
echo "$greeting"

Enregistrez le fichier
Rendez le script exécutable en exécutant cette commande dans le terminal :

chmod +x variables.sh

Exécutez votre script :

./variables.sh

Vous devriez voir une sortie similaire à celle-ci :

Hello, my name is LabEx User
I am 25 years old
Today is: Mon Jan 1 12:34:56 UTC 2023
Welcome to Bash scripting

Règles de nommage des variables

Lors de la dénomination des variables en Bash, gardez ces règles à l'esprit :

Les noms de variables peuvent contenir des lettres, des chiffres et des traits de soulignement
Les noms de variables ne peuvent pas commencer par un chiffre
Aucun espace n'est autorisé autour du signe égal lors de l'affectation de valeurs
Les noms de variables sont sensibles à la casse (NAME et name sont des variables différentes)

Ajoutons quelques exemples supplémentaires à notre script. Ouvrez variables.sh à nouveau et ajoutez ce qui suit à la fin :

## Exemples de noms de variables valides
user_1="John"
HOME_DIR="/home/user"
count=42

## Impression des variables
echo "User: $user_1"
echo "Home directory: $HOME_DIR"
echo "Count: $count"

Enregistrez le fichier et exécutez-le à nouveau :

./variables.sh

La sortie supplémentaire devrait ressembler à ceci :

User: John
Home directory: /home/user
Count: 42

Vous avez maintenant créé votre premier script Bash qui utilise correctement les variables !

Rencontre avec les variables non définies

Maintenant que nous comprenons les bases des variables, explorons ce qui se passe lorsque nous essayons d'utiliser une variable à laquelle aucune valeur n'a été affectée - une variable non définie.

Que sont les variables non définies ?

Une variable non définie, également appelée variable non initialisée (unset variable), est une variable à laquelle aucune valeur n'a été affectée dans votre script. Lorsque vous essayez d'utiliser une variable non définie, Bash la traite généralement comme une chaîne vide, ce qui peut provoquer des bogues subtils dans vos scripts.

Créons un nouveau script pour voir cela en action :

Créez un nouveau fichier nommé unbound.sh dans votre répertoire de projet avec le contenu suivant :

#!/bin/bash

## Une variable qui est correctement définie
username="labex"

## Essayez d'utiliser une variable qui n'a pas été définie
echo "Hello, $username! Your home directory is $home_dir"

## Essayez de faire des calculs avec une variable non définie
total=$((count + 5))
echo "Total: $total"

Rendez le script exécutable :

chmod +x unbound.sh

Exécutez le script :

./unbound.sh

Vous devriez voir une sortie similaire à celle-ci :

Hello, labex! Your home directory is

Total: 5

Notez que $home_dir apparaît comme un espace vide, et $count est traité comme 0 dans le calcul. Ce comportement silencieux peut conduire à des bogues difficiles à trouver.

Détection des variables non définies

Modifions notre script pour aider à détecter ces variables non définies. Une façon de le faire est d'utiliser des vérifications conditionnelles avant d'utiliser les variables :

Ouvrez unbound.sh et remplacez son contenu par :

#!/bin/bash

## Une variable qui est correctement définie
username="labex"

## Vérifiez si home_dir est défini avant de l'utiliser
if [ -z "$home_dir" ]; then
  echo "Warning: home_dir is not set!"
  home_dir="/home/default"
  echo "Using default: $home_dir"
else
  echo "Home directory is: $home_dir"
fi

## Vérifiez si count est défini avant de faire des calculs
if [ -z "$count" ]; then
  echo "Warning: count is not set!"
  count=10
  echo "Using default count: $count"
fi

total=$((count + 5))
echo "Total: $total"

Enregistrez le fichier et exécutez-le à nouveau :

./unbound.sh

La sortie devrait maintenant être :

Warning: home_dir is not set!
Using default: /home/default
Warning: count is not set!
Using default count: 10
Total: 15

Cette approche vous aide à détecter les variables non définies et à les gérer explicitement plutôt que de les laisser provoquer des erreurs silencieuses.

Test avec l'option `set -u`

Une autre façon de détecter les variables non définies est d'utiliser l'option set -u, qui fait que Bash quitte immédiatement lorsqu'il rencontre une variable non définie :

Créez un nouveau fichier nommé strict.sh avec le contenu suivant :

#!/bin/bash
set -u ## Quitte lorsque la variable non définie est utilisée

echo "My username is $username"
echo "My favorite color is $favorite_color"
echo "This line won't be reached if favorite_color isn't set"

Rendez-le exécutable :

chmod +x strict.sh

Exécutez le script :

./strict.sh

Vous devriez voir un message d'erreur similaire à :

./strict.sh: line 4: favorite_color: unbound variable

Le script quitte immédiatement à la ligne 4 lorsqu'il essaie d'utiliser la variable non définie $favorite_color. Cela aide à détecter les variables non définies tôt, en empêchant les problèmes potentiels plus tard dans le script.

Gestion des variables non définies avec l'expansion de paramètres

L'une des fonctionnalités les plus puissantes de Bash pour la gestion des variables non définies est l'expansion de paramètres (parameter expansion). Elle vous permet de fournir des valeurs par défaut et d'effectuer diverses opérations sur les variables.

Utilisation des valeurs par défaut avec l'expansion de paramètres

L'expansion de paramètres offre plusieurs façons de gérer élégamment les variables non définies. Créons un nouveau script pour démontrer ces techniques :

Créez un nouveau fichier nommé parameter_expansion.sh avec le contenu suivant :

#!/bin/bash

## Valeur par défaut avec ${parameter:-default}
## Si le paramètre n'est pas défini ou est nul, 'default' est utilisé
echo "1. Username: ${username:-anonymous}"

## Définir le nom d'utilisateur et réessayer
username="labex"
echo "2. Username: ${username:-anonymous}"

## Valeur par défaut avec ${parameter-default}
## Seulement si le paramètre n'est pas défini, 'default' est utilisé
unset username
empty_var=""
echo "3. Username (unset): ${username-anonymous}"
echo "4. Empty variable: ${empty_var-not empty}"

## Affecter la valeur par défaut avec ${parameter:=default}
## Si le paramètre n'est pas défini ou est nul, définissez-le sur 'default'
echo "5. Language: ${language:=bash}"
echo "6. Language is now set to: $language"

## Afficher l'erreur avec ${parameter:?message}
## Si le paramètre n'est pas défini ou est nul, affichez le message d'erreur et quittez
echo "7. About to check required parameter..."
## Uncomment the line below to see the error
## echo "Config file: ${config_file:?not specified}"

echo "8. Script continues..."

Rendez le script exécutable :

chmod +x parameter_expansion.sh

Exécutez le script :

./parameter_expansion.sh

Vous devriez voir une sortie comme celle-ci :

1. Username: anonymous
2. Username: labex
3. Username (unset): anonymous
4. Empty variable:
5. Language: bash
6. Language is now set to: bash
7. About to check required parameter...
8. Script continues...

Modèles courants d'expansion de paramètres

Voici un résumé des modèles d'expansion de paramètres que nous venons d'utiliser :

Syntaxe	Description
`${var:-default}`	Utiliser la valeur par défaut si var n'est pas défini ou est nul
`${var-default}`	Utiliser la valeur par défaut uniquement si var n'est pas défini
`${var:=default}`	Définir var sur la valeur par défaut s'il n'est pas défini ou est nul
`${var:?message}`	Afficher l'erreur si var n'est pas défini ou est nul

Création d'un exemple pratique

Créons un script plus pratique qui utilise l'expansion de paramètres pour gérer les paramètres de configuration :

Créez un nouveau fichier nommé config_script.sh avec le contenu suivant :

#!/bin/bash

## Script qui traite les fichiers avec des paramètres configurables

## Utiliser l'expansion de paramètres pour définir les valeurs par défaut pour toutes les options de configuration
BACKUP_DIR=${BACKUP_DIR:-"/tmp/backups"}
MAX_FILES=${MAX_FILES:-5}
FILE_TYPE=${FILE_TYPE:-"txt"}
VERBOSE=${VERBOSE:-"no"}

echo "Configuration settings:"
echo "----------------------"
echo "Backup directory: $BACKUP_DIR"
echo "Maximum files: $MAX_FILES"
echo "File type: $FILE_TYPE"
echo "Verbose mode: $VERBOSE"

## Créer le répertoire de sauvegarde s'il n'existe pas
if [ ! -d "$BACKUP_DIR" ]; then
  echo "Creating backup directory: $BACKUP_DIR"
  mkdir -p "$BACKUP_DIR"
fi

## Rechercher les fichiers du type spécifié (dans le répertoire actuel pour la démo)
echo "Searching for .$FILE_TYPE files..."
file_count=$(find . -maxdepth 1 -name "*.$FILE_TYPE" | wc -l)

echo "Found $file_count .$FILE_TYPE files"

## Activer la sortie verbose si demandé
if [ "$VERBOSE" = "yes" ]; then
  echo "Files found:"
  find . -maxdepth 1 -name "*.$FILE_TYPE" -type f
fi

echo "Script completed successfully!"

Rendez le script exécutable :

chmod +x config_script.sh

Exécutez le script avec les valeurs par défaut :

./config_script.sh

Maintenant, exécutez-le à nouveau avec des paramètres personnalisés :

FILE_TYPE="sh" VERBOSE="yes" ./config_script.sh

La sortie devrait afficher vos scripts bash (fichiers .sh) dans le répertoire actuel.

Ce script montre comment utiliser l'expansion de paramètres pour définir des valeurs par défaut pour les variables de configuration, rendant votre script flexible et convivial.

Utilisation du mode strict pour des scripts robustes

Pour créer des scripts Bash plus fiables et résistants aux erreurs, de nombreux développeurs utilisent ce qui est souvent appelé le "mode strict". Cela inclut un ensemble d'options Bash qui aident à détecter les erreurs courantes, y compris les variables non définies.

Qu'est-ce que le mode strict ?

Le mode strict implique généralement l'activation de ces options au début de votre script :

set -e : Quitte immédiatement si une commande se termine avec un statut différent de zéro
set -u : Quitte si une variable non définie est référencée
set -o pipefail : Fait échouer un pipeline si une commande en son sein échoue

Voyons comment implémenter cela dans un script :

Créez un nouveau fichier nommé strict_mode.sh avec le contenu suivant :

#!/bin/bash
## Strict mode
set -euo pipefail

echo "Starting strict mode script..."

## Define some variables
username="labex"
project_dir="/home/labex/project"

## This function requires two parameters
process_data() {
  local input="$1"
  local output="${2:-output.txt}"

  echo "Processing $input and saving to $output"
  ## For demo purposes, just echo to the output file
  echo "Processed data from $input" > "$output"
}

## Call the function with required arguments
process_data "input.txt"

## Try to access a non-existent file
## Uncomment the next line to see how strict mode handles errors
## cat non_existent_file.txt

echo "Script completed successfully"

Rendez le script exécutable :

chmod +x strict_mode.sh

Exécutez le script :

./strict_mode.sh

Vous devriez voir :

Starting strict mode script...
Processing input.txt and saving to output.txt
Script completed successfully

Vérifiez que le fichier de sortie a été créé :

cat output.txt

Vous devriez voir :

Processed data from input.txt

Test de la gestion des erreurs en mode strict

Maintenant, modifions notre script pour voir comment le mode strict gère les erreurs :

Créez un nouveau fichier nommé strict_mode_errors.sh avec le contenu suivant :

#!/bin/bash
## Strict mode
set -euo pipefail

echo "Starting script with error demonstrations..."

## Example 1: Unbound variable
echo "Example 1: About to use an unbound variable"
## Uncomment the next line to see the error
## echo "Home directory: $HOME_DIR"
echo "This line will not be reached if you uncomment the above line"

## Example 2: Command failure
echo "Example 2: About to run a failing command"
## Uncomment the next line to see the error
## grep "pattern" non_existent_file.txt
echo "This line will not be reached if you uncomment the above line"

## Example 3: Pipeline failure
echo "Example 3: About to create a failing pipeline"
## Uncomment the next line to see the error
## cat non_existent_file.txt | sort
echo "This line will not be reached if you uncomment the above line"

echo "Script completed without errors"

Rendez le script exécutable :

chmod +x strict_mode_errors.sh

Exécutez le script :

./strict_mode_errors.sh

Maintenant, modifiez le script pour décommenter l'une des lignes d'erreur (par exemple, la ligne avec $HOME_DIR), enregistrez-le et exécutez-le à nouveau :

./strict_mode_errors.sh

Vous devriez voir que le script se termine immédiatement avec un message d'erreur lorsqu'il rencontre la variable non définie :

Starting script with error demonstrations...
Example 1: About to use an unbound variable
./strict_mode_errors.sh: line 9: HOME_DIR: unbound variable

Cela montre comment le mode strict aide à identifier les problèmes dès le début de votre script.

Création d'un modèle de script robuste

Créons un modèle pour les scripts Bash robustes que vous pourrez utiliser pour vos futurs projets :

Créez un nouveau fichier nommé robust_script_template.sh avec le contenu suivant :

#!/bin/bash
## ====================================
## Robust Bash Script Template
## ====================================

## --- Strict mode ---
set -euo pipefail

## --- Script metadata ---
SCRIPT_NAME="$(basename "$0")"
SCRIPT_VERSION="1.0.0"

## --- Default configuration ---
DEBUG=${DEBUG:-false}
LOG_FILE=${LOG_FILE:-"/tmp/${SCRIPT_NAME}.log"}

## --- Helper functions ---
log() {
  local message="$1"
  local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
  echo "[$timestamp] $message" | tee -a "$LOG_FILE"
}

debug() {
  if [[ "$DEBUG" == "true" ]]; then
    log "DEBUG: $1"
  fi
}

error() {
  log "ERROR: $1"
  exit 1
}

usage() {
  cat << EOF
Usage: $SCRIPT_NAME [options]

A robust bash script template with error handling and logging.

Options:
  --help      Show this help message and exit
  --version   Show script version and exit

Environment variables:
  DEBUG       Set to 'true' to enable debug output
  LOG_FILE    Path to the log file (default: /tmp/${SCRIPT_NAME}.log)
EOF
}

## --- Process command line arguments ---
for arg in "$@"; do
  case $arg in
    --help)
      usage
      exit 0
      ;;
    --version)
      echo "$SCRIPT_NAME version $SCRIPT_VERSION"
      exit 0
      ;;
    *)
      ## Unknown option
      ;;
  esac
done

## --- Main script logic ---
main() {
  log "Starting $SCRIPT_NAME version $SCRIPT_VERSION"

  ## Your script logic goes here
  debug "Script executed with DEBUG=$DEBUG"
  log "Script executed by user: $(whoami)"
  log "Current directory: $(pwd)"

  ## Example of using a variable with default value
  TARGET_DIR=${TARGET_DIR:-$(pwd)}
  log "Target directory: $TARGET_DIR"

  log "$SCRIPT_NAME completed successfully"
}

## --- Run main function ---
main

Rendez le script exécutable :

chmod +x robust_script_template.sh

Exécutez le script :

./robust_script_template.sh

Essayez de l'exécuter avec le débogage activé :

DEBUG=true ./robust_script_template.sh

Ce modèle comprend :

Des paramètres de mode strict pour détecter les erreurs
Une configuration par défaut avec l'expansion de paramètres
Des fonctions de journalisation et de débogage
Le traitement des arguments de ligne de commande
Une structure claire avec une fonction principale

Vous pouvez utiliser ce modèle comme point de départ pour vos propres scripts Bash afin de les rendre plus robustes et maintenables.

Création d'une application concrète

Maintenant que nous avons appris les variables, les variables non définies, l'expansion de paramètres et le mode strict, combinons tous ces concepts dans un script pratique. Nous allons créer un simple utilitaire de sauvegarde de fichiers qui démontre les meilleures pratiques pour la gestion des variables en Bash.

Planification de notre script de sauvegarde

Notre script de sauvegarde :

Prend un répertoire source et une destination de sauvegarde en entrée
Permet la configuration via des variables d'environnement ou des arguments de ligne de commande
Gère les erreurs avec élégance en utilisant le mode strict
Fournit des informations utiles à l'utilisateur

Création du script de sauvegarde

Créez un nouveau fichier nommé backup.sh avec le contenu suivant :

#!/bin/bash
## ====================================
## File Backup Utility
## ====================================

## --- Strict mode ---
set -euo pipefail

## --- Script metadata ---
SCRIPT_NAME="$(basename "$0")"
SCRIPT_VERSION="1.0.0"

## --- Default configuration ---
SOURCE_DIR=${SOURCE_DIR:-"$(pwd)"}
BACKUP_DIR=${BACKUP_DIR:-"/tmp/backups"}
BACKUP_NAME=${BACKUP_NAME:-"backup_$(date +%Y%m%d_%H%M%S)"}
EXCLUDE_PATTERN=${EXCLUDE_PATTERN:-"*.tmp"}
VERBOSE=${VERBOSE:-"false"}

## --- Helper functions ---
log() {
  if [[ "$VERBOSE" == "true" ]]; then
    echo "$(date "+%Y-%m-%d %H:%M:%S") - $1"
  fi
}

error() {
  echo "ERROR: $1" >&2
  exit 1
}

usage() {
  cat << EOF
Usage: $SCRIPT_NAME [options]

A simple file backup utility.

Options:
  -s, --source DIR      Source directory to backup (default: current directory)
  -d, --destination DIR Backup destination directory (default: /tmp/backups)
  -n, --name NAME       Name for the backup archive (default: backup_YYYYMMDD_HHMMSS)
  -e, --exclude PATTERN Files to exclude (default: *.tmp)
  -v, --verbose         Enable verbose output
  -h, --help            Show this help message and exit

Environment variables:
  SOURCE_DIR       Same as --source
  BACKUP_DIR       Same as --destination
  BACKUP_NAME      Same as --name
  EXCLUDE_PATTERN  Same as --exclude
  VERBOSE          Set to 'true' to enable verbose output
EOF
}

## --- Process command line arguments ---
while [[ $## -gt 0 ]]; do
  case $1 in
    -s | --source)
      SOURCE_DIR="$2"
      shift 2
      ;;
    -d | --destination)
      BACKUP_DIR="$2"
      shift 2
      ;;
    -n | --name)
      BACKUP_NAME="$2"
      shift 2
      ;;
    -e | --exclude)
      EXCLUDE_PATTERN="$2"
      shift 2
      ;;
    -v | --verbose)
      VERBOSE="true"
      shift
      ;;
    -h | --help)
      usage
      exit 0
      ;;
    *)
      error "Unknown option: $1"
      ;;
  esac
done

## --- Main function ---
main() {
  ## Validate source directory
  if [[ ! -d "$SOURCE_DIR" ]]; then
    error "Source directory does not exist: $SOURCE_DIR"
  fi

  ## Create backup directory if it doesn't exist
  if [[ ! -d "$BACKUP_DIR" ]]; then
    log "Creating backup directory: $BACKUP_DIR"
    mkdir -p "$BACKUP_DIR" || error "Failed to create backup directory"
  fi

  ## Full path for the backup file
  BACKUP_FILE="$BACKUP_DIR/$BACKUP_NAME.tar.gz"

  log "Starting backup from $SOURCE_DIR to $BACKUP_FILE"
  log "Excluding files matching: $EXCLUDE_PATTERN"

  ## Create the backup
  tar -czf "$BACKUP_FILE" \
    --exclude="$EXCLUDE_PATTERN" \
    -C "$(dirname "$SOURCE_DIR")" "$(basename "$SOURCE_DIR")" \
    || error "Backup failed"

  ## Check if backup was created
  if [[ -f "$BACKUP_FILE" ]]; then
    BACKUP_SIZE=$(du -h "$BACKUP_FILE" | cut -f1)
    echo "Backup completed successfully: $BACKUP_FILE ($BACKUP_SIZE)"
  else
    error "Backup file was not created"
  fi
}

## --- Run main function ---
main

Rendez le script exécutable :

chmod +x backup.sh

Exécutez le script avec les paramètres par défaut :

./backup.sh

Vous devriez voir un message confirmant que la sauvegarde a été créée avec succès.

Vérifiez le fichier de sauvegarde :

ls -lh /tmp/backups/

Essayez d'exécuter le script avec différentes options :

./backup.sh --source ~/project --destination ~/backups --name my_project_backup --verbose

Si le répertoire ~/backups n'existe pas, le script le créera. Vous pourriez voir une erreur si vous n'avez pas les permissions d'écriture pour créer ce répertoire.

Test de la gestion des erreurs dans notre script de sauvegarde

Testons comment notre script gère les erreurs :

Essayez de sauvegarder un répertoire inexistant :

./backup.sh --source /path/that/does/not/exist

Vous devriez voir un message d'erreur comme :

ERROR: Source directory does not exist: /path/that/does/not/exist

Essayez de définir une destination de sauvegarde non valide (où vous n'avez pas les permissions d'écriture) :

./backup.sh --destination /root/backups

Vous devriez voir un message d'erreur indiquant que le script n'a pas réussi à créer le répertoire de sauvegarde.

Création d'un environnement de test

Créons un environnement de test pour démontrer notre script de sauvegarde :

Créez une structure de répertoire de test :

mkdir -p ~/project/test_backup/{docs,images,code}
touch ~/project/test_backup/docs/{readme.md,manual.pdf}
touch ~/project/test_backup/images/{logo.png,banner.jpg}
touch ~/project/test_backup/code/{script.sh,data.tmp,config.json}

Exécutez le script de sauvegarde sur ce répertoire de test :

./backup.sh --source ~/project/test_backup --exclude "*.tmp" --verbose

Listez les fichiers dans la sauvegarde :

tar -tvf /tmp/backups/backup_*.tar.gz | sort

Vous devriez voir tous les fichiers, à l'exception de ceux correspondant au motif d'exclusion (*.tmp).

Ce script de sauvegarde démontre tous les concepts que nous avons couverts :

Définition des valeurs par défaut pour les variables à l'aide de l'expansion de paramètres
Utilisation du mode strict pour détecter les erreurs
Gestion des arguments de ligne de commande et des variables d'environnement
Fourniture d'informations à l'utilisateur et de messages d'erreur
Validation des entrées et gestion des cas limites

Grâce à ces techniques, vous pouvez écrire des scripts Bash robustes qui gèrent les variables non définies avec élégance et offrent une meilleure expérience utilisateur.

Résumé

Dans ce laboratoire, vous avez appris à gérer les variables non définies dans les scripts Bash, une compétence essentielle pour écrire des scripts shell fiables. Voici un résumé de ce que vous avez accompli :

Création de scripts avec une déclaration et une utilisation appropriées des variables
Identification des problèmes que les variables non définies peuvent causer dans les scripts Bash
Utilisation de contrôles conditionnels pour détecter les variables non définies
Application de techniques d'expansion de paramètres pour fournir des valeurs par défaut
Implémentation du mode strict (set -euo pipefail) pour détecter les erreurs rapidement
Création d'un modèle de script robuste avec une gestion appropriée des erreurs
Construction d'un utilitaire de sauvegarde pratique qui démontre les meilleures pratiques

En appliquant ces techniques, vous pouvez écrire des scripts Bash plus fiables qui gèrent les cas limites avec élégance et offrent une meilleure expérience aux utilisateurs. Rappelez-vous ces points clés :

Tenez toujours compte de ce qui se passe lorsque les variables ne sont pas définies
Utilisez l'expansion de paramètres pour les valeurs par défaut
Activez le mode strict pour les scripts critiques
Validez les entrées et fournissez des messages d'erreur utiles
Documentez le comportement et les exigences de votre script

Ces pratiques vous aideront à créer des scripts Bash plus robustes, maintenables et conviviaux.

Comment Dépanner les Variables Non Définies dans les Scripts Bash