Les variables sont des éléments fondamentaux pour la création de scripts efficaces et la compréhension du code que vous utilisez sur votre système Linux. Cet article vous guidera à travers les bases des variables et leur application pratique.
Variables : Les Fondamentaux
Les variables sont des identifiants symboliques qui représentent une chaîne de caractères ou une valeur numérique. Lorsque ces symboles sont employés dans des commandes ou expressions, le système les interprète comme si vous aviez directement saisi la valeur qu’ils contiennent, plutôt que le nom de la variable elle-même.
Pour définir une variable, il suffit de lui attribuer un nom et une valeur. Les noms de variables doivent être clairs et descriptifs, reflétant la donnée qu’ils conservent. Un nom de variable ne doit pas commencer par un chiffre ni contenir d’espaces, mais peut débuter par un tiret bas. Hormis ces restrictions, une combinaison de caractères alphanumériques en majuscules ou minuscules est acceptable.
Exemples Concrets
Nous allons illustrer la création de cinq variables : quatre variables textuelles et une variable numérique nommée `annee_courante`. La syntaxe est simple : `nom_variable=valeur`. Il est essentiel de ne pas insérer d’espaces avant ou après le signe égal. L’action d’affecter une valeur à une variable est souvent désignée comme « l’attribution d’une valeur ».
nom_utilisateur=David
systeme_exploitation=Linux
personnage=Popeye
aliment_favori=Épinards
annee_courante=2023
Pour afficher la valeur stockée dans une variable, on utilise la commande `echo`. Il est impératif de faire précéder le nom de la variable du symbole dollar (`$`) lorsque vous souhaitez accéder à sa valeur, comme suit :
echo $nom_utilisateur
echo $systeme_exploitation
echo $annee_courante
Utilisons toutes nos variables ensemble :
echo "$systeme_exploitation est à $nom_utilisateur ce que $aliment_favori est à $personnage (c) $annee_courante"
Les valeurs des variables remplacent leurs noms. Il est également possible de modifier la valeur d’une variable. Pour changer la valeur de `systeme_exploitation`, il suffit de réitérer le processus d’affectation initial:
systeme_exploitation=Tequila
Si nous réexécutons la commande précédente, nous obtiendrons un résultat différent :
echo "$systeme_exploitation est à $nom_utilisateur ce que $aliment_favori est à $personnage (c) $annee_courante"
Ainsi, la même commande qui utilise les mêmes variables peut produire des résultats variables en fonction de la modification de ces dernières.
Nous aborderons la question des guillemets autour des variables plus tard. Voici quelques points essentiels à retenir :
Une variable entre apostrophes (‘) est interprétée comme une chaîne littérale, non comme une variable.
Les variables entre guillemets (« ) sont interprétées comme des variables.
Pour obtenir la valeur stockée dans une variable, vous devez utiliser le symbole dollar ($).
Une variable sans le signe dollar ($) retourne simplement le nom de la variable.
Il est possible de créer une variable à partir d’une ou plusieurs variables existantes. La commande ci-dessous crée une variable appelée `boisson_de_lannee` à partir des variables `systeme_exploitation` et `annee_courante` :
boisson_de_lannee="$systeme_exploitation $annee_courante"
echo $boisson_de_lannee
Utiliser les Variables dans les Scripts
Les variables sont indispensables dans les scripts pour leur apporter la flexibilité nécessaire pour une solution générique et non spécifique. Pour illustrer ce concept, prenons l’exemple d’un script qui compte le nombre de fichiers dans le répertoire `/dev`.
Copiez le code ci-dessous dans un fichier texte et enregistrez-le sous le nom `compte_fichiers.sh` :
#!/bin/bash repertoire_cible=/dev nombre_fichiers=$(ls $repertoire_cible | wc -l) echo $nombre_fichiers fichiers dans $repertoire_cible
Pour que le script soit exécutable, utilisez la commande suivante :
chmod +x compte_fichiers.sh
Exécutez le script via la commande suivante :
./compte_fichiers.sh
Ce script affichera le nombre de fichiers contenus dans `/dev`. Voici son fonctionnement détaillé :
- Une variable, `repertoire_cible`, est créée et contient la chaîne « /dev ».
- Une autre variable, `nombre_fichiers`, est définie et prend sa valeur d’une substitution de commande. Cette substitution est délimitée par la syntaxe `$()`. Notez le signe dollar `$` avant la première parenthèse. La construction `$()` permet d’évaluer la commande interne et de retourner sa sortie. Dans cet exemple, cette sortie est assignée à `nombre_fichiers`. Pour la variable `nombre_fichiers`, sa valeur est obtenue via une substitution de commande.
- La commande évaluée dans la substitution de commande exécute `ls` sur le répertoire pointé par la variable `repertoire_cible`. Ainsi, le script exécute `ls /dev`.
- La sortie de `ls /dev` est dirigée vers la commande `wc`. L’option `-l` (nombre de lignes) de `wc` permet de compter le nombre de lignes dans la sortie de `ls`. Étant donné que chaque fichier est listé sur une ligne distincte, cela équivaut au nombre de fichiers et de sous-répertoires dans `/dev`. Cette valeur est stockée dans `nombre_fichiers`.
- Enfin, la dernière ligne du script utilise `echo` pour afficher le résultat.
Cependant, ce script ne fonctionne que pour `/dev`. Comment le rendre utilisable avec n’importe quel répertoire ? Un petit ajustement suffit.
Les Paramètres de Ligne de Commande
De nombreuses commandes comme `ls` ou `wc` acceptent des paramètres en ligne de commande, fournissant des informations à la commande sur ce que l’utilisateur souhaite qu’elle exécute. Si vous souhaitez utiliser `ls` sur votre répertoire personnel et afficher les fichiers cachés, vous pouvez utiliser la commande `ls ~ -a`, où `~` et `-a` sont des paramètres en ligne de commande.
Nos scripts peuvent également accepter des paramètres. Ces derniers sont référencés par `$1` pour le premier, `$2` pour le second, et ainsi de suite jusqu’à `$9` pour le neuvième. Il existe aussi `$0`, mais il est réservé au nom du script.
Ces paramètres peuvent être référencés dans un script comme n’importe quelle autre variable. Modifions notre script et sauvegardons-le sous `compte_fichiers2.sh` :
#!/bin/bash repertoire_cible=$1 nombre_fichiers=$(ls $repertoire_cible | wc -l) echo $nombre_fichiers fichiers dans $repertoire_cible
Cette fois, la variable `repertoire_cible` prend la valeur du premier paramètre de ligne de commande `$1`.
Le reste du script fonctionne comme précédemment. Au lieu d’une solution spécifique, votre script est devenu une solution générique utilisable avec n’importe quel répertoire, n’étant plus limité à `/dev`.
Rendez le script exécutable :
chmod +x compte_fichiers2.sh
Maintenant, testez le script avec différents répertoires. Commencez avec `/dev` pour vérifier que le résultat est le même qu’avant. Tapez :
./compte_fichiers2.sh /dev
./compte_fichiers2.sh /etc
./compte_fichiers2.sh /bin
Le résultat pour `/dev` est identique (207 fichiers), validant la nouvelle version. Le script fournit également des résultats spécifiques à chaque répertoire fourni en argument.
Pour simplifier le script, vous pouvez supprimer la variable `repertoire_cible` et directement utiliser `$1` :
#!/bin/bash nombre_fichiers=$(ls $1 | wc -l) echo $nombre_fichiers fichiers dans $1
Les Variables Spéciales
Nous avons mentionné `$0`, qui représente toujours le nom du script. Cela permet de récupérer le nom du script pour l’afficher, même s’il est renommé. C’est particulièrement utile pour les journaux, où il est important d’identifier le processus qui a généré un enregistrement.
Voici d’autres variables prédéfinies spéciales :
- `$#`: Nombre de paramètres passés au script.
- `$@`: Liste de tous les paramètres passés au script.
- `$?`: Statut de sortie de la dernière commande exécutée.
- `$$`: Identifiant de processus (PID) du script.
- `$USER`: Nom de l’utilisateur exécutant le script.
- `$HOSTNAME`: Nom de l’hôte de l’ordinateur exécutant le script.
- `$SECONDS`: Nombre de secondes pendant lesquelles le script s’exécute.
- `$RANDOM`: Retourne un nombre aléatoire.
- `$LINENO`: Retourne le numéro de la ligne actuelle du script.
Pour les voir toutes à l’œuvre dans un script, sauvegardez le code ci-dessous dans un fichier nommé `variables_speciales.sh` :
#!/bin/bash echo "Il y a $# paramètres en ligne de commande" echo "Ils sont : $@" echo "Le premier paramètre est : $1" echo "Le script est nommé : $0" # Une ancienne commande quelconque pour récupérer son statut de sortie pwd echo "pwd a retourné $?" echo "Ce script a l'ID de processus $$" echo "Le script a été lancé par $USER" echo "Il est exécuté sur $HOSTNAME" sleep 3 echo "Il s'exécute depuis $SECONDS secondes" echo "Nombre aléatoire : $RANDOM" echo "C'est la ligne numéro $LINENO du script"
Rendez le script exécutable :
chmod +x variables_speciales.sh
Exécutez-le avec différents paramètres de ligne de commande :
Les Variables d’Environnement
Bash utilise des variables d’environnement pour stocker des informations sur l’environnement dans lequel il est exécuté. Ces variables fournissent des données telles que votre nom d’utilisateur, vos paramètres linguistiques, la taille de votre historique de commandes, votre éditeur par défaut, et plus encore.
Pour voir les variables d’environnement actives, utilisez la commande :
env | less
Parcourez la liste et identifiez celles qui pourraient être utiles à vos scripts.
L’Exportation de Variables
Lorsqu’un script s’exécute, il est lancé dans son propre processus, et ses variables ne sont pas visibles en dehors de ce processus. Si vous souhaitez partager une variable avec un autre script que votre script lance, il est nécessaire d’exporter cette variable. Nous allons illustrer ce processus avec deux scripts.
Tout d’abord, créez le script `script_un.sh` :
#!/bin/bash premiere_variable=alpha seconde_variable=bravo # Vérification des valeurs echo "$0: premiere_variable=$premiere_variable, seconde_variable=$seconde_variable" export premiere_variable export seconde_variable ./script_deux.sh # Vérification des valeurs après exécution du deuxième script echo "$0: premiere_variable=$premiere_variable, seconde_variable=$seconde_variable"
Ce script crée deux variables, `premiere_variable` et `seconde_variable`, avec des valeurs initiales. Il les affiche dans le terminal, les exporte et lance `script_deux.sh`. Après le retour de ce script, il affiche à nouveau la valeur des variables, vous permettant ainsi de voir si elles ont été modifiées.
Le second script, `script_deux.sh`, est le script appelé par le premier. Voici son code:
#!/bin/bash # Vérification des valeurs echo "$0: premiere_variable=$premiere_variable, seconde_variable=$seconde_variable" # Modification des valeurs premiere_variable=charlie seconde_variable=delta # Vérification des valeurs après modification echo "$0: premiere_variable=$premiere_variable, seconde_variable=$seconde_variable"
Ce script affiche la valeur des variables, les modifie et les affiche à nouveau.
Rendez ces deux scripts exécutables :
chmod +x script_un.sh chmod +x script_deux.sh
Lancez `script_un.sh` :
./script_un.sh
La sortie nous apprend que :
- `script_un.sh` affiche les valeurs initiales des variables, alpha et bravo.
- `script_deux.sh` affiche les valeurs des variables qu’il a reçues, également alpha et bravo.
- `script_deux.sh` modifie les variables en charlie et delta.
- `script_un.sh` affiche à nouveau ses variables, qui sont toujours alpha et bravo.
Les changements effectués dans le second script n’affectent que ce second script. Les variables d’origine dans le premier script restent inchangées. C’est comme si des copies des variables étaient envoyées au second script, et que ces copies étaient supprimées lorsque le second script se termine. L’export de la variable permet de la transmettre mais ne permet pas de la modifier depuis un autre script.
Les Guillemets et les Variables
Vous avez peut-être remarqué que les variables sont souvent entre guillemets (« ) dans les scripts. Cela assure que les variables soient interprétées correctement et que leurs valeurs soient utilisées lors de l’exécution de la ligne.
Si la valeur que vous assignez à une variable contient des espaces, il est impératif d’entourer cette valeur de guillemets lors de l’affectation, car Bash utilise les espaces comme séparateurs par défaut.
Voici un exemple:
nom_site=toptips.fr
Bash interprète l’espace avant « Geek » comme le début d’une nouvelle commande. Il signale que cette commande n’existe pas. Un echo montrera que la variable `nom_site` ne contient rien, même pas le texte « How-To ».
Essayez avec des guillemets :
nom_site="toptips.fr"
Cette fois, la valeur est interprétée comme une entité unique et correctement attribuée à la variable `nom_site`.
La Commande `echo` : Votre Alliée
Il faut parfois du temps pour s’habituer aux substitutions de commandes, à l’usage des guillemets et à savoir quand utiliser le signe dollar.
Avant de valider une ligne de commande Bash, utilisez la commande `echo` devant cette ligne. Cela vous permettra de vous assurer que le comportement du code correspond à ce que vous attendez. Cette pratique permet également de repérer d’éventuelles erreurs de syntaxe.