Transmission d'arguments au script

Introduction

En programmation Shell, la capacité de passer des arguments à un script est une fonctionnalité fondamentale et puissante. Elle permet aux scripts d'être plus flexibles et réutilisables en acceptant des entrées depuis la ligne de commande. Ce labo (LabEx) vous guidera tout au long du processus de création d'un script Shell capable d'accepter et d'utiliser des arguments de ligne de commande. Vous apprendrez à accéder à ces arguments dans votre script, à gérer plusieurs arguments et à utiliser des variables spéciales pour les traiter efficacement.

Skills Graph

Créer un nouveau fichier de script

Commençons par créer un nouveau fichier de script. Nous utiliserons l'WebIDE (VS Code) pour ce labo (LabEx).

1. Ouvrez l'WebIDE s'il n'est pas déjà ouvert.
2. Dans l'explorateur de fichiers à gauche, accédez au répertoire /home/labex/project.
3. Cliquez avec le bouton droit dans l'explorateur de fichiers et sélectionnez "Nouveau fichier".
4. Nommez le nouveau fichier arguments.sh.

Maintenant que nous avons créé le fichier, ajoutons la structure de base de notre script :

#!/bin/bash

## Votre code sera placé ici

La première ligne est appelée le "shebang" ou "hashbang". Elle indique au système quel interpréteur utiliser pour exécuter le script. Dans ce cas, nous utilisons bash.

Pour les débutants : La ligne shebang est importante car elle vous permet d'exécuter le script directement (comme ./arguments.sh) au lieu d'avoir à taper bash arguments.sh à chaque fois. C'est un détail mineur, mais il rend vos scripts plus pratiques à utiliser.

Accéder aux arguments du script

Maintenant, modifions notre script pour accéder et afficher les arguments qui lui sont passés. En programmation Shell, des variables spéciales sont utilisées pour accéder aux arguments de ligne de commande :

• $0 représente le nom du script lui-même
• $1, $2, $3, etc., représentent le premier, le deuxième, le troisième argument, et ainsi de suite

Ajoutez le code suivant à votre fichier arguments.sh :

#!/bin/bash

echo "Script name: $0"
echo "First argument: $1"
echo "Second argument: $2"
echo "Third argument: $3"

Ce script affichera le nom du script et les trois premiers arguments qui lui sont passés.

Pour les débutants :

• Le symbole $ est utilisé pour faire référence à des variables en bash.
• $0, $1, $2, etc., sont des variables spéciales que bash définit automatiquement pour vous lorsque vous exécutez un script avec des arguments.
• Si vous exécutez le script sans aucun argument, $1, $2 et $3 seront vides, mais le script continuera de s'exécuter sans erreur.

Rendre le script exécutable

Avant de pouvoir exécuter notre script, nous devons le rendre exécutable. Cela se fait en utilisant la commande chmod. Dans le terminal, accédez au répertoire du projet et exécutez la commande suivante :

cd /home/labex/project
chmod +x arguments.sh

La commande chmod +x ajoute les droits d'exécution au fichier, permettant de l'exécuter comme un script.

Pour les débutants :

• chmod signifie "change mode" (changer le mode). Elle est utilisée pour modifier les permissions d'un fichier ou d'un répertoire.
• L'option +x ajoute le droit d'exécution. Cela est nécessaire pour que bash puisse exécuter le fichier comme un script.
• Si vous oubliez cette étape, vous obtiendrez une erreur "permission denied" (permission refusée) lorsque vous essayerez d'exécuter votre script.

Exécuter le script avec des arguments

Maintenant que notre script est exécutable, exécutons-le avec quelques arguments. Dans le terminal, exécutez la commande suivante :

./arguments.sh hello world example

Vous devriez voir une sortie similaire à ceci :

Script name:./arguments.sh
First argument: hello
Second argument: world
Third argument: example

Cette sortie montre que notre script a réussi à accéder et à afficher les arguments de ligne de commande.

Pour les débutants :

• Le ./ avant le nom du script indique à bash de chercher le script dans le répertoire actuel.
• Chaque mot après le nom du script devient un argument distinct. Dans ce cas, "hello" est le premier argument, "world" est le deuxième et "example" est le troisième.
• Si vous souhaitez passer un argument contenant des espaces, vous devez utiliser des guillemets, comme ceci : ./arguments.sh "hello world" example

Gérer le nombre d'arguments

Modifions notre script pour gérer différents nombres d'arguments. Nous utiliserons la variable spéciale $#, qui contient le nombre d'arguments passés au script.

