Introduction aux scripts de l'interpréteur BASH

Modèle:Article incomplet

Un petit script simple

Voici un petit script exemple.sh qui sera exécuté par l’interpréteur de commande bash. Le script a été créé à l’aide d’un éditeur de texte tel gedit ou vi.

#!/bin/bash
#fichier exemple.sh
# ceci est un commentaire
echo "Le nombre de parametres est: "  $#
echo "Les parametres sont :" $*
echo ' Les paramtetres sont aussi disponible comme ceci : ' $@ 
echo "Le parametre numero 1 est : " $1
echo "Le parametre numero 12 est : " ${12}
echo "Mon numero de processus (PID) est: " $$
echo "Entrez un nombre au clavier: "
read nombre
echo "Votre nombre est : " ${nombre:-nul}

Explication du script

Le script débute avec la ligne #!/bin/bash. Normalement, ‘ # ’ indique le début d’un commentaire. Cependant, la séquence ‘#!’ au début d’un script indique à Linux d’utiliser le programme spécifié, ici, l’interpréteur de commandes /bin/bash pour interpréter et exécuter les commandes qui suivent.

Les paramètres passés au script sont disponibles via les variables $1, $2, ... $9. $* et $@ représentent la liste de tous les paramètres passés au script alors que $# contient le nombre de paramètres. La variable $$ contient le numéro du processus qui exécute le script (résultat d’un fork et exec).

L’énoncé read nombre attend une entrée de l’entrée standard (habituellement le clavier) et attribue la valeur fournie à la variable nombre. Pour utiliser le contenu de la variable nombre, on peut utiliser la syntaxe $nombre ou bien ${nombre}. On peut aussi attribuer une valeur par défaut à la variable nombre si aucune valeur n’a été fournie au clavier: dans cet exemple, si aucune valeur n’est fournie, la variable nombre prend pour valeur nul.

Pour exécuter ce script, il faut tout d’abord le rendre exécutable:

-bash-3.2$ ls -l exemple.sh
-rw-r--r--. 1 caveenj users 289 nov  2 20:20 exemple.sh
-bash-3.2$ chmod +x exemple.txt
-bash-3.2$ ls -l exemple.sh
-rwxr-xr-x. 1 caveenj users 289 nov  2 20:20 exemple.sh
-bash-3.2$ ./exemple.sh bonjour tout le monde 
Le nombre de parametres est:  4 
Les parametres sont : bonjour tout le monde 
Les paramtetres sont aussi disponible comme ceci : bonjour tout le monde 
Le parametre numero 1 est :  bonjour 
Le parametre numero 12 est :
Mon numero de processus (PID) est:  3576 
Entrez un nombre au clavier: 
6 
Votre nombre est :  6 
-bash-3.2$

Nous pouvons utiliser la redirection des entrées-sorties avec les scripts:

-bash-3.2$ echo 6 | ./exemple.sh bonjour tout le monde

donnera le même résultat sans attendre qu'on fournisse un nombre à partir du clavier.

Récapitulatif des variables spéciales d'un script

#!/bin/bash

Syntaxe donnant le nom de l'interpréteur de commande à utiliser pour exécuter le script. Cet énoncé doit se trouver sur la première ligne du script.

$#

Contient le nombre de paramètres (ou arguments) que l'utilisateur a fourni lors de l'appel du script. Si on appelle le script exemple.sh de la façon suivante: exemple.sh a b c d, $# aura pour valeur 4 et l'appel exemple.sh a b c d e f donnera à $# la valeur 6.

$1

Contient la valeur du premier argument. L'appel exemle.sh a b c d attribue la valeur a à $1.

$2

Contient la valeur du deuxième argument. L'appel exemle.sh a b c d attribue la valeur b à $2.

$3, $4,...$n

Comme précédemment pour les paramètres 3,4,...n.

$* ou $@

Ces variables contiennent la liste complète des arguments passés au script. Par exemple, si on lance la commande exemple.sh a b c d e f, la variable $* aura pour valeur a b c d e f.

$0

Cette variable contient le nom du script, tel qu'il a été invoqué pour son exécution. Si on exécute notre script avec l'appel suivant: ./exemple.sh la variable $0 aura pour valeur ./exemple.sh.

$$

