Comment Définir des Valeurs par Défaut dans les Scripts Bash

Introduction

Définir des valeurs par défaut dans les scripts Bash est une compétence cruciale pour créer des scripts shell robustes et conviviaux. Ce tutoriel vous guidera à travers le processus de gestion des paramètres manquants ou optionnels en fournissant des valeurs par défaut, garantissant que vos scripts peuvent gérer avec élégance une variété de scénarios d'entrée.

À la fin de ce lab, vous serez capable d'écrire des scripts Bash qui fonctionnent bien même lorsque les utilisateurs ne fournissent pas tous les paramètres d'entrée attendus.

Comprendre les valeurs par défaut en Bash

Lorsque vous écrivez des scripts Bash, vous avez souvent besoin que vos scripts fonctionnent même lorsque certains paramètres d'entrée sont manquants. Les valeurs par défaut offrent une solution en proposant des options de repli lorsque les variables ne sont pas explicitement définies.

Pourquoi les valeurs par défaut sont importantes

Les valeurs par défaut dans les scripts Bash servent plusieurs objectifs importants :

• Elles empêchent votre script d'échouer lorsque l'entrée attendue est manquante
• Elles rendent vos scripts plus conviviaux en réduisant les paramètres requis
• Elles permettent à vos scripts d'avoir un comportement raisonnable dans différents environnements
• Elles simplifient le développement et les tests de scripts

Création d'un script simple

Créons un script Bash simple pour démontrer la nécessité des valeurs par défaut. Suivez ces étapes :

1. Ouvrez le terminal WebIDE
2. Créez un nouveau répertoire pour notre projet :

mkdir -p ~/project/bash_defaults
cd ~/project/bash_defaults

3. En utilisant le WebIDE, créez un nouveau fichier nommé greeting.sh dans le répertoire bash_defaults avec le contenu suivant :

#!/bin/bash

## A simple greeting script
NAME=$1
echo "Hello, $NAME!"

4. Rendez le script exécutable :

chmod +x greeting.sh

5. Maintenant, exécutez le script avec un paramètre de nom :

./greeting.sh Alice

Vous devriez voir la sortie :

Hello, Alice!

6. Maintenant, essayez d'exécuter le script sans aucun paramètre :

./greeting.sh

Vous devriez voir la sortie :

Hello, !

Remarquez que la salutation semble incomplète lorsqu'aucun nom n'est fourni. C'est un scénario parfait où les valeurs par défaut seraient utiles pour rendre notre script plus robuste.

Dans l'étape suivante, nous allons modifier ce script pour utiliser des valeurs par défaut afin qu'il fonctionne bien même lorsque des paramètres sont manquants.

Techniques de base pour les valeurs par défaut

Maintenant que nous comprenons pourquoi les valeurs par défaut sont importantes, apprenons différentes façons de définir des valeurs par défaut dans les scripts Bash. Nous commencerons par les techniques les plus courantes.

L'opérateur de substitution de paramètre (:-)

La façon la plus courante de définir des valeurs par défaut en Bash est d'utiliser l'opérateur :- avec la syntaxe suivante :

${variable:-default_value}

Cela signifie "utiliser la valeur de variable si elle est définie et non vide, sinon utiliser default_value".

Modifions notre script de salutation pour inclure une valeur par défaut :

1. Ouvrez le fichier greeting.sh dans le WebIDE et mettez-le à jour avec le contenu suivant :

#!/bin/bash

## A greeting script with default value
NAME=${1:-"World"}
echo "Hello, $NAME!"

2. Enregistrez le fichier et exécutez le script avec un paramètre :

./greeting.sh Alice

Vous devriez voir :

Hello, Alice!

3. Maintenant, exécutez le script sans aucun paramètre :

./greeting.sh

Vous devriez voir :

Hello, World!

Le script utilise désormais "World" comme valeur par défaut lorsqu'aucun nom n'est fourni, ce qui le rend beaucoup plus convivial.

Création d'un script plus complexe

Créons un script plus complexe qui souhaite la bienvenue aux utilisateurs avec un message personnalisable et l'heure de la journée. Nous utiliserons des valeurs par défaut pour les deux paramètres :

1. Créez un nouveau fichier nommé welcome.sh dans le répertoire bash_defaults avec le contenu suivant :

#!/bin/bash

## A welcome script with multiple default values
NAME=${1:-"User"}
GREETING=${2:-"Welcome"}
TIME_OF_DAY=${3:-"today"}

echo "$GREETING, $NAME! How are you doing $TIME_OF_DAY?"

2. Rendez le script exécutable :

chmod +x welcome.sh