Mettez à jour votre fichier arguments.sh avec le contenu suivant :

#!/bin/bash

if [ $## -eq 0 ]; then
  echo "No arguments provided."
elif [ $## -eq 1 ]; then
  echo "One argument provided: $1"
elif [ $## -eq 2 ]; then
  echo "Two arguments provided: $1 and $2"
else
  echo "More than two arguments provided:"
  echo "First argument: $1"
  echo "Second argument: $2"
  echo "Third argument: $3"
  echo "Total number of arguments: $#"
fi

Ce script utilise des instructions conditionnelles pour gérer différents nombres d'arguments.

Pour les débutants :

• $# est une variable spéciale qui contient le nombre d'arguments passés au script.
• [ $## -eq 0 ] est une condition qui vérifie si le nombre d'arguments est égal à 0.
• elif est l'abréviation de "else if". Il vous permet de vérifier plusieurs conditions en séquence.
• L'opérateur -eq signifie "égal à". Il existe d'autres opérateurs comme -lt (inférieur à), -gt (supérieur à), etc.

Tester le script mis à jour

Maintenant, testons notre script mis à jour avec différents nombres d'arguments :

./arguments.sh
./arguments.sh one
./arguments.sh one two
./arguments.sh one two three four

Vous devriez voir des sorties différentes en fonction du nombre d'arguments fournis.

Pour les débutants :

• L'exécution du script sans aucun argument (./arguments.sh) déclenchera la première condition de notre script.
• Chaque commande suivante ajoute plus d'arguments, montrant ainsi comment notre script gère différents cas.
• Remarquez comment le comportement du script change en fonction du nombre d'arguments. Ce genre de flexibilité est très utile dans les scripts du monde réel.

Parcourir tous les arguments

Enfin, modifions notre script pour parcourir tous les arguments fournis en utilisant la variable spéciale $@, qui représente tous les arguments de ligne de commande.

Mettez à jour votre fichier arguments.sh avec le contenu suivant :

#!/bin/bash

echo "Total number of arguments: $#"
echo "All arguments:"

count=1
for arg in "$@"; do
  echo "Argument $count: $arg"
  count=$((count + 1))
done

Ce script utilise une boucle for pour parcourir tous les arguments et les afficher avec leur position.

Pour les débutants :

• $@ est une variable spéciale qui contient tous les arguments passés au script.
• La boucle for est utilisée pour parcourir une liste d'éléments. Dans ce cas, elle parcourt tous les arguments.
• $((count + 1)) est une expansion arithmétique en bash. Elle est utilisée pour incrémenter la variable count.
• Ce script fonctionnera avec n'importe quel nombre d'arguments, ce qui le rend plus flexible que nos versions précédentes.

Tester le script final

Testons notre script final avec plusieurs arguments :

./arguments.sh apple banana cherry date

Vous devriez voir une sortie similaire à ceci :

Total number of arguments: 4
All arguments:
Argument 1: apple
Argument 2: banana
Argument 3: cherry
Argument 4: date

Cela démontre que notre script peut désormais gérer n'importe quel nombre d'arguments et les afficher tous.

Pour les débutants :

• Cette version finale du script est beaucoup plus flexible que nos versions précédentes.
• Elle peut gérer n'importe quel nombre d'arguments, de zéro à plusieurs.
• Le script numérote désormais chaque argument, ce qui peut être très utile dans des scripts plus complexes.
• Essayez d'exécuter le script avec différents nombres d'arguments pour voir comment il se comporte.

Résumé

Dans ce laboratoire, vous avez appris à créer un script Shell capable d'accepter et de traiter des arguments de ligne de commande. Vous avez exploré plusieurs concepts clés :

1. Création et exécution d'un script
2. Accès aux arguments individuels à l'aide de variables spéciales ($1, $2, etc.)
3. Utilisation de la variable $## pour déterminer le nombre d'arguments
4. Mise en œuvre de la logique conditionnelle pour gérer différents nombres d'arguments
5. Utilisation de la variable $@ pour parcourir tous les arguments fournis

Ces compétences sont fondamentales en scripting Shell et vous permettront de créer des scripts plus flexibles et puissants qui peuvent s'adapter à différents types d'entrées. Au fur et à mesure que vous continuerez à développer vos compétences en scripting Shell, vous constaterez que la capacité à gérer les arguments de ligne de commande est essentielle pour créer des scripts polyvalents et réutilisables pour diverses tâches d'administration système et d'automatisation.