Une commande externe est un fichier présent dans l'arborescence.

Quand un utilisateur exécute la commande ls, le shell demande au noyau Linux d'exécuter le fichier /bin/ls

Sont considérés comme commandes externes, tous les fichiers au format binaire exécutable ainsi que tous les fichiers au format texte représentant un script de commandes.

La commande file indique le type de données contenues dans un fichier.

$ file /bin/ls
/bin/ls: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.15, stripped

$ file monscript
monscript: POSIX shell script text executable

L'argument de la commande file est un nom de fichier indiqué en relatif ou en absolu

Une commande interne est intégrée au processus shell.

Elle n'a aucune correspondance avec un fichier sur le disque.

La commande type indique si une commande est interne ou externe.

$ type cd
cd est une primitive du shell

$ type ls
ls est un alias vers « ls --color=auto »

La commande type prend en argument le nom d'une commande. Si cette dernière n'est pas une commande interne, elle est recherchée dans les répertoires indiqués dans la variable PATH

Certaines commandes ont une implémentation interne et externe.

• La commande interne est exécutée en priorité.
• L'exécution d'une commande interne est plus rapide.
• La commande type, indique que la commande est interne mais ne précise pas qu'elle peut également être une commande externe.

La commande pwd est une commande interne :

$ type pwd
pwd est une primitive du shell

La commande pwd possède également une implémentation externe :

$ ls -l /bin/pwd
-rwxr-xr-x 1 root root 34376 2010-09-21 20:33 /bin/pwd

Pour forcer l'utilisation de la commande externe, il faut indiquer l'emplacement de la commande :

$ /bin/pwd
/home
$ cd /bin
$ ./pwd
/bin

Attention, certaines de ces expressions ne fonctionnent pas toutes avec les mêmes shell.
Pour certaines, elles sont compatibles BASH, pour d'autres ZSH et certaines ne fonctionnent qu'avec KSH.

Le caractère "*" permet de remplacer n'importe quel caractère.

$ ls
fichier1 fichier2.a monfichier tOnfichier.b

• Afficher uniquement les fichiers se terminant par ".a" :

$ ls *.a
fichier2.a

• Afficher uniquement les fichiers commançant par "f" :

$ ls f*
fichier1 fichier2.a

Le caractère "?" représente un caractère quelconque.

• Afficher uniquement les fichiers ayant une extension composée d'un seul caractère :

$ ls *.?
fichier2.a tOnfichier.b

• Afficher uniquement les fichiers composés de 8 caractères :

$ ls ????????
fichier1

Les caractères "[ ]" permettent d'indiquer la liste des caractères que l'on recherche à une position bien précise dans le noms des fichiers.

• Afficher les fichiers commençant par la lettre "f" ou "t" et se terminant
  par le "." suivi d'une lettre minuscule :

$ ls [ft]*.[a-z]
fichier2.a tOnfichier.b

• Afficher tous les fichiers ayant en deuxième caractère une lettre majuscule, ou un chiffre,
  ou la lettre "e" :

% ls ?[A-Z0-9e]*
cOucou  f1chier  F2chier  Hello

• Afficher tous les fichiers ne commançant pas par une lettre minuscule :

$ ls [!a-z]*
1coucou  Coucou  F2chier  Fichier  Hello

• Supprimer tous les fichiers se terminant par .b ou .c :

% rm -i *.b *.c
rm : supprimer fichier vide «fichier1.b» ? y
rm : supprimer fichier vide «fichier1.c» ? y

Les expressions complexes sont compatible BASH à condition d'activer l'option extglob avec la commande shopt (shopt -s extglob).

$ ls
1coucou   coucou.t    fichier159159159.log  fichier161.log  fichier.log
cOucou    coucou.uvw  fichier159159.log     fichier1.a      Hello.txt
Coucou    f1chier     fichier159160.log     fichier1.abc
coucou.r  F2chier     fichier159.log        fichier1.b
coucou.s  Fichier     fichier160.log        fichier1.c

• ?(expression)

L'expression sera présente 0 ou 1 fois.

Afficher tous les fichiers dont le nom contient 0 ou 1 fois "159"

$ ls fichier?(159).log
fichier159.log  fichier.log

• *(expression)

L'expression sera présente entre 0 et x fois.

Afficher tous les fichiers dont le nom contient 0 ou x fois "159"

$ ls fichier*(159).log
fichier159159159.log  fichier159159.log  fichier159.log  fichier.log

• +(expression)

L'expression sera présente entre 1 et x fois.

Afficher tous les fichiers dont le nom contient 1 ou x fois "159"

$ ls fichier+(159).log
fichier159159159.log  fichier159159.log  fichier159.log

• @(expression)

L'expression sera présente exactement 1 fois.

Afficher tous les fichiers dont le nom contient 1 fois "159"

$ ls fichier@(159).log
fichier159.log

• !(expression)

L'expression ne sera pas présente.

Afficher tous les fichiers dont le nom ne contient pas 1 fois "159"

$ ls fichier!(159).log
fichier159159159.log  fichier159160.log  fichier161.log
fichier159159.log     fichier160.log     fichier.log

Afficher tous les fichiers dont le nom ne contient pas "fichier"

$ ls !(fichier*)
1coucou  Coucou    coucou.s  coucou.uvw  F2chier  Hello.txt
cOucou   coucou.r  coucou.t  f1chier     Fichier

Une barre verticale dans une expression correspond à "ou bien"

Afficher tous les fichiers dont le nom contient 1 fois "159" ou "160"

$ ls fichier@(159|160).log
fichier159.log  fichier160.log

Afficher tous les fichiers dont le nom contient 1 ou x fois "159" ou "161"

$ ls fichier+(159|161).log
fichier159159159.log  fichier159159.log  fichier159.log  fichier161.log

Afficher tous les fichiers dont le nom contient 1 fois ( 1 ou x fois "159" ou "161")

$ ls fichier@(+(159)|+(161)).log
fichier159159159.log  fichier159159.log  fichier159.log  fichier161.log

Les commandes Linux ont par défaut 3 descripteurs de fichier différent.

• Entrée standard :

L'entrée standard d'une commande correspond au descripteur de fichier 0.
Les commandes qui attendent des informations de la part de l'utilisateur déclenche une requête de lecture sur le descripteur 0.
Par défaut, ce descripteur est associé au terminal et donc par une saisie au clavier.

• Sortie standard :

La sortie standard d'une commande correspond au descripteur de fichier 1.
Le résultat d'une commande est, par défaut, affichée à l'écran via ce descripteur mais il peut être redirigé dans un fichier.

• Sortie d'erreur standard :

La sortie d'erreur standard d'une commande correspond au descripteur de fichier 2.
Quand une commande rencontre une erreur, celle-ci est retournée à l'écran via le descripteur 2 mais elle peut également être retournée dans un fichier.

Cette redirection permet d'écrire dans un fichier le résultat d'une commande au lieu de l'afficher à l'écran.

• Sortie standard (descripteur de fichier 1)

Simple redirection

$ commande > fichier
ou
$ commande 1> fichier

Si le fichier n'existe pas, il est automatiquement créé. S'il existe déjà, il est tout simplement écrasé.