3. Exécutez le script avec différentes combinaisons de paramètres :

./welcome.sh

Sortie :

Welcome, User! How are you doing today?

./welcome.sh Bob

Sortie :

Welcome, Bob! How are you doing today?

./welcome.sh Bob "Good morning"

Sortie :

Good morning, Bob! How are you doing today?

./welcome.sh Bob "Good morning" "this fine afternoon"

Sortie :

Good morning, Bob! How are you doing this fine afternoon?

Comme vous pouvez le constater, les valeurs par défaut rendent vos scripts beaucoup plus flexibles, fonctionnant avec n'importe quel nombre de paramètres fournis.

Travailler avec les variables d'environnement et les valeurs par défaut

Dans de nombreux scénarios de scripts Bash, vous devrez travailler avec des variables d'environnement. Les valeurs par défaut sont particulièrement utiles lorsque vous souhaitez que votre script fonctionne même si certaines variables d'environnement ne sont pas définies.

Valeurs par défaut pour les variables d'environnement

Les variables d'environnement sont souvent utilisées pour la configuration dans les scripts shell. Créons un script qui utilise des variables d'environnement avec des valeurs par défaut :

1. Créez un nouveau fichier nommé config.sh dans le répertoire bash_defaults avec le contenu suivant :

#!/bin/bash

## Access environment variables with default values
USERNAME=${USER:-"anonymous"}
WORKING_DIR=${PWD:-"/home/labex"}
EDITOR=${VISUAL:-${EDITOR:-"nano"}}

echo "Current user: $USERNAME"
echo "Working directory: $WORKING_DIR"
echo "Preferred editor: $EDITOR"

2. Rendez le script exécutable :

chmod +x config.sh

3. Exécutez le script :

./config.sh

Vous devriez voir une sortie similaire à :

Current user: labex
Working directory: /home/labex/project/bash_defaults
Preferred editor: nano

Remarquez comment nous avons imbriqué des valeurs par défaut pour la variable EDITOR. Ce script vérifie d'abord si la variable d'environnement VISUAL est définie, et sinon, il vérifie la variable EDITOR. Si aucune des deux n'est définie, il utilise par défaut "nano".

Création d'un script de configuration

Créons maintenant un script plus pratique qui configure une application à l'aide de variables d'environnement avec des valeurs par défaut :

1. Créez un nouveau fichier nommé app_config.sh dans le répertoire bash_defaults avec le contenu suivant :

#!/bin/bash

## Application configuration script using default values
APP_NAME=${APP_NAME:-"MyApp"}
APP_VERSION=${APP_VERSION:-"1.0.0"}
APP_PORT=${APP_PORT:-8080}
APP_ENV=${APP_ENV:-"development"}
LOG_LEVEL=${LOG_LEVEL:-"info"}

echo "Starting $APP_NAME v$APP_VERSION"
echo "Configuration:"
echo "  Port: $APP_PORT"
echo "  Environment: $APP_ENV"
echo "  Log Level: $LOG_LEVEL"

## Create a config file with these settings
echo "Creating configuration file..."
cat > app.conf << EOF
APP_NAME=$APP_NAME
APP_VERSION=$APP_VERSION
APP_PORT=$APP_PORT
APP_ENV=$APP_ENV
LOG_LEVEL=$LOG_LEVEL
EOF

echo "Configuration file created at $(pwd)/app.conf"

2. Rendez le script exécutable :

chmod +x app_config.sh

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

./app_config.sh

Vous devriez voir une sortie concernant la configuration par défaut.

4. Maintenant, exécutez-le avec certaines variables d'environnement définies :

APP_NAME="WebService" APP_PORT=3000 APP_ENV="production" ./app_config.sh

Vous devriez voir que le script utilise les valeurs que vous avez fournies pour certains paramètres et les valeurs par défaut pour d'autres.

5. Vérifiez le contenu du fichier de configuration :

cat app.conf

Cet exemple pratique montre comment les valeurs par défaut en Bash aident à créer des scripts de configuration flexibles qui fonctionnent avec ou sans valeurs spécifiées par l'utilisateur.

Techniques avancées pour les valeurs par défaut

Maintenant que vous comprenez les bases de la définition des valeurs par défaut en Bash, explorons quelques techniques avancées qui rendront vos scripts encore plus puissants et flexibles.

L'opérateur d'affectation :=

L'opérateur := non seulement substitue une valeur par défaut, mais affecte également cette valeur à la variable si elle n'était pas définie. Ceci est utile lorsque vous souhaitez que la variable conserve sa valeur par défaut pour une utilisation ultérieure.

