Les variables dans Bash

Avec un gros retard sur mes prévisions, voilà une introduction à la gestion des variables dans Bash.

Généralités

Les noms de variables sont relativement libres, mais ils sont limités aux lettres a-zA-Z, aux chiffres 0-9 et à l'underscore. Par ailleurs ils ne peuvent pas commencer par un chiffre.
J'ai pour préférence personnelle de nommer mes variables par des noms en majuscules, cela me permet de les distinguer facilement des noms de commandes. Cela posé, chacun fait comme il veut.
Un nom de variable ne commence pas par "$", c'est la référence à la valeur de la variable qui commence par "$". Donc VAR est ma variable, $VAR est sa valeur. On parle cependant de variable pour les deux notations, mais il faut garder cette distinction à l'esprit quand on rencontre certaines syntaxes particulières.

Comme le fait remarquer l'Advanced Bash Scripting Guide (ABSG), la forme $VAR est en réalité une forme abrégée de ${VAR}. Il est possible que dans certains contextes l'usage raccourci $VAR pose des problèmes. Il ne faut donc pas hésiter à employer la "version longue" ${VAR}.

Les variables (dans bash et dans d'autres shell, mais je me limite à bash) ne sont pas fortement typées, c'est à dire qu'elles prennent pour valeur indifféremment des chaînes de caractères, des tableaux, des entiers... La grosse différence se joue surtout entre les chaînes et les entiers. Un entier peut être traité comme une chaîne en cas d'opération de type chaîne :

VAR=1234		# définition
VAR=ABC$VAR		# concaténation
echo $VAR		# ABC1234

mais une chaîne est traitée comme un zéro en cas d'opération de type mathématique :

VAR=ABC			# définition
VAR=$((VAR + 0))	# addition d'un zéro
echo $VAR		# 0

Déclaration et assignation

On voit dans ces exemples qu'une déclaration de variable est plutôt immédiate. Il faut cependant bien surveiller sa syntaxe : jamais d'espace, ni avant, ni après le signe égal.
Si la valeur de la variable doit contenir des espaces, il faut les échapper, ou mettre des guillemets :

VAR=toto titi
-bash: titi: command not found

VAR="toto titi"
echo $VAR		# toto titi

VAR=foo\ bar
echo $VAR		# foo bar

Un exemple de tableau :

TABLE=( "A" "B" "C" )
echo ${TABLE[0]}	# accolades obligatoires !
			# résultat : A
			# la numérotation commence à 0
TABLE[4]="D"		# ajout d'un élément

Ce type de déclaration de variable est une assignation directe. Il est cependant possible de faire une pré-déclaration, même si c'est d'un usage plus marginal :

declare -i ENTIER
declare -a TABLEAU	# il y en a d'autres, voir l'ABSG

Ce typage permet de s'assurer dans une certaine mesure que nos variables ne contiennent pas n'importe quoi.
Par exemple, une variable déclarée comme entier ne pourra pas contenir de chaîne de caractères :

declare -i NOMBRE
NOMBRE=trois
echo $NOMBRE		# donne 0, NOMBRE contient bien un entier en dépit de
			# l'assignation de la chaîne "trois"

Il existe toute une série d'autres manières d'assigner une variable.
Par exemple :

let "VAR = 50"			# assignation par la commande let
let "TOTAL = VAR1 + VAR2"	# assignation avec calcul
for VAR in 1 2 3; do ...	# assignation par une boucle for
read -p "valeur : " VAR		# assignation par la commande read
VAR=`ls -1`			# assignation par "capture" du
				# résultat de la commande ls -1
VAR=$(ls -1)			# idem, en plus souple

Variables d'environnement et variables transmises

Certaines variables sont particulières : les variables d'environnement. Les variables d'environnement existent dans le shell, et elles sont accessibles à tous les processus de la machine. Elles peuvent définir tout un tas de choses propres au shell ou à l'environnement de travail au sens large. Encodage du texte, formatage des nombres, chemin d'accès des binaires sont quelques exemples.
Pour avoir un aperçu des variables définies dans l'environnement, on peut utiliser la commande `env`.
On ajoute des variables d'environnement en exportant une variable existante (ou en l'exportant au moment de sa création) :

VAR="toto"; export VAR

ou directement

export VAR="toto"

Note : un script shell peut définir des variables d'environnement, mais ces variables ne seront accessibles que par lui et par les processus lancés par lui.
Bash défini par ailleurs tout un tas de variables internes que vous pourrez découvrir dans le chapitre "Shell Variables" du man bash ou dans l'ABSG.

Un autre groupe de variables intéressant est le groupe des paramètres transmis (à une commande ou un script). On utilise souvent les commandes dans le shell avec un ou plusieurs arguments :

man 1 env		# par exemple

Ici la commande man est lancée avec deux arguments : "1" et "env". Il est possible de créer des scripts shell ou des fonctions bash utilisant le même principe :

mon_script.sh arg1 arg2

Le script mon_script.sh doit alors être capable de récupérer ces paramètres transmis sous forme de variable. C'est un processus automatique géré par l'interpréteur du script shell (bash ici). Chaque paramètre transmis est injecté dans une variable numérotée. Ainsi, dans mon_script.sh, $1 vaut arg1 et $2 vaut arg2. Au delà de 9, les accolades sont obligatoires : ${10}, ${11}...

Le nombre d'arguments passés est aussi stocké dans une variable particulière : $#
Quant à l'ensemble des arguments passés, il peut être obtenu par les variables $* et $@ (qui n'ont pas tout à fait le même comportement, je vous renvoie à l'ABSG pour les explications détaillées).

N'hésitez pas à poser vos questions, à faire vos remarques ou à me corriger.

Pour aller un peu plus loin, n'hésitez pas à consulter les autres articles sur bash !

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.