Récupérer le résultat de la commande ls dans un fichier "liste"

$ ls > liste
$ cat liste
1coucou
cOucou
Coucou

Double redirection

Elle permet de concaténer le résultat d'une commande au contenu d'un fichier déjà existant.

$ commande >> fichier
ou
$ commande 1>> fichier

Si le fichier n'existe pas, il est automatiquement créé. S'il existe déjà, le résultat de la commande est ajouté au fichier.

$ pwd >> liste
$ cat liste
1coucou
cOucou
Coucou
/home/toto

• Sortie d'erreur standard (descripteur de fichier 2)

Simple redirection

$ commande 2> fichier

$ ls /root 2> erreur
$ cat erreur
ls: impoossible d'ouvrir le répertoire /root: Permission non accordée

Double redirection

$ commande 2>> fichier

$ mkdir /root/tmp 2>> erreur
$ cat erreur
ls: impoossible d'ouvrir le répertoire /root: Permission non accordée
mkdir: impossible de créer le répertoire «/root/tmp»: Permission non accordée

• Sortie standard et sortie d'erreur standard

Il est possible de rediriger plusieurs sorties sur une même ligne de commande.

$ commande 1> fichier1 2> fichier2
ou
$ commande 2> fichier2 1> fichier1

$ find /etc -name smb.conf 1> resultat 2> erreur
$ cat resultat
/etc/samba/smb.conf
$ cat erreur
find: "/etc/lvm/cache": Permission non accordée
find: "/etc/lvm/backup": Permission non accordée
find: "/etc/lvm/archive": Permission non accordée

Si l'on ne souhaite pas afficher et/ou enregistrer les erreurs retournées, il est possible de rediriger le descripteur 2 vers un fichier spécial existant sur tous les systèmes Linux "/dev/null"

$ find /etc -name smb.conf 1> resultat 2> /dev/null
$ cat resultat
/etc/samba/smb.conf
$ cat /dev/null
$
 

La redirection de l'entrée standard concerne toutes les commandes attendant une saisie de la part de l'utilisateur sur le descripteur 0 (saisie écran).

$ mail toto
>Coucou
>Comment vas tu ?
>^d (équivalent de CTRL+d)
$

La commande mail lit sur l'entrée standard toutes les données saisies à l'écran. La saisie se termine par la fonction CTRL+d.
Ensuite, la commande mail envoie ces données dans un message à l'utilisateur indiqué (toto).

Il est tout à fait possible d'écrire le contenu du message dans un fichier et de "l'injecter" à la commande mail sur son descripteur 0.

$ commande 0< fichier
ou
$ commande < fichier

$ echo "Coucou, comment vas tu ?" > message
$ cat message
Coucou, comment vas tu ?
$ mail toto < message

Rediriger les descripteurs 1 et 2 vers le même fichier :

$ commande 1> fichier1 2>&1
ou
$ commande 2> fichier2 1>&2

Le principe consiste à écrire dans un fichier le résulat du descripteur 1 dans le fichier "fichier1" (1> fichier1) puis le résultat du descripteur 2 vers le descripteur 1 (2>&1) et par conséquent dans le fichier "fichier1".

$ find /etc -name smb.conf 1> resultat 2>&1
$ cat resultat
find: "/etc/lvm/cache": Permission non accordée
find: "/etc/lvm/backup": Permission non accordée
find: "/etc/lvm/archive": Permission non accordée
/etc/samba/smb.conf

Attention :

$ commande 2>&1 1> fichier1

Cette syntaxe n'agit pas de la même manière que les précédentes.