Cette variable contient le numéro du processus qui exécute le script. En effet, sous UNIX,à chaque fois qu'on lance un programme (ou un script), un nouveau processus est créé auquel le système d'exploitation attrbue un identifiant unique, le numéro de processus (ou PID). Ce numéro étant unique, on peut l'utiliser dans un script pour créer un fichier ou répertoire temporaire en ajoutant $$ au nom du fichier/répertoire à créer: mkdir travail_$$.

Les énoncés de contrôle

Énoncé if-then-else

Les scripts bash peuvent exécuter des branchements selon une condition :

if [ test ]
then
     commandes à exécuter si test est vrai
fi

ou:

if [ test ]
then
     commandes à exécuter si test est vrai
else
     commandes à exécuter si test est faux
fi

ou encore:

if [ test ]
then
     commandes à exécuter si test est vrai
elif [ test]
then
     commandes à exécuter si test est vrai
else
     commandes à exécuter si test est faux
fi

La condition (test) à évaluer peut impliquer les propriétés de fichiers ou répertoires, ou bien simplement être une comparaison de nombres ou de chaînes de caractères.

Attention : Le caractère ‘[‘ utilisé ici est en fait une commande (/usr/bin/[) servant à évaluer l’expression test. Il faut donc mettre des espaces (blancs) avant et après les symboles ‘[‘ et ‘]’ .

Voici quelques conditions très utilisées:

-s fichier

retourne vrai si fichier existe et est non vide

-f fichier

retourne vrai si fichier est un fichier ordinaire

-d fichier

retourne vrai si fichier est un répertoire

-r fichier

retourne vrai si on peut lire fichier

-w fichier

retourne vrai si on peut écrire dans fichier

-x fichier

retourne vrai si fichier est exécutable

$X -eq $Y

vrai si X est égal à Y (comparaison d'entiers)

$X -ne $Y

vrai si X n’est pas égal à Y (comparaison d'entiers)

$X -lt $Y

vrai si X est plus petit que Y (comparaison d'entiers)

$X -gt $Y

vrai si X est plus grand que Y (comparaison d'entiers)

$X -le $Y

vrai si X est plus petit ou égal Y (comparaison d'entiers)

$X -ge $Y

vrai si X est plus grand ou égal à Y (comparaison d'entiers)

$X ! -gt $Y

vrai si X n’est pas plus grand que Y (! inverse le résultat de la relation) (comparaison d'entiers)

"$A" = "$B"

vrai si la chaîne A est égale à la chaîne B (comparaison de chaînes)

"$A" != "$B"

vrai si la chaîne A n’est pas égale à la chaîne B (comparaison de chaînes)

$E -a $F

vrai si E et F sont tous les deux vrai (ET)

$E -o $F

vrai si E ou F est vrai (OU)

Exemples

nombre=100
if [ $nombre -eq 100 ]
then
    echo 'nombre egal 100'
fi

nombre=100
if [ $nombre -eq 100 ]
then
   echo 'nombre egal 100'
else
   echo 'nombre different de 100'
fi

nombre=100
if [ $nombre -lt 100 ]
then
   echo 'nombre plus petit que 100'
elif [ $nombre -gt 100 ]
then
    echo 'nombre plus grand que 100'
else
    echo 'Nombre est egal a 100'
fi

Les boucles for

Lorsque nous voulons, par exemple, faire un ensemble d’opérations sur plusieurs fichiers, nous pouvons utiliser une boucle for:

for var in liste
do
    commande ( utilisant $var)
done

Ici, liste représente une suite de valeurs qui seront attribuées à la variable var une après l'autre à chacune des itérations de la boucle. Par exemple l'énoncé for val in 1 2 3 4 5 provoquera cinq itérations au cours desquelles la variable val prendra succesivement pour valeur 1,2,3,4 et 5.

Exemples

Le script suivant trie (commande sort) le contenu de tous les fichiers du répertoire courant ayant dans leur nom l’extension .txt et écrit le résultat dans un fichier ayant pour nom le même nom auquel on ajoute le suffixe trie:

#!/bin/bash
#fichier triertout.sh
for f in *.txt
do
   echo On trie le fichier $f
   cat $f | sort > $f.trie
   echo le fichier trie est conserve dans le fichier $f.trie
done
          

Le script suivant reçoit une année en paramètre et affiche un calendrier de chaque mois de l’année sur la sortie standard (l’écran) tout en s’assurant que l’année est entre 1 et 9999. Notons l'utilisation de l'opérateur logique -o dans le second énoncé if.

#!/bin/bash 
#fichier calendrier.sh
#
#On s'assure d'avoir recu une annee en parametre
#
if [ $# -ne 1 ] 
then 
    echo usage $0 annee 
    exit 1 
fi 
#
#On initialise la variable annee en on valide sa valeur
#
annee=$1 
if [ $annee -lt 1 -o $annee -gt 9999 ] 
then 
    echo Annee doit etre entre 1 et 9999 
    exit 1 
fi 
#
#On boucle sur les 12 mois avec la commande seq()
#et on affiche un calendrier pour chacun des mois de l'annee 
#
for mois in $(seq 01 12) 
do 
    cal ${mois} ${annee} 
done

Boucle while

Une autre forme de boucle est la boucle while:

while [ test ]
do
     commandes     (à être exécutées tant que test est vrai)
done

Exemples

Le script suivant attend que le fichier donnees_entree.txt soit créé et soit non vide puis il se termine. Mentionnons l'emploi de l'opérateur ! pour inverser la condition de l'énoncé while (c.a.d., on boucle tant que le fichier donnees_entree.txt n'existe pas).

#!/bin/bash
#fichier attend1.sh
while [ ! -s  donnees_entree.txt ]
do
   echo on attend ...
   sleep 5
done
echo le fichier donnees_entree.txt est pret
exit 0

Vous pouvez terminer l’exécution d’un script n’importe quand en utilisant l’énoncé exit. Le script suivant est donc équivalent:

#!/bin/sh
#fichier attend2.sh
while true
do
   if [ -s donnees_entree.txt ]
   then
       echo donnees_entree.txt est pret
       exit 0
   fi
   echo on attend...
   sleep 5
done

Le script suivant initialise un compteur à 1 et boucle tant que le compteur n'a pas pour valeur 100:

#/bin/bash
#
#Initialisation du compteur
#
compteur=1
while [ $compteur -lt 100 ]
do
      #incrementer le compteur
      compteur=$(( $compteur + 1 ))
done

Enoncé case

L’énoncé case permet d’effectuer un branchement d’exécution en comparant la valeur d'une variable à plusieurs patrons possibles. Lorsqu'il y a concordance entre la valeur de la variable et un patron, les commandes associées à ce patron sont alors exécutées.

case variable in
  patron1)
    commande  (exécuté si  variable concorde à patron1)
    ;;
  patron2)
    commande
    ;;
   etc.
esac

Exemples

L'exemple suivant détermine si la valeur d'un nombre positif est inférieure à 10, entre 10 et 99 ou supérieure à 100:

#!/bin/bash
nombre=89
case $nombre in 
  [0-9][0-9][0-9]*)    
     echo nombre plus grand ou egal 100
     ;; 
  [0-9][0-9])    
     echo nombre entre 10 et 99
     ;; 
  [0-9])    
     echo nombre entre 0 et 9
     ;; 
esac

L’exemple suivant tente de déterminer la nature de chacun des fichiers passés en paramètre, soit à partir de son nom ou de son extension. On remarquera dans l’exemple:

• l’emploi de l’opérateur « | » (OU) pour indiquer des patrons multiples ;
• l'emploi de « * » utilisé pour indiquer n’importe-quoi ;
• la syntaxe $(commande) qui permet d’exécuter une commande et dans récupérer le résultat. Ici, le résultat de $(file -b ...) est récupéré et affiché par la commande echo.

#!/bin/bash
#fichier natfic.sh
#
#On boucle sur tous les fichiers qui ne sont 
#pas des répertoires et qui ne sont pas executables
#
for fichier in $*
do
   if [ -f $fichier -a ! -x $fichier ]
   then
      case $fichier in
          core)
              echo "$fichier : un fichier core"
              ;;
          *.c)
              echo "$fichier : un programme en C"
              ;;
          *.cpp|*.cc|*.cxx)
              echo "$fichier: un programme en C++"
              ;;
          *.txt)
              echo "$fichier: un fichier texte"
              ;;
          *.pl)
              echo "$fichier: un script en langage PERL"
              ;;
          *.html|*.htm)
              echo "$fichier: un fichier WEB"
              ;;
          *)
              echo "$fichier: semble etre un fichier " $(file -b $f)
              ;;
     esac
  fi
done