Dans cet atelier, vous allez découvrir les variables spéciales de la programmation shell. Ces variables fournissent des informations essentielles sur l'environnement d'exécution du script, telles que les arguments passés en ligne de commande, le nom du script ou encore l'identifiant du processus (PID). La maîtrise de ces variables vous permettra d'écrire des scripts shell plus flexibles et plus performants.
Commençons par créer un script shell simple pour illustrer l'utilisation des variables spéciales.
Ouvrez votre terminal dans l'interface WebIDE. Vous devriez voir une invite de commande prête à recevoir vos instructions.
Naviguez vers le répertoire du projet :
cd ~/projectCette commande change votre répertoire actuel pour ~/project, qui est votre espace de travail par défaut pour cet atelier.
special_vars.sh à l'aide de la commande suivante :touch special_vars.shLa commande touch crée un fichier vide s'il n'existe pas, ou met à jour sa date de modification s'il existe déjà.
Ouvrez le fichier dans l'éditeur de la WebIDE. Vous pouvez le faire en cliquant sur le nom du fichier dans l'explorateur de fichiers situé sur le côté gauche de votre écran.
Ajoutez le contenu suivant au fichier :
#!/bin/bash
echo "Script Name: $0"
echo "First Argument: $1"
echo "Second Argument: $2"
echo "All Arguments: $@"
echo "Number of Arguments: $#"
echo "Process ID: $$"Analysons le rôle de chaque ligne :
#!/bin/bash : C'est ce qu'on appelle le "shebang". Il indique au système d'utiliser l'interpréteur bash pour exécuter ce script.$0 : Cette variable spéciale contient le nom du script.$1 et $2 : Elles représentent respectivement le premier et le deuxième argument passés en ligne de commande.$@ : Cette variable représente l'ensemble des arguments passés au script.$# : Elle donne le nombre total d'arguments fournis.$$ : Elle fournit l'identifiant de processus (PID) du shell actuel.Enregistrez le fichier après avoir ajouté le contenu.
Rendez le script exécutable en lançant la commande suivante dans votre terminal :
chmod +x special_vars.shLa commande chmod modifie les permissions d'un fichier. L'option +x ajoute la permission d'exécution, vous permettant ainsi de lancer le script.
Maintenant que notre script est prêt, exécutons-le avec différents arguments pour observer le comportement des variables spéciales.
./special_vars.shLe préfixe ./ devant le nom du script indique au shell de chercher le fichier dans le répertoire courant.
Vous devriez obtenir un résultat similaire à celui-ci :
Script Name: ./special_vars.sh
First Argument:
Second Argument:
All Arguments:
Number of Arguments: 0
Process ID: 1234Remarquez que les premier et deuxième arguments sont vides, et que le nombre d'arguments est 0 puisque nous n'en avons fourni aucun.
./special_vars.sh hello worldLe résultat devrait ressembler à ceci :
Script Name: ./special_vars.sh
First Argument: hello
Second Argument: world
All Arguments: hello world
Number of Arguments: 2
Process ID: 1235Voici ce qui a changé :
$1 contient désormais "hello"$2 contient désormais "world"$@ affiche tous les arguments : "hello world"$# affiche 2, car nous avons fourni deux argumentsL'identifiant de processus ($$) sera probablement différent à chaque exécution, car il est attribué dynamiquement par le système d'exploitation.
$? et $!Deux autres variables spéciales essentielles sont $? et $!. Créons un nouveau script pour illustrer leur utilité.
exit_status.sh :touch ~/project/exit_status.sh#!/bin/bash
echo "Running a successful command:"
ls /home
echo "Exit status: $?"
echo "Running a command that will fail:"
ls /nonexistent_directory
echo "Exit status: $?"
echo "Running a background process:"
sleep 2 &
echo "Process ID of last background command: $!"Analysons ce script :
$? donne le code de retour (exit status) de la dernière commande exécutée. La valeur 0 signifie généralement un succès, tandis qu'une valeur différente de zéro indique diverses conditions d'erreur.$! donne l'identifiant de processus (PID) de la dernière commande lancée en arrière-plan.& à la fin d'une commande permet de l'exécuter en arrière-plan.chmod +x ~/project/exit_status.sh./exit_status.shVous devriez voir un résultat de ce type :
Running a successful command:
labex
Exit status: 0
Running a command that will fail:
ls: cannot access '/nonexistent_directory': No such file or directory
Exit status: 2
Running a background process:
Process ID of last background command: 1236Observations :
ls réussit, donc $? vaut 0.ls échoue (car le répertoire n'existe pas), donc $? vaut 2 (une valeur non nulle indiquant une erreur).sleep s'exécute en arrière-plan, et $! nous donne son PID.Les variables spéciales peuvent également être utilisées à l'intérieur des fonctions. Créons un script pour le démontrer.
function_vars.sh :touch ~/project/function_vars.sh#!/bin/bash
function print_args {
echo "Function Name: $0"
echo "First Argument: $1"
echo "Second Argument: $2"
echo "All Arguments: $@"
echo "Number of Arguments: $#"
}
echo "Calling function with two arguments:"
print_args hello world
echo "Calling function with four arguments:"
print_args one two three fourCe script définit une fonction print_args qui utilise des variables spéciales. Il appelle ensuite cette fonction deux fois avec un nombre d'arguments différent.
chmod +x ~/project/function_vars.sh./function_vars.shLe résultat devrait être le suivant :
Calling function with two arguments:
Function Name: ./function_vars.sh
First Argument: hello
Second Argument: world
All Arguments: hello world
Number of Arguments: 2
Calling function with four arguments:
Function Name: ./function_vars.sh
First Argument: one
Second Argument: two
All Arguments: one two three four
Number of Arguments: 4Notez que :
$0 fait toujours référence au nom du script, et non au nom de la fonction.$1, $2, $@ et $# fonctionnent pour les arguments de la fonction exactement comme ils le font pour les arguments du script.Les variables spéciales $@ et $* servent toutes deux à représenter l'ensemble des arguments de la ligne de commande, mais elles se comportent différemment lorsqu'elles sont entourées de guillemets doubles. Créons un script pour mettre en évidence cette différence.
at_vs_star.sh :touch ~/project/at_vs_star.sh#!/bin/bash
echo "Using \$@:"
for arg in "$@"; do
echo "Argument: $arg"
done
echo "Using \$*:"
for arg in "$*"; do
echo "Argument: $arg"
doneCe script illustre la différence entre $@ et $* lorsqu'ils sont utilisés dans une boucle.
chmod +x ~/project/at_vs_star.sh./at_vs_star.sh "arg with spaces" another_arg "third arg"Vous devriez obtenir ce résultat :
Using $@:
Argument: arg with spaces
Argument: another_arg
Argument: third arg
Using $*:
Argument: arg with spaces another_arg third argVoici l'explication :
"$@", chaque argument est traité comme une entité distincte. Les arguments contenant des espaces sont préservés en tant qu'unités individuelles."$*", tous les arguments sont combinés en une seule chaîne de caractères, séparés par le premier caractère de la variable IFS (Internal Field Separator), qui est généralement un espace.Cette distinction est cruciale lorsque vous devez traiter des arguments susceptibles de contenir des espaces ou d'autres caractères spéciaux.
Dans cet atelier, vous avez découvert les variables spéciales de la programmation shell et appris à les utiliser efficacement. Vous avez créé des scripts illustrant l'usage de diverses variables telles que $0, $1, $@, $#, $$, $? et $!. Vous avez également exploré le comportement de ces variables dans différents contextes, notamment au sein de fonctions et lors de la manipulation d'arguments complexes.
Points clés à retenir :
$0, $1, $2, etc., représentent le nom du script et les arguments de la ligne de commande.$@ et $# permettent de manipuler l'ensemble des arguments et de les compter.$$ vous donne le PID du processus actuel, ce qui est utile pour créer des fichiers temporaires uniques.$? permet de vérifier si la commande précédente s'est exécutée avec succès.$! fournit le PID du dernier processus lancé en arrière-plan, utile pour le contrôle des tâches.$@ et $* se comportent différemment lorsqu'ils sont entre guillemets, ce qui est primordial pour gérer les arguments contenant des espaces.La compréhension de ces variables spéciales est indispensable pour écrire des scripts shell avancés et flexibles. Elles permettent de concevoir des outils capables de s'adapter à diverses entrées et fournissent des informations précieuses sur l'environnement d'exécution.
Au fur et à mesure de votre pratique, vous trouverez de nombreuses autres façons de tirer parti de ces variables. N'hésitez pas à consulter le manuel de bash (man bash) pour obtenir des informations plus détaillées sur ces variables et bien d'autres.