En effet, nous indiquons dans un premier temps de rediriger le descripteur 2 (sortie d'erreur standard) vers le descripteur 1, c'est à dire vers la sortie standard qui est, par défaut, l'affichage à l'écran, puis dans un second temps nous redirigeons le descripteur 1 (sortie standard) vers le fichier "fichier1".
En conclusion, tous les messages d'erreurs seront affichés à l'écran et le résulat de la commande dans le fichier "fichier1".

Cela revient à saisir :

$ commande 1> fichier1

La double redirection en lecture :

Elle est principalement utilisée dans les scripts shell.
Elle permet de connecter l'entrée standard d'une commande sur une portion du script

Par exemple, avec la commande mail, cela permet de terminer la saisie du texte avec un caractère ou une chaine de caractère.

$ mail toto<<end
> bonjour
> ceci est un test
> end
$

Pour mettre fin à la commande mail, il suffit simplement de saisir l'expression inscrite juste après les doubles chevrons "<<". Dans l'exemple, la commande se termine après avoir saisi "end".
Identique à la fonction ^d (CTRL+d) en console.

Utilisation dans un script :

$ cat envoiMail.sh
#!/bin/sh
mail toto<<end
Bonjour,
Ceci est un test
Voici la liste des fichiers presents dans ton repertoire :
`ls -lhtr`
end
exit 0

Exécution du script

$ sh ./envoiMail.sh

Fermeture d'un descripteur :

Il est tout à fait possible de fermé un descripteur d'entrée ou de sortie en utilisant les symboles "<&-" ou ">&-" ou "2>&-".

Descripteur d'entrée standard "0" :

$ commande <&-

Descripteur de sortie standard "1" :

$ commande >&-

Descripteur de sortie d'erreur standard "2" :

$ commande 2>&-

Il existe 3 méthodes pour exécuter un script.

La première méthode consiste à appeler la commande bash, sh, ksh etc.. (l'interpréteur de commande désiré) suivi du nom du script.

$ bash monPremierScript.sh

Dans ce cas, le droit de lecture sur le fichier est suffisant.

$ ls -l monPremierScript.sh
-rw-r--r-- 1 toto toto 68 2011-10-20 08:52 monPremierScript.sh
$

La seconde méthode consiste à utiliser l'entrée standard de la commande bash, sh, ksh etc.. afin de lui faire lire le contenu du script.

$ bash < monPremierScript.sh

Dans ce cas, le droit de lecture sur le fichier est également suffisant.
Cette méthode est très peu utilisée.

La troisième méthode consiste à rendre le script exécutable.

$ chmod u+x monPremierScript.sh
$ ls -l monPremierScript.sh
-rwxr--r-- 1 toto toto 68 2011-10-20 08:52 monPremierScript.sh
$ ./monPremierScript.sh

Choisir un interpréteur de commande :

Pour indiquer au script quel interpréteur de commande utiliser, il faut indiquer sur la première ligne du script les caractères #! suivi du chemin absolu de l'interpréteur.

Par exemple, pour utiliser l'interpéteur de commande BASH, on recherche son chemin absolu :

$ whereis bash
bash: /bin/bash /etc/bash.bashrc /usr/share/man/man1/bash.1.gz
$

La résultat de la commande nous indique le répertoire /bin/bash
Inscrire sur la première ligne du script #! /bin/bash

$ nl monPremierScript.sh
     1  #! /bin/bash
     2  pwd
     3  echo "Liste des fichiers commençant par la lettre C"
     4  ls -lh c*
$

De cette manière, le script sera toujours exécuté avec l'interpréteur de commande BASH.

L'exécution d'un script par le shell courant permet de modifier l'environnement du shell courant.

Les droits d'exécution sur le script ne sont pas nécessaires.
L'utilisation de la commande interne "." est nécessaire pour l'exécution.

Par exemple, pour modifier l'éditeur par défaut, il est nécessaire de modifier la variable environnement EDITOR.

$ env | grep EDITOR
EDITOR=/usr/bin/vi
$ echo $EDITOR
/usr/bin/vi
$ nano .profile
export EDITOR='/usr/bin/nano'
^o (enregistrer)
^x (quitter)
$ . .profile
$ echo $EDITOR
/usr/bin/nano
$ env | grep EDITOR
EDITOR=/usr/bin/nano
$

Attention, l'appel de la commande interne "." est obligatoirement suivi d'un espace et d'un script shell.

Il est possible d'écrire dans un script des commentaires afin de faciliter la compréhension du script.

Les commentaires sont désignés à l'aide du caractère #.
Ne pas confondre avec #! inscrit sur la première ligne du script qui sert à renseigner l'interpréteur de commande.

$ nl monPremierScript.sh
     1    #! /bin/bash
       
     2    # Ceci est un commentaire
     3    # La commande PWD indique le répertoire courant
     4    pwd
     5    # La commande ECHO permet d'afficher du texte et des informations
     6    echo "Liste des fichiers commençant par la lettre C"
     7    # La commande LS permet de lister tous les fichiers commençant par la lettre "c"
     8    ls -lh c*
$

Les scripts shell sont capables de récupérer des arguments placés juste après l'appel du script.

• $# indique le nombre d'arguments passés au script
• $0 indique le nom du script
• $1, $2, $3 ... $9 contient la valeur de l'argument 1, 2, 3 ... 9

En KSH et en BASH, il est possible d'aller au delà de 9 arguments en utilisant les variables spéciales ${10}, ${11} etc...
Les accolades sont obligatoires à partir du moment où le nom de la variable contient plus d'un chiffre.

• $* et $@ contient la liste de tous les arguments

Exemple :

$ nano monSecondScript.sh
#! /bin/bash
echo "Il y a $# arguments passés au script"
echo "Le script se nomme $0"
echo "La valeur du premier argument : $1"
echo "La valeur du second argument : $2"
echo "La valeur du troisième argument : $3"
echo "Les valeurs de tous les arguments : $*"
^o (enregistrer)
^x (quitter)
$ chmod u+x monSecondScript.sh
$ ./monSecondScript.sh arg1 arg2 arg3 arg4 arg5
Il y a 5 arguments passés au script
Le script se nomme ./monSecondScript.sh
La valeur du premier argument : arg1
La valeur du second argument : arg2
La valeur du troisième argument : arg3
Les valeurs de tous les arguments : arg1 arg2 arg3 arg4 arg5
$

Exemple avec 3 arguments :

$ ./monSecondScript.sh 25 + 15
Il y a 3 arguments passés au script
Le script se nomme ./monSecondScript.sh
La valeur du premier argument : 25
La valeur du second argument : +
La valeur du troisième argument : 15
Les valeurs de tous les arguments : 25 + 15
$

Tous les arguments doivent être séparés les uns des autres par un espace ou une tabulation

La commande shift permet de décaler la liste des arguments d'une ou plusieurs positions vers la gauche.

Cette commande est utilisée dans le cas où le premier argument n'a pas à subir le même traitement que les suivants.
Dans ce cas, le premier argument doit être sauvegardé dans une variable et l'exécution de la commande shift entraine le remplacement du premier argument par le second et ainsi de suite.

$ nl monTroisiemeScript.sh
     1  #! /bin/bash
     2  # Ce script doit recevoir en premier argument le nom d'un dossier puis des noms de fichiers pour les suivants
     3  # Affichage des variables avant l'utilisation de la commande shift
     4  echo -e "Affichage avant exécution de la commande shift\n"
     5  echo "1er argument \$1 : $1"
     6  echo "1er argument \$2 : $2"
     7  echo "1er argument \$3 : $3"
     8  echo "1er argument \$4 : $4"
     9  echo "Tous les arguments \$* : $*"
    10  echo -e "Le nombre d'argument \$# : $#\n"
    11  # On sauvegarde le premier argument dans la variable rep
    12  rep=$1
    13  # On décale tous les arguments avec la commande shift
    14  shift
    15  # Affichage des variables après l'exécution de la commande shift
    16  echo -e "Affichage après exécution de la commande shift\n"
    17  echo "1er argument \$1 : $1"
    18  echo "1er argument \$2 : $2"
    19  echo "1er argument \$3 : $3"
    20  echo "1er argument \$4 : $4"
    21  echo "Tous les arguments \$* : $*"
    22  echo -e "Le nombre d'argument \$# : $#\n"
    23  # Création du répertoire
    24  mkdir $rep
    25  # On se positionne dans le nouveau répertoire
    26  cd $rep
    27  # Création des fichiers dans le nouveau répertoire
    28  for fichier in $*
    29  do
    30          touch $fichier
    31  done
$ chmod u+x monTroisiemeScript

Exécution du script :

$ ./monTroisiemeScript.sh test fic1 fic2 fic3 fic4 fic5 fic6
Affichage avant exécution de la commande shift
1er argument $1 : test
1er argument $2 : fic1
1er argument $3 : fic2
1er argument $4 : fic3
Tous les arguments $* : test fic1 fic2 fic3 fic4 fic5 fic6
Le nombre d'argument $# : 7
Affichage après exécution de la commande shift
1er argument $1 : fic1
1er argument $2 : fic2
1er argument $3 : fic3
1er argument $4 : fic4
Tous les arguments $* : fic1 fic2 fic3 fic4 fic5 fic6
Le nombre d'argument $# : 6
$ ls -l ./test/
total 0
-rw-r--r-- 1 toto toto 0 2011-10-25 09:01 fic1
-rw-r--r-- 1 toto toto 0 2011-10-25 09:01 fic2
-rw-r--r-- 1 toto toto 0 2011-10-25 09:01 fic3
-rw-r--r-- 1 toto toto 0 2011-10-25 09:01 fic4
-rw-r--r-- 1 toto toto 0 2011-10-25 09:01 fic5
-rw-r--r-- 1 toto toto 0 2011-10-25 09:01 fic6
$

Toutes les commandes Linux retournent un code d'erreur compris entre 0 et 255.
La valeur 0 représente la valeur vrai (succès de la commande).
Les valeurs supérieur à 0 représente la valeur faux (échec de la commande).
Le code erreur de la dernière commande utilisée est contenu dans la variable $?

$ ls f*
f1chier               fichier159159.log  fichier159.log  fichier161.log  fichier1.abc  fichier1.c   fset
fichier159159159.log  fichier159160.log  fichier160.log  fichier1.a      fichier1.b    fichier.log
$ echo $?
0
$ ls 2*
ls: impossible d'accéder à 2*: Aucun fichier ou dossier de ce type
$ echo $?
2

Dans un script shell, le test du code de retour d'une commande permet d'effectuer différentes actions.

Un script shell étant lui-même une commande, il est possible de lui faire retourner un code d'erreur avec la commande exit.

Par exemple, il est possible d'indiquer dans un script exit 1 afin d'indiquer une erreur rencontrée et/ou exit 0 afin d'indiquer que tout c'est bien déroulé.

Dans l'exemple suivant, le script test s'il reçoit bien au minimum 2 arguments et renvoi le code erreur 1 si c'est faux.

$ nl ./script.sh
1  #! /bin/bash
2  # Le script doit recevoir au minimum 2 arguments
3  if [ $# -lt 2 ]
4  then
5          # Si le nombre d'arguments est inférieur à 2
6          # on retourne le code erreur 1
7          echo "Nombre arguments incorrect"
8          exit 1
9  else
10          # Si le nombre d'arguments est supérieur ou égal à 2
11          # on retourne le code erreur 0
12          echo "Nombre arguments correct"
13          exit 0
14  fi
$

Exécution du script :

$ ./script.sh
Nombre arguments incorrect
$ echo $?
1
$ ./script.sh test
Nombre arguments incorrect
$ echo $?
1
$ ./script.sh test test2
Nombre arguments correct
$ echo $?
0
$

La variable $$ représente le PID du shell qui interprète le script.
La valeur de cette variable est la même pendant toute la durée d'exécution du script et différente à chaque utilisation du script.

Exemple :

Dans ce script, la variable $$ est utilisée pour générer le nom d'un dossier différent à chaque exécution du script.

$ nl monQuatriemeScript.sh
     1  #! /bin/bash
     2  dossierTemp=dossier_$$
     3  echo "Création du dossier \"$dossierTemp\""
     4  mkdir $dossierTemp
     5  cd $dossierTemp
     6  for (( i=0 ; i<10 ; i++)) do
     7          touch fichier_$i
     8  done
     9  exit 0
$

$ ./monQuatriemeScript.sh
Création du dossier "dossier_26563"
$ ./monQuatriemeScript.sh
Création du dossier "dossier_26581"
$

La variable $! représente le PID d'une commande exécutée en arrière plan.

exemple :

$ nl monCinquiemeScript.sh
     1  #! /bin/bash
     2  echo "Le script est exécuté sous le PID $$"
     3  find /etc -name $1 1> resultat 2> /dev/null &
     4  echo "La commande FIND est en cours d'exécution sous le PID $!"
     5  ps
     6  exit 0
$

$ ./monCinquiemeScript.sh hosts.allow
Le script est exécuté sous le PID 29999
La commande FIND est en cours d'exécution sous le PID 30000
  PID TTY          TIME CMD
19703 pts/0    00:00:00 bash
29999 pts/0    00:00:00 monCinquiemeScr
30000 pts/0    00:00:00 find
30001 pts/0    00:00:00 ps
$

La commande [[ ]] est une version améliorée de la commande test.
Tous les opérateurs utilisés avec la commandes test restent valables à l'exception des opérateurs logiques -a et -o respectivement remplacés par && et ||.

Syntaxe :

commande1 && commande2

La seconde commande (commande2) est exécutée uniquement si le code de retour de la commande (commande1) est égale à 0 (vrai).

Le code de retour global est égal à 0 (vrai) si le code de retour de chaque commande est égal à 0 (vrai).

Exemple :

Le répertoire temp/temp2 n'existe pas donc la commande cd n'est pas exécutée

$ ls -d temp/temp2
ls: impossible d'accéder à temp/temp2: Aucun fichier ou dossier de ce type
$ pwd
/home/toto
$ [[ -d temp/temp2 ]] && cd temp/temp2
$ echo $?                     # code de retour de la commande [[ ]]
1
$ pwd
/home/toto
$

Le répertoire temp/temp2 existe donc la commande cd est exécutée

$ mkdir temp/temp2
$ pwd
/home/toto
$ [[ -d temp/temp2 ]] && cd temp/temp2
$ echo $?                     # code de retour de la commande globale
0
$ pwd
/home/toto/temp/temp2
$

Le répertoire temp/temp2 existe mais le répertoire temp/temp3 n'existe pas donc la commande cd retourne un code erreur égal à 1

$ [[ -d temp/temp2 ]] && cd temp/temp3
-bash: cd: temp/temp3: Aucun fichier ou dossier de ce type
$ echo $?                     # code de retour de la commande cd
1
$

Ces actions peuvent également être exécutées avec la structure de commande if

$ pwd
/home/toto
$ ls -d temp/temp2
temp/temp2
$ if [[ -d temp/temp2 ]]
> then
> cd temp/temp2
> fi
$ echo $?
0
$ pwd
/home/toto/temp/temp2
$

Syntaxe :

commande1 || commande2

La seconde commande (commande2) est exécutée uniquement si le code de retour de la commande (commande1) est égale à 1 (faux).

Le code de retour global est égal à 0 (vrai) si au moins une des commandes retourne un code égal à 0 (vrai).

Exemple :

Le répertoire temp/temp2 n'existe pas donc la commande echo est exécutée

$ ls -d temp/temp2
ls: impossible d'accéder à temp/temp2: Aucun fichier ou dossier de ce type
$ [[ -d temp/temp2 ]] || echo "Le répertoire n'existe pas"
Le répertoire n'existe pas
$ echo $?
0
$

Le répertoire temp/temp2 existe donc la commande echo n'est pas exécutée

$ mkdir temp/temp2
$ ls -d temp/temp2
temp/temp2
$ [[ -d temp/temp2 ]] || echo "Le répertoire n'existe pas"
$ echo $?
0
$

Ces actions peuvent également être exécutées avec la structure de commande if

$ ls -d temp/temp2
ls: impossible d'accéder à temp/temp2: Aucun fichier ou dossier de ce type
$ if [[ ! -d temp/temp2 ]]
> then
> echo "Le répertoire n'existe pas"
> fi
Le répertoire n'existe pas
$

Ne pas confondre les opérateurs du shell && et || qui effectuent une opération logique entre deux commandes et les opérateurs && et || de la commande [[ ]] qui sont internes à celle-ci

Syntaxe :

expr $nbr1 opérateur $nbr2
expr $chaine : expression régulière

Opérateurs :

Attention, certains opérateurs ayant une signification particulière pour le shell, ceux ci doivent être protégés par un antislash.

Les arguments de la commande expr doivent toujours être séparés par au moins un espace ou une tabulation.

Exemple :

$ nb=3
$ expr $nb + 5
8
$ expr $nb \* 6
18
$ expr $nb / 2
1
$ nb=10
$ expr $nb % 3
1
$ expr $nb - -5
15
$

Récupérer le résultat dans une variable :

$ nb2=`expr $nb - 2`
$ echo $nb2
8
$

Priorité d'exécution des opérateurs :

$ nb=5
$ nb2=`expr $nb \* 3 + 4`
$ echo $nb2
19
$ nb2=`expr $nb \* \( 3 + 4 \)`
$ echo $nb2
35
$

Résultat d'une comparaison VS valeur du code de retour :

$ nb=2
$ expr $nb \>= 1
1                            # Résultat de la comparaison
$ echo $?
0                            # Résultat du code de retour
$ expr $nb \>= 3
0                            # Résultat de la comparaison
$ echo $?
1                            # Résultat du code de retour
$

Différents types de comparaison :

$ nl comparaison.sh
     1  #!/bin/bash
 
     2  # Test sur le nombre d'arguments
     3  if [[ $# -ne 2 ]]
     4  then
     5          echo "Mauvais nombre d'arguments"
     6          echo "Utilisation : $0 expr1 expr2"
     7          exit 1
     8  fi
 
     9  # On compare expr1 et expr2 avec la commande EXPR et redirection du résultat dans /dev/null
    10  if expr $1 \> $2 > /dev/null
    11  then
    12          echo "Comparaison EXPR : $1 est supérieur à $2"
    13  else
    14          echo "Comparaison EXPR : $1 est inférieur à $2"
    15  fi
 
    16  # On compare expr1 et expr2 avec la commande [[ ]] (lexicographiquement)
    17  if [[ $1 > $2 ]]
    18  then
    19          echo "Comparaison lexico.. [[ ]] : $1 est supérieur à $2"
    20  else
    21          echo "Comparaison lexico.. [[ ]] : $1 est inférieur à $2"
    22  fi
 
    23  # On compare expr1 et expr2 avec la commande [[ ]]
    24  if [[ $1 -gt $2 ]]
    25  then
    26          echo "Comparaison [[ ]] : $1 est supérieur à $2"
    27  else
    28          echo "Comparaison [[ ]] : $1 est inférieur à $2"
    29  fi
 
    30  exit 0
$ ./comparaison.sh 9 5
Comparaison EXPR : 9 est supérieur à 5
Comparaison lexico.. [[ ]] : 9 est supérieur à 5
Comparaison [[ ]] : 9 est supérieur à 5
$ ./comparaison.sh 50 9
Comparaison EXPR : 50 est supérieur à 9
Comparaison lexico.. [[ ]] : 50 est inférieur à 9
Comparaison [[ ]] : 50 est supérieur à 9
$ ./comparaison.sh a b
Comparaison EXPR : a est inférieur à b
Comparaison lexico.. [[ ]] : a est inférieur à b
Comparaison [[ ]] : a est inférieur à b
$ ./comparaison.sh t r
Comparaison EXPR : t est supérieur à r
Comparaison lexico.. [[ ]] : t est supérieur à r
Comparaison [[ ]] : t est inférieur à r
$

Le résultat de la commande EXPR est toujours exact que ce soit des chiffres ou des caractères.

Syntaxe :

((expression_arithmétique))

Utilisation :

La commande (( )) dispose de nombreux avantages par rapport à la commande expr

• Opérateurs supplémentaires
• Les arguments n'ont pas besoin d'être séparés par des espaces
• Les variables n'ont pas besoin d'être préfixées par le symbole $
• Les caractères spéciaux du shell n'ont pas besoin d'être protégés par des antislashes
• Les affectations se font dans la commande
• Son exécution est plus rapide

Une grande partie des opérateurs proviennent du langage C

Exemples :

Ajouter 10 à nbr1 (2 méthodes différentes)

$ nbr1=10
$ ((nbr1=nbr1+10))
$ echo $nbr1
20
$ nbr1=10
$ ((nbr1+=10))
$ echo $nbr1
20
$

Test si nbr1 est supérieur à nbr2 et inversement

$ nbr1=5
$ nbr2=6
$ ((nbr1>nbr2))
$ echo $?
1                           # Code retour 1 (faux) car nbr1 n'est pas supérieur à nbr2
$ ((nbr1<nbr2))
$ echo $?
0                           # Code retour 0 (vrai) car nbr1 est inférieur à nbr2
$

Le script suivant compare les 2 arguments passés en paramètre

$ nl comparaison2.sh
     1  #!/bin/bash
 
     2  # Test sur le nombre d'arguments
     3  if (($#!=2))
     4  then
     5          echo "Mauvais nombre d'arguments"
     6          echo "Utilisation : $0 nbr1 nbr2"
     7          exit 1
     8  fi
 
     9  # On compare nbr1 et nbr2 avec la commande (( ))
    10  if (($1<$2))
    11  then
    12          echo "$1 est inférieur à $2"
    13  else
    14          if (($1>$2))
    15          then
    16                  echo "$1 est supérieur à $2"
    17          else
    18                  if (($1==$2))
    19                  then
    20                          echo "$1 est égal à $2"
    21                  else
    22                          echo "Comparaison impossible"
    23                  fi
    24          fi
    25  fi
 
    26  exit 0
$ ./comparaison2.sh 2 8
2 est inférieur à 8
$ ./comparaison2.sh 8 2
8 est supérieur à 2
$ ./comparaison2.sh 8 8
8 est égal à 8
$

Regroupements et tests logiques

$ nbr1=2
$ nbr2=5
$ if (( (nbr1>0) && (nbr2>nbr1) ))
> then
> echo "nbr1 est supérieur à 0 et inférieur à nbr2"
> else
> echo "nbr1 est égal à 0 ou supérieur à nbr2"
> fi
nbr1 est supérieur à 0 et inférieur à nbr2
$

La commande let est équivalente à ((expression))

Syntaxe :

let "expression"

Exemple :

Multiplier nbr1 par 3

$ nbr1=5
$ let "nbr1=nbr1*3"
$ echo $nbr1
15
$

Calculer le modulo de nbr1 par 2 et l'affecter à la variable nbr2

$ nbr1=5
$ let "nbr2=nbr1%2"
$ echo $nbr1
5
$ echo $nbr2
1
$

L'option -x permet de débugger un script shell en affichant l'exécution des commandes après traitement des caractères spéciaux du shell.

Les différentes syntaxes permettant d'activer l'option -x :

Activer l'option

1. set -x
2. set -o xtrace
3. bash -x nom_du_script

Désactiver l'option

1. set +x
2. set +o xtrace

Exemple :

Dans l'exemple suivant, la variable fichier n'a pas été préfixée par le symbole $.

$ nl liste.sh
     1  #!/bin/bash
     2  for fichier in `ls`
     3  do
     4          if [[ -f fichier ]]
     5          then
     6                  echo "$fichier"
     7          fi
     8  done
$

L'exécution du script ne retourne aucun résultat malgré la présence de fichiers dans le dossier d'exécution du script.

$ ./liste.sh
$

L'exécution du script avec activation de l'option -x démontre effectivement que la variable fichier n'est pas remplacée par sa valeur.

$ bash -x liste.sh
++ ls
+ for fichier in '`ls`'
+ [[ -f fichier ]]
+ for fichier in '`ls`'
+ [[ -f fichier ]]
+ for fichier in '`ls`'
+ [[ -f fichier ]]
...
$

L'activation de l'option de débuggage peut également être lancée directement dans le script.

$ nl liste.sh
     1  #!/bin/bash
     2  set -x
     3  for fichier in `ls`
     4  do
     5          if [[ -f fichier ]]
     6          then
     7                  echo "$fichier"
     8          fi
     9  done
$

Après correction de l'erreur et exécution du script en mode débuggage.

$ nl liste.sh
     1  #!/bin/bash
     2  set -x
     3  for fichier in `ls`
     4  do
     5          if [[ -f "$fichier" ]]
     6          then
     7                  echo "$fichier"
     8          fi
     9  done
$ ./liste.sh
++ ls
+ for fichier in '`ls`'
+ [[ -f 1coucou ]]
+ echo 1coucou
1coucou
+ for fichier in '`ls`'
+ [[ -f 24902 ]]
+ for fichier in '`ls`'
+ [[ -f 25013 ]]
+ for fichier in '`ls`'
+ [[ -f 25031 ]]
+ for fichier in '`ls`'
+ [[ -f 25043 ]]
+ for fichier in '`ls`'
+ [[ -f comparaison2.sh ]]
+ echo comparaison2.sh
comparaison2.sh
...
$

Exemple :

Dans l'exemple suivant, un guillemet a été volontairement omis.

$ nl liste.sh
     1  #!/bin/bash
     2  set -n
     3  for fichier in `ls`
     4  do
     5          if [[ -f "$fichier ]]
     6          then
     7                  echo "$fichier"
     8          fi
     9  done
$ ./liste.sh
./liste.sh: line 7: Caractère de fin de fichier (EOF) prématuré lors de la recherche du « " » correspondant
./liste.sh: line 10: argument inattendu pour l'opérateur conditionnel à un argument
./liste.sh: line 10: Erreur de syntaxe : fin de fichier prématurée
$

$ nl liste.sh
     1  #!/bin/bash
     2  set -v
     3  for fichier in `ls`
     4  do
     5          if [[ -f "$fichier ]]
     6          then
     7                  echo "$fichier"
     8          fi
     9  done
$ ./liste.sh
for fichier in `ls`
do
        if [[ -f "$fichier ]]
        then
                echo "$fichier"
        fi
done
./liste.sh: line 7: Caractère de fin de fichier (EOF) prématuré lors de la recherche du « " » correspondant
./liste.sh: line 10: argument inattendu pour l'opérateur conditionnel à un argument
./liste.sh: line 10: Erreur de syntaxe : fin de fichier prématurée
$

La structure de controle if permet de réaliser des tests.
La commande située à droite du if est exécutée.
Si le code retour de la commande ($?) est égal à 0 (vrai), les commandes situées dans le bloc then sont exécutées.
Si le code de retour est supérieur à 0 (faux), ce sont les commandes situées dans le bloc else (optionnel) qui sont exécutées.
Dans le cas où le bloc else n'est pas spécifié, le shell continue à la première commande située sous le fi.

Les différentes syntaxes :

if, then, else, fi

if commande1
then
     commande2
     commande3
     ...
else
     commande4
     ...
fi

if, then, fi

if commande1
then
     commande2
     commande3
     ...
fi

if, then, elif, else, fi

if commande1
then
     commande2
     commande3
     ...
elif commande4
then
     commande5
     ...
else
     commande6
     ...
fi

Le mot clé fi permet de fermer la structure de controle if.
Le mot clé elif n'a pas de fermeture.

Autres syntaxes :

Le mot clé then peut être placé sur la même ligne que le if à condition de les séparer à l'aide d'un point virgule.

if commande1 ; then
     commande2
     commande3
     ...
fi

Plusieurs structures de controles if peuvent être imbriquées les unes dans les autres.

if commande1
then
     commande2
     ...
else
     if commande3
     then
          commande4
          ...
     else
          commande5
          ...
     fi
fi

Exemple :

Le script suivant vérifie si un argument est passé en paramètre et dans le cas contraire demande une saisie clavier à l'utilisateur.
Le script vérifie ensuite que le user saisi existe bien dans le fichier /etc/passwd.

$ nl user_passwd.sh
     1  #!/bin/bash
     2  if [[ $# -ne 1 ]]
     3  then
     4          echo -e "Saisir le nom d'un user : \c"
     5          read user
     6  else
     7          user=$1
     8  fi
     9  if grep -q "^$user:" /etc/passwd
    10  then
    11          echo "Le user $user existe"
    12          echo "Son UID est le : $(grep "^$user:" /etc/passwd | cut -d":" -f3)"
    13          echo "Son GID est le : $(grep "^$user:" /etc/passwd | cut -d":" -f4)"
    14  else
    15          echo "Le user $user n'existe pas !!!"
    16  fi
    17  exit 0
$ ./user_passwd.sh root
Le user root existe
Son UID est le : 0
Son GID est le : 0
$ ./user_passwd.sh
Saisir le nom d'un user : www-data
Le user www-data existe
Son UID est le : 33
Son GID est le : 33
$

La structure de controle case permet elle aussi d'effectuer des tests.
Elle permet d'orienter la suite du programme en fonction d'un choix de différentes valeurs.
Quand il y a un nombre important de choix, la commande case est plus appropriée que la commande if.

Syntaxe :

case $variable in
modele1) commande1
     ...
     ;;
modele2) commande2
     ...
     ;;
modele3 | modele4 | modele5 ) commande3
     ...
     ;;
esac

Le shell compare la valeur de la variable aux différents modèle renseignés.
Lorsque la valeur correspond au modèle, les commandes faisant partie du bloc sont exécutées.
Les caractères ;; permettent de fermer le bloc et de mettre fin au case.
Le shell continue à la première commande située sous esac.

Il ne faut surtout pas oublier les caractères ;; car cela engendrera une erreur.

Rappel des caractères spéciaux :

Exemple :

Le script suivant permet de créer, modifier, visualiser et supprimer un fichier dans le répertoire d'exécution du script.
Il prend en argument un nom de fichier et affiche un menu.
Utilisation de case avec imbrication de if.

$ nl file.sh
     1  #!/bin/bash
     2  #set -x
     3  # Si le nombre d'arguments est different de 1 on quitte avec code 1
     4  if [[ $# -ne 1 ]]
     5  then
     6          echo "Nombre d'arguments incorrect"
     7          echo "Usage : $0 file"
     8          exit 1
     9  fi
    10  # On affiche le menu
    11  echo -e "1(Creer) "
    12  echo -e "2(Editer) "
    13  echo -e "3(Afficher) "
    14  echo -e "4(Supprimer)"
    15  echo -e "Votre choix : \c"
    16  # On recupere la valeur saisi
    17  read choix
    18  # Si la valeur saisi est differente de 1, 2, 3 ou 4 on quitte avec code 1
    19  if [[ "$choix" != [1-4] ]]
    20  then
    21          echo "Choix incorrect"
    22          exit 1
    23  fi
    24  # En fonction de la valeur saisi on execute les differentes actions
    25  case "$choix" in
    26  # Si choix = 1 --> creation
    27  1)      if [[ -e "$1" ]]
    28          then
    29                  if [[ -f "$1" ]]
    30                  then
    31                          echo "Fichier $1 deja existant"
    32                  elif [[ -d "$1" ]]
    33                  then
    34                          echo "$1 est un repertoire"
    35                  fi
    36                  exit 1
    37          else
    38                  touch "$1"
    39                  nano "$1"
    40          fi
    41  ;;
    42  # Si choix = 2 --> edition
    43  2)      if [[ -f "$1" ]]
    44          then
    45                  nano "$1"
    46          else
    47                  if [[ -d "$1" ]]
    48                  then
    49                          echo "$1 est un repertoire et ne peut etre edite"
    50                  else
    51                          echo "Fichier $1 inexistant"
    52                  fi
    53                  exit 1
    54          fi
    55  ;;
    56  # Si choix = 3 --> affichage
    57  3)      if [[ -f "$1" ]]
    58          then
    59                  more "$1"
    60          else
    61                  if [[ -d "$1" ]]
    62                  then
    63                          echo "$1 est un repertoire et ne peut etre visualise"
    64                  else
    65                          echo "Fichier $1 inexistant"
    66                  fi
    67                  exit 1
    68          fi
    69  ;;
    70  # Si choix = 4 --> suppression
    71  4)      if [[ -f "$1" ]]
    72          then
    73                  rm "$1"
    74          else
    75                  if [[ -d "$1" ]]
    76                  then
    77                          echo "$1 est un repertoire et ne peut etre supprime"
    78                  else
    79                          echo "Fichier $1 inexistant"
    80                  fi
    81                  exit 1
    82          fi
    83  ;;
    84  # Fin du case
    85  esac
    86  # Tout c'est bien deroule on quitte avec le code 0
    87  exit 0
$ ./file.sh test4
1(Creer)
2(Editer)
3(Afficher)
4(Supprimer)
Votre choix : 1
$

Syntaxe :

La boucle for permet de traiter une liste de valeurs indiquée à droite du mot clé in.
A chaque tour de boucle, la variable var est initialisée avec une des valeurs de la liste.
Elles sont traitées dans l'ordre de leur énumération.

Liste de valeurs citée directement

for var in valeur1 valeur2 valeur3 ... valeurn
do
     commande
done

Liste de valeurs contenue dans une variable

for var in $variable
do
     commande
done

Liste de valeurs générée par substitution de commande

for var in `commande`
do
     commande
done

Liste de valeurs générée par substitution de caractères de génération de noms de fichiers

for var in *.ext
do
     commande
done

Liste par défaut : Arguments de la ligne de commande

for var
do
     commande
done

for var in $*
do
     commande
done

Avec incrémentation d'une variable

for (( var=valeurMin; var<=valeurMax; var++ ))
do
     commande
done

Exemple :

Un script compte à rebours

$ nl boucleFor01.sh
     1  #!/bin/bash
     2  for var in 10 9 8 7 6 5 4 3 2 1 0
     3  do
     4          echo "$var"
     5  done
     6  exit 0
$ ./boucleFor01.sh
10
9
8
7
6
5
...
$

Lister les fichiers d'un ou plusieurs dossiers

$ nl boucleFor02.sh
     1  #!/bin/bash
     2  if [[ $# -lt 1 ]]
     3  then
     4          echo "Nombre d'argument incorrect"
     5          echo "Utilisation $0 dossier1 dossier2 dossiern"
     6          exit 1
     7  fi
     8  for dossier in $*
     9  do
    10          if [[ -d $dossier ]]
    11          then
    12                  echo "Liste des fichiers du dossier $dossier"
    13                  for fichier in `ls $dossier`
    14                  do
    15                          echo "$fichier"
    16                  done
    17          fi
    18  done
    19  exit 0
$ ./boucleFor02.sh coucou 24902 25013 25031
Liste des fichiers du dossier coucou
test
Liste des fichiers du dossier 24902
fichier_0
fichier_1
fichier_2
fichier_3
Liste des fichiers du dossier 25013
fichier_0
fichier_1
fichier_2
Liste des fichiers du dossier 25031
fichier_0
fichier_1
fichier_2
fichier_3
$

En utilisant une variable incrémentée :

$ for (( i=0; i <= 10; i++ )); do echo $i; done
0
1
2
3
4
5
6
7
8
9
10
$

Idem avec la syntaxe suivante :

$ for i in {0..10}; do echo $i; done
0
1
2
3
4
5
6
7
8
9
10
$

Syntaxe :

while commande1
do
     commande2
     ...
done

La boucle while permet d'exécuter les commandes présentes entre le do et le done tant que la commande1 placée à droite du while retourne un code vrai.

Exemple :

Le script suivant demande de saisir 53 et continue tant que c'est faux

$ nl boucleWhile01.sh
     1  #!/bin/bash
     2  nbr=0
     3  while ((nbr!=53))
     4  do
     5          echo -e "Saisir 53 : \c"
     6          read nbr
     7
     8  done
     9  exit 0
$ ./boucleWhile01.sh
Saisir 53 : rt
Saisir 53 : 54
Saisir 53 : R4
Saisir 53 : 53
$

Le script suivant affiche le compteur tant qu'il est inférieur à 10

$ nl boucleWhile02.sh
     1  #!/bin/bash
     2  cpt=0
     3  while ((cpt<10))
     4  do
     5          echo "Le compteur vaut : $cpt"
     6          ((cpt+=1))
     7  done
     8  exit 0
$ ./boucleWhile02.sh
Le compteur vaut : 0
Le compteur vaut : 1
Le compteur vaut : 2
Le compteur vaut : 3
Le compteur vaut : 4
Le compteur vaut : 5
Le compteur vaut : 6
Le compteur vaut : 7
Le compteur vaut : 8
Le compteur vaut : 9
$

Le script suivant effectue une somme des nombres saisis

$ nl boucleWhile03.sh
     1  #!/bin/bash
     2  somme=0
     3  echo "Saisir un nombre, ^d pour afficher la somme"
     4  while read nombre
     5  do
     6          if [[ $nombre != +([0-9]) ]]
     7          then
     8                  echo "$nombre n'est pas un nombre"
     9                  continue
    10          fi
    11          ((somme+=nombre))
    12  done
    13  echo "La somme est de : $somme"
    14  exit 0
$ ./boucleWhile03.sh
Saisir un nombre, ^d pour afficher la somme
56
32
89
9.6
9.6 n'est pas un nombre
g8
g8 n'est pas un nombre
54
La somme est de : 231
$

Le mot clé continue permet de remonter aussitôt à la boucle while sans exécuter la commande suivante

Attention aux boucles infinies

Ce script provoqe une boucle infinie car il manque l'incrémentation du compteur

$ nl boucleWhile04.sh
     1  #!/bin/bash
     2  cpt=0
     3  while ((cpt<10))
     4  do
     5          echo "Le compteur vaut : $cpt"
     6  done
     7  exit 0
$

Le shell propose également la commande interne : qui renvoie toujours vrai et permet donc de faire une boucle infinie avec un while.

$ nl boucleWhile05.sh
     1  #!/bin/bash
     2  while :
     3  do
     4          echo "Boucle infinie"
     5  done
     6  exit 0
$

En bash et ksh, la commande true propose exactement la même chose.

$ nl boucleWhile05.sh
     1  #!/bin/bash
     2  while true
     3  do
     4          echo "Boucle infinie"
     5  done
     6  exit 0
$

Syntaxe :

until commande1
do
     commande2
     ...
done

A l'inverse de while, la commande until exécute les commandes situées entre le do et le done tant que la commande située à droite du until retourne un code faux.

Exemple :

Le script suivant boucle tant que le nombre saisi n'est pas égal à 53

$ nl boucleUntil01.sh
     1  #!/bin/bash
     2  nbr=0
     3  until ((nbr==53))
     4  do
     5          echo -e "Saisir 53 : \c"
     6          read nbr
     7  done
     8  exit 0
$ ./boucleUntil01.sh
Saisir 53 : 45
Saisir 53 : rt
Saisir 53 : fd
Saisir 53 : 53
$

Le script suivant permet, en tâche de fond, de surveiller un répertoire donné et d'informer l'utilisateur de l'arrivée d'un fichier attendu dans ce répertoire.
Pour plus de sécurité sur l'intégrité du fichier attendu, un fichier témoin devra être créé à la suite du fichier attendu puisque le principal contrôle se fera sur l'existence de ce fichier.

$ nl boucleUntil02.sh
     1    #!/bin/bash
     2    # Il doit y avoir au minimum 2 paramètres en arguments et un maximum de 3
     3    if [[ $# -lt 2 || $# -gt 3 ]]
     4    then
     5        echo "Utilisation : $0 repertoire fichier [ temoin ]"
     6        exit 1
     7    fi
     8    # Le premier argument doit être un répertoire
     9    if [[ ! -d $1 ]]
    10    then
    11        echo "$1 n'est pas un répertoire"
    12        exit 2
    13    fi
    14    # Nom du fichier témoin par défaut
    15    ficTemoin=${3:-temoin}
    16    # Exécution de la boucle en attendant l'arrivée du fichier témoin avec une pause toutes les 3 secondes
    17    until [[ -e $1/$ficTemoin ]]
    18    do
    19        sleep 3
    20    done
    21    # Vérification que le fichier attendu est bien présent
    22    if [[ ! -e $1/$2 ]]
    23    then
    24        echo "Le fichier témoin existe mais le fichier attendu est absent"
    25        exit 3
    26    fi
    27    # Sauvegarde du fichier attendu dans le HOME de l'utilisateur avec horodatage et suppression du fichier témoin
    28    date=$(date '+%Y%m%d_%H%M')
    29    newFichier=$2.$date
    30    mv $1/$2 $HOME/$newFichier
    31    rm $1/$ficTemoin
    32    # Envoi d'un mail à l'utilisateur
    33    mail $LOGNAME <<FIN
    34    Le fichier $HOME/$newFichier est bien arrivé.
    35    FIN
    36    echo "$0 : Vous avez reçu un message !!! "
    37    exit 0
$ ./boucleUntil02.sh /tmp monFichier &     # Lancement du script en arrière plan grâce à la commande &
[1] 2298
$ touch /tmp/monFichier                                   # Création du fichier attendu
$ touch /tmp/temoin                                           # Création du fichier témoin
$ ./boucleUntil02.sh : Vous avez reçu un message !!!     # Message généré par la ligne 36
 
[1]+  Done                    ./boucleUntil02.sh /tmp monFichier
$

il ne reste plus qu'à consulter sa boite mail pour lire le message envoyé par le script.

Les commandes break et continue peuvent s'utiliser à l'intérieur des boucles for, while, until et select.
La commande break permet de sortir d'une boucle.
La commande continue permet de remonter à la condition d'une boucle.

Syntaxe :

Quitter la boucle de premier niveau
break

Quitter la boucle de niveau n
break n

Remonter à la condition de la boucle de premier niveau
continue

Remonter à la condition de la boucle de niveau n
continue n

Exemple :

$ nl boucleWhile06.sh
     1    #!/bin/bash
     2    somme=0
     3    while true
     4    do
     5        echo "Saisir un nombre, ^d pour afficher la somme"
     6        if read nombre
     7        then
     8            if [[ $nombre != +([0-9]) ]]
     9            then
    10                echo "$nombre n'est pas un nombre"
    11                continue
    12            fi
    13            ((somme+=nombre))
    14        else
    15            break
    16        fi
    17    done
    18    echo "La somme est de : $somme"
    19    exit 0
$ ./boucleWhile06.sh
Saisir un nombre, ^d pour afficher la somme
23
Saisir un nombre, ^d pour afficher la somme
56
Saisir un nombre, ^d pour afficher la somme
54
Saisir un nombre, ^d pour afficher la somme
89
Saisir un nombre, ^d pour afficher la somme
La somme est de : 222
$

Les variables $* et $@ contiennent la liste des arguments d'un script shell.
Lorsqu'elles ne sont pas entourées par des guillemets, elles sont équivalentes.

Exemple :

$ nl scr01.sh
     1  #!/bin/bash
     2  cpt=1
     3  echo "Utilisation de la variable \$*"
     4  for arg in $*
     5  do
     6          echo "Argument $cpt : $arg"
     7          ((cpt+=1))
     8  done
     9  cpt=1
    10  echo "Utilisation de la variable \$@"
    11  for arg in $@
    12  do
    13          echo "Argument $cpt : $arg"
    14          ((cpt+=1))
    15  done
    16  exit 0
$ ./scr01.sh a b "c d e" f
Utilisation de la variable $*
Argument 1 : a
Argument 2 : b
Argument 3 : c
Argument 4 : d
Argument 5 : e
Argument 6 : f
Utilisation de la variable $@
Argument 1 : a
Argument 2 : b
Argument 3 : c
Argument 4 : d
Argument 5 : e
Argument 6 : f
$

Interprétation :

1. $* et $@ contiennent exactement la même liste d'arguments.
2. Les guillemets protégeant les arguments ne sont pas pris en compte
3. Ce sont les espaces qui délimitent les arguments

Les guillemets autour de $* supprime la signification des espaces contenus dans $*.

Exemple :

$ nl scr02.sh
     1  #!/bin/bash
     2  cpt=1
     3  echo "Utilisation de la variable \"\$*\""
     4  for arg in "$*"
     5  do
     6          echo "Argument $cpt : $arg"
     7          ((cpt+=1))
     8  done
     9  exit 0
$ ./scr02.sh a b c "d e f" g
Utilisation de la variable "$*"
Argument 1 : a b c d e f g
$

Interprétation :

1. Les guillemets entourant les arguments ne sont pas pris en compte.
2. Tous les arguments sont considérés comme étant un seul argument.

La variable $@ placée entre guillemets permet de conserver la protection des arguments par les guillemets.

Exemple :

$ nl scr03.sh
     1  #!/bin/bash
     2  cpt=1
     3  echo "Utilisation de la variable \"\$@\""
     4  for arg in "$@"
     5  do
     6          echo "Argument $cpt : $arg"
     7          ((cpt+=1))
     8  done
     9  exit 0
$ ./scr03.sh a b c "d e f" g
Utilisation de la variable "$@"
Argument 1 : a
Argument 2 : b
Argument 3 : c
Argument 4 : d e f
Argument 5 : g
$

Interprétation :

1. Les espaces délimitent la liste des arguments.
2. Les arguments placés entre guillemets sont considérés comme étant un seul argument