1. Créez un nouveau fichier nommé assign_default.sh dans le répertoire bash_defaults avec le contenu suivant :

#!/bin/bash

## Demonstrate the := assignment operator
echo "Before assignment, NAME = $NAME"

## This assigns the default value to NAME if it's unset
: ${NAME:="DefaultUser"}

echo "After assignment, NAME = $NAME"

## Now use the variable in a function
greet() {
  echo "Hello, $NAME!"
}

greet

2. Rendez le script exécutable :

chmod +x assign_default.sh

3. Exécutez le script sans définir NAME :

./assign_default.sh

Vous devriez voir :

Before assignment, NAME =
After assignment, NAME = DefaultUser
Hello, DefaultUser!

4. Maintenant, définissez NAME avant l'exécution :

NAME="Alice" ./assign_default.sh

Vous devriez voir :

Before assignment, NAME = Alice
After assignment, NAME = Alice
Hello, Alice!

Chaînage des valeurs par défaut

Parfois, vous souhaiterez peut-être vérifier plusieurs sources pour une valeur avant de revenir à une valeur par défaut codée en dur. Vous pouvez chaîner des valeurs par défaut pour y parvenir :

1. Créez un nouveau fichier nommé chain_defaults.sh dans le répertoire bash_defaults avec le contenu suivant :

#!/bin/bash

## Read config file if it exists
if [[ -f "./user.conf" ]]; then
  source "./user.conf"
fi

## Chain default values: command line arg -> config file -> environment var -> hard-coded default
USERNAME=${1:-${CONFIG_USER:-${USER:-"guest"}}}
LANGUAGE=${2:-${CONFIG_LANG:-${LANG:-"en_US"}}}

echo "Hello, $USERNAME! Your language is set to $LANGUAGE."

2. Rendez le script exécutable :

chmod +x chain_defaults.sh

3. Créez un fichier de configuration pour les tests :

echo "CONFIG_USER=ConfigUser" > user.conf
echo "CONFIG_LANG=es_ES" >> user.conf

4. Testez le script avec différentes combinaisons :

## Use defaults from the config file
./chain_defaults.sh

## Override with command line arguments
./chain_defaults.sh CommandLineUser fr_FR

## Remove config file to test falling back to environment variables
rm user.conf
./chain_defaults.sh

Valeurs par défaut conditionnelles

Vous pouvez également utiliser des expressions conditionnelles pour définir différentes valeurs par défaut en fonction des conditions :

1. Créez un nouveau fichier nommé conditional_defaults.sh dans le répertoire bash_defaults avec le contenu suivant :

#!/bin/bash

## Get the current hour (24-hour format)
HOUR=$(date +%H)

## Set default greeting based on time of day
if ((HOUR < 12)); then
  DEFAULT_GREETING="Good morning"
elif ((HOUR < 18)); then
  DEFAULT_GREETING="Good afternoon"
else
  DEFAULT_GREETING="Good evening"
fi

## Use the conditional default if no greeting is provided
GREETING=${1:-"$DEFAULT_GREETING"}
NAME=${2:-"User"}

echo "$GREETING, $NAME!"
echo "The current time is $(date +%H:%M)."

2. Rendez le script exécutable :

chmod +x conditional_defaults.sh

3. Exécutez le script pour voir comment il choisit une salutation par défaut en fonction de l'heure de la journée :

./conditional_defaults.sh

4. Remplacez la salutation par défaut :

./conditional_defaults.sh "Hello" "World"

Ces techniques avancées vous offrent plus de flexibilité lorsque vous travaillez avec des valeurs par défaut en Bash, vous permettant de créer des scripts plus sophistiqués et conviviaux.

Application des valeurs par défaut dans un script réel

Maintenant que nous avons couvert diverses techniques pour définir des valeurs par défaut, mettons tout ensemble dans un script pratique que vous pourriez utiliser dans un scénario réel.

Nous allons créer un script de sauvegarde qui utilise des valeurs par défaut pour diverses options de configuration. Ce script démontrera comment les valeurs par défaut rendent vos scripts plus flexibles et conviviaux.

Création d'un script de sauvegarde

1. Créez un nouveau fichier nommé backup.sh dans le répertoire bash_defaults avec le contenu suivant :

#!/bin/bash

## Backup script with default values for all parameters

## Source directories to backup (comma-separated) - default to current directory
SRC_DIRS=${1:-$(pwd)}

## Destination directory for backups - default to ~/backups
BACKUP_DIR=${2:-"$HOME/backups"}

## Backup filename prefix - default to "backup"
PREFIX=${3:-"backup"}

## Maximum number of backups to keep - default to 5
MAX_BACKUPS=${4:-5}

## Create destination directory if it doesn't exist
mkdir -p "$BACKUP_DIR"

## Generate timestamp for the backup filename
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="$BACKUP_DIR/${PREFIX}_${TIMESTAMP}.tar.gz"

echo "Starting backup process..."
echo "Source: $SRC_DIRS"
echo "Destination: $BACKUP_FILE"

## Create the backup archive (we'll simulate this for the lab)
echo "Creating backup archive..."
echo "tar -czf $BACKUP_FILE $SRC_DIRS" > "$BACKUP_DIR/last_backup_command.txt"
touch "$BACKUP_FILE" ## Just create an empty file for demonstration

## Clean up old backups if we have more than MAX_BACKUPS
echo "Checking for old backups to remove..."
NUM_BACKUPS=$(ls -1 "$BACKUP_DIR"/${PREFIX}_*.tar.gz 2> /dev/null | wc -l)
if ((NUM_BACKUPS > MAX_BACKUPS)); then
  NUM_TO_DELETE=$((NUM_BACKUPS - MAX_BACKUPS))
  echo "Removing $NUM_TO_DELETE old backup(s)..."
  ls -1t "$BACKUP_DIR"/${PREFIX}_*.tar.gz | tail -n "$NUM_TO_DELETE" | while read file; do
    echo "Would delete: $file (simulation)"
  done
else
  echo "No old backups need to be removed (keeping $NUM_BACKUPS of $MAX_BACKUPS maximum)"
fi

echo "Backup process completed!"
echo "Backup saved to: $BACKUP_FILE"

2. Rendez le script exécutable :

chmod +x backup.sh

3. Créez les répertoires nécessaires aux tests :

mkdir -p ~/backups
mkdir -p ~/test_data
echo "Test file 1" > ~/test_data/file1.txt
echo "Test file 2" > ~/test_data/file2.txt

Test du script de sauvegarde

Testons maintenant notre script de sauvegarde avec différentes combinaisons de paramètres pour voir comment les valeurs par défaut fonctionnent en pratique :

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

./backup.sh

Cela sauvegardera le répertoire actuel vers ~/backups avec le préfixe "backup".

2. Exécutez le script en spécifiant un répertoire source :

./backup.sh ~/test_data

Cela sauvegardera le répertoire test_data en utilisant les autres valeurs par défaut.

3. Exécutez le script avec une source et une destination personnalisées :

./backup.sh ~/test_data ~/project/bash_defaults/my_backups

4. Exécutez le script avec tous les paramètres spécifiés :

./backup.sh ~/test_data ~/project/bash_defaults/my_backups project_backup 3

Cet exemple montre comment les valeurs par défaut rendent vos scripts flexibles - les utilisateurs peuvent spécifier autant ou aussi peu de paramètres qu'ils en ont besoin, et votre script fonctionnera toujours correctement.

Vérifiez les résultats

Après avoir exécuté le script de sauvegarde avec différents paramètres, vous pouvez vérifier les résultats :

## Check the default backup location
ls -la ~/backups

## Check the custom backup location (if you used it)
ls -la ~/project/bash_defaults/my_backups

En utilisant des valeurs par défaut de manière cohérente dans vos scripts, vous créez des outils plus conviviaux et adaptables à différents environnements et cas d'utilisation.

Résumé

Dans ce laboratoire, vous avez appris à définir des valeurs par défaut dans les scripts Bash, une compétence fondamentale pour créer des scripts robustes et conviviaux. Tout au long du laboratoire, vous avez :

• Créé des scripts simples en utilisant des techniques de base de valeurs par défaut avec l'opérateur :-
• Travaillé avec des variables d'environnement et des valeurs par défaut
• Exploré des techniques avancées de valeurs par défaut, notamment l'opérateur d'affectation := et les valeurs par défaut conditionnelles
• Développé un script de sauvegarde pratique qui démontre comment les valeurs par défaut rendent vos scripts plus flexibles

Ces techniques permettent à vos scripts de bien fonctionner même lorsque les utilisateurs ne fournissent pas tous les paramètres attendus, ce qui les rend plus résistants et plus faciles à utiliser. Les valeurs par défaut simplifient également le développement et les tests de scripts en réduisant le besoin d'une validation d'entrée complète.

Lorsque vous continuez à écrire des scripts Bash, n'oubliez pas d'utiliser généreusement les valeurs par défaut pour améliorer l'expérience utilisateur et la robustesse de vos scripts. Cette pratique rendra vos scripts plus professionnels et utiles dans une variété d'environnements et de scénarios.