Vous êtes sur la page 1sur 15

Plan

Partie1: Définition et utilisation de variable

Chapitre 3 1. Introduction
2. Les scripts Shell
3. Les variables
Partie2: Définition d’une expression
La programmation Shell 1. La procédure
2. La commande test
3. La commande expr
Partie3: Structure de contrôle
1. La structure conditionnelle
2. Le choix multiples
3. Les structures itératives
4. La fonction
1 2

1 2

1. Introduction 2. Les scripts Shell

La programmation shell Saisie du script


Un script bash est un fichier de type texte contenant une suite Utiliser vi de préférence
de commande shell, exécutable par l’interpréteur comme une
commande unique. Les lignes commençant par le caractère dièse # sont des
commentaires.

Un script peut être lancé en ligne de commande, comme dans un Le script doit débuter par l’indication de son interpréteur écrite sur
autre script. Mais il s’agit bien plus qu’un simple enchaînement de la première ligne: #!/bin/bash

commande: on peut définir des variables et utiliser des structures de


contrôle, ce qui lui confère le statut de langage de programmation
interprété et complet.

3 4

3 4

1
2. Les scripts Shell 3. Les variables
Saisie du script
3.1- Les variables prédéfinies
Exemple:
#!/bin/bash
afficher les variables d’environnement avec la commande env
#script bonjour
$ env
#affiche un salut à l’utilisateur qui l’a lancé
#la variable d’environnement $USER contient le nom de login
echo ----Bonjour $USER -----
Variable Signification
#l’option –n empêche le passage à la ligne
HOME Répertoire personnel
#le ; sert de séparateur des commandes sur la ligne
echo –n “Nous sommes le“; date PATH Répertoire de recherche des commandes
#recherche de $USER en début de ligne dans le fichier passwd
TERM Nom du type de terminal utilisé
#puis extraction de l’uid au 3ième champ, et affichage
echo “Ton numéro d’utilisateur est “ USER Nom de l’utilisateur
(grep “^$USER“ /etc/passwd | cut -d: -f3)
PWD Le chemin courant
5 6

5 6

2. Les scripts Shell 3. Les variables

Exécution du script L’affectation


Il est indispensable que le fichier script ait la permission x (soit exécutable).
Lui accorder cette permission pour tous ses utilisateurs avec chmod:
$variable=valeur
$a=truc
Chmod a+x bonjour
$monrep=/usr/c1
$d=date
Pour lancer l’exécution du script, taper ./bonjour, ./ indiquant le chemin, ici le
$j=‘mot1 mot2’
répertoire courant. Ou bien indiquer le chemin absolu à partir de la racine.
Ceci dans le cas où le répertoire contenant le script n’est pas listé dans le PATH
Par exemple, i=2, i=0002, i=deux n’ont pas la moindre signification de valeur pour
le shell, et sont donc pour lui des affectations différentes.

7 8

7 8

2
3. Les variables 3. Les variables
Le contenu Réévaluation de variables
Il s’agit de la récupération du contenu de la variable
Il n’est pas possible de réévaluer les variables utilisateurs. C’est-à-dire que le shell ne
change la valeur d’une variable QUE lors de l’affectation.
$variable=valeur $A=1
$echo variable $B=A
variable $echo $B
$echo $variable A
valeur $B=$A
$ $echo $B
1
Le shell interprète d’abord les variables, puis la commande qu’il trouve en première position sur la $A=2
ligne. $echo $B
1
$
On affecte toujours une variable à une chaîne de caractère, soit le nom de la variable
(B=A), soit son contenu (B=$A).
9 10

9 10

3. Les variables 3.7- Substitution de commande

Substitution de commande
Une commande à exécuter entre ‘‘(guillemet inverse):
Il est possible de faire exécuter une commande et d’en récupérer le résultat dans une
variable. Cela se fait en encadrant une commande par des quotes inverses ou accent
grave ``.
Dans ce cas, on substitue la commande par sa sortie standard; c’est-à-dire que l’on $var= `cd /etc ; grep fun passwd`
exécute la commande se trouvant entre ``, puis le shell interprète la ligne de commande.
$echo $var
fun:x:208:55:Guy Thienot:/tech/u2/fun:/bin/ksh
$echo la date est: `date`
$
la date est: Wed May 18 15:56:30 MET 2018

La substitution de commande permet l’exécution d’une commande ou même d’un fichier


de commandes.

11 12

11 12

3
3. Les variables 3. Les variables

Ordre d’interprétation L’affectation interactive


– La commande interne read permet d’assigner une valeur à une variable, à
Voici l’ordre et ce qu’interprète le shell:
1. gestion des redirections (<, >, >>, <<, |) partir d’une lecture sur l’entrée standard (par défaut).

2. Interprétation des “ dans un sous-shell (substitution de commande) – La commande se met en attente du clavier et affecte les valeurs que vous
3. Interprétation des variables
tapez aux noms de variables qui lui sont passés en arguments.
4. Interprétation des méta caractères
5. Affectation ou exécution du premier mot rencontré sur la ligne avec
comme arguments les substitutions précédentes
$j=`date`
$d=date
$echo $j
Wed May 18 16:28:16 MET 1994
13 14

13 14

3.9- l’affectation interactive

Exemples: $echo $a La commande export


et
$read a $echo $b • Supposons que tu crées un script toto.sh et que
33 voici tu déclares dedans une variable toto (sans
$echo $a $echo $c export) et une variable titi (avec export). Si tu
33 quatre mots exécutes ton script dans ton shell, alors toto ne
$read b c d $read d e f "vivra" que le temps du script toto.sh, tandis que
voici trois mots blups
titi subsistera même quand ton script sera
terminé (tu peux le vérifier avec echo $titi).
$echo $d $c $b $echo $d
mots trois voici blups
$read a b c $echo $e • export est traditionnellement utilisé pour créer
et voici quatre mots $echo $f des variables d'environnement.
• $ export HOME="/home/ubuntu"
15 16

15 16

4
plan
1. Procédure
Partie1: Définition et utilisation de variable Une procédure (shell script – fichier de commandes shell) est un fichier
Partie2: Définition d’une expression contenant une suite de lignes exécutables par l’interpréteur de commande
shell.
1. La procédure
Exemple:
2. La commande test $cat p1
# ceci est une procédure
3. La commande expr date
Partie3: Structure de contrôle who
$

17 18

17 18

1. Procédure 1.2- Paramètres positionnels

1.2- Paramètres positionnels La procédure ne peut jamais initialiser le contenu de ces variables, mais peut le consulter
en utilisant la syntaxe $0, $1, $2,…$9. Chaque paramètre positionnel contient un mot de
Si une procédure est exécutable, on peut l’appeler comme les autres commandes la ligne de commande.

externes, c’est-à-dire mettre le nom de cette procédure au début de ligne et la Exemple:


faire suivre d’arguments:
$ P1 X Y Z
$p1 arg1 arg2 arg3

La procédure trouve les arguments d’appel dans des pseudo-variables, appelées $0 P1 Z $3


paramètres positionnels, dont les noms sont $0, $1, $2 …, $9.
$1 X Y $2
En fait ce ne sont que des valeurs, en effet un nom de variable ne peut pas
commencer par un chiffre.

19 20

19 20

5
1. Procédure

1.3- Variable automatiques


Lorsqu’une procédure commence, d’autres variables spéciales, en plus des paramètres La commande shift
positionnels, sont initialisées. Celles-ci peuvent être consultées, mais pas modifiées. On
les appelle les variables automatiques ou prédéfinies.
La commande shift permet de décaler les paramètres.
Nom de la variable Valeur de la variable
_ (underscore) Le dernier mot de la dernière commande exécutée
La valeur du 1er paramètre ($1) est remplacée par la valeur du 2nd paramètre
($2), celle du 2nd paramètre ($2) par celle du 3ème paramètre (
# Le nombre de variables de position définies
* La liste des variables de position vu comme une seule variable
$3), etc... On peut indiquer en argument (shift [n]) le nombre de pas (position)
dont il faut décaler les paramètres
@ La liste des variables de position
Exemple:
? Le code de retour du dernier processus terminé
$ Le numéro du processus courant
while test $# -ne 0
! Le numéro du dernier processus lancé en arrière plan do
PPID Le numéro du processus père echo $1
PWD La référence absolue du répertoire de travail shift
RANDOM Un nombre aléatoire done
SECONDS Le nombre de secondes écoulées depuis le lancement du processus shell
21 22

21 22

• ./decale_param.sh 1 2 3 4 5 6 7 8 9 10

• Nombre de paramètres : 10 Initialiser les paramètres


• Le 1er paramètre est : 1
• Le 3ème paramètre est : 3
• Le 6ème paramètre est : 6 La commande "set"
• Le 10ème paramètre est : 10
• =============================================
Il est possible d'affecter directement des paramètres
• Décalage d'un pas avec la commande "shift" au shell grâce à la commande set
• Nombre de paramètres : 9 Une simple commande tel que :set param1 param2
• Le 1er paramètre est : 2
• Le 3ème paramètre est : 4
param3 initialisera automatiquement les paramètres
• Le 6ème paramètre est : 7 Positionnels $1,$2,$3 avec les valeurs
• Le 10ème paramètre est : param1,param2,param3, effaçant de ce fait les
• =============================================
anciennes valeurs si toutefois elles existaient.
• Décalage de quatre pas avec la commande "shift 4"
• Nombre de paramètres : 5 Les paramètres spéciaux $#,$*et$@ sont automatiquement
• Le 1er paramètre est : 6 mis à jours en conséquence.
• Le 3ème paramètre est : 8
23 24
• Le 6ème paramètre est :
• Le 10ème paramètre est :
23 24

6
Chapitre1: Définition et utilisation de variable
Exemples: 2. La commande test
• $ set param1 param2 param3 Généralités
• $ echo "Nombre de paramètres : $#" – Comme son nom l’indique, elle sert à vérifier des conditions.
• Nombre de paramètres : 3 – Ces conditions portent sur des fichiers (le plus souvent), ou des chaînes ou
une expression numérique.
• $ echo "Le second paramètre est : $2"
– Cette commande courante sert donc à prendre des (bonnes) décisions, d’où
• Le second paramètre est : param2 son utilisation comme condition dans les structures conditionnelles if .. then
• $ echo "Les paramètres sont : $@" .. else, en quelque sorte à la place de variables booléennes … qui n’existent
pas.
• Les paramètres sont : param1 param2 param3
Syntaxe
Test expression
• $ set pêche pomme [expression]
• $ echo "Nombre de paramètres : $#" Valeur de retour
• Nombre de paramètres : 2 La commande test, retourne 0 si la condition est considérée comme vraie, une
valeur différentes de 0 sinon pour signifier qu’elle est fausse.
• $ echo "Les paramètres sont : $@"
25 26
• Les paramètres sont : pêche pomme

25 26

2. La commande test 2. La commande test

Tester un fichier Tester une chaine


Elle admet 2 syntaxes (la seconde est la plus utilisée):
test option fichier
[ option chaîne ]
OU BIEN
Option significatif:
[ option fichier ]
-z | -n la chaine est vide / n’est pas vide
Exemples des options: = | != les chaines comparées sont identiques | différentes.
-e il existe
-f c’est un fichier normal
-d c’est un répertoire Exemple:
-r | -w | -x il est lisible modifiable exécutable [-n " toto"]
-s il n’est pas vide
echo $?
Exemples:
[-w fichier] le fichier est il modifiable? Affiche la valeur renvoyée 0
[-r “/etc/passwd“] peut-on lire le fichier /etc/passwd?
27 28

27 28

7
2. La commande test 2. La commande test

Tester un nombre Opérations dans une commande test


[ nb1 option nb2 ] • [expr1 –a expr2]
Il y a d’abord un transtypage automatique de la chaîne de (and) 0 si les 2 expr sont vraies
caractères en nombre • [expr1 –o expr2]
(or) 0 si l’une des 2 expr est vraie
Option Significatif
• [!expr1]
-eq | -ne égal | différent
négation
-lt | -gt strict.inf | strict.sup
-le | -ge inf ou égal | sup ou égal
Exemple:
note=9;
Exemples:
[$note –lt 8 –o $note –ge 10] && echo “tu n’est pas convoqué(e) à l’oral"
a=15; [" $a " –lt 15]; echo $?

29 30

29 30

3.La commande expr

3.La commande expr # Opérations Logiques retourne 1 si vrai, 0 si faux,


echo x=24 y=25
b=‘expr $x = $y’
Définition: # Test d’égalité
Évaluateur d’expression: concatène et évalue les arguments echo “b = $b“ # 0 [ $x –ne $y ]
suivant l’opération souhaitée (les arguments doivent être séparés
par des espaces). Les opérations peuvent être arithmétiques,
comparatives, chaîne de caractères ou logiques.

expr 3+5 #renvoie 8


expr 5 % 3 #renvoie 2
expr 5 \* 3 #renvoie 15

L’opérateur de multiplication doit être échappé lorsqu’il est utilisé


dans une expression arithmétique avec expr.
31 32

31 32

8
3.La commande expr

# Opérateur de chaîne de caractères


echo “Opérateur de chaînes de caractères“ Exercice 1…
echo a=1234zipper43231
echo “Voici $a“
# length: longueur de la chaîne  Écrire une procédure shell « types » qui
b=‘expr length $a’ teste si un fichier est de type ordinaire ou
echo “la taille de $a est $b“
répertoire et affiche le résultat
# Index: position du premier caractère dans une sous-chaine qui correspond à un
# caractère dans la chaine
b=‘expr index $a 23’
echo “la position du premier 23 dans $a est $b“
# substr: extrait une sous-chaine, en spécifiant la position de départ et la taille
b=‘expr substr $a 2 6’

33 34

33 34

Chapitre3: Structure de contrôle


Plan 1. La structures conditionnelles
Partie1: Définition et utilisation de variable Syntaxe:
if condition
Partie2: Définition d’une expression then
Syntaxe:
instruction(s)
Partie3: Structure de contrôle fi
if condition
then
instruction(s)
1. La structure conditionnelle Syntaxe: elif condition
if condition then
2. Le choix multiples then instruction(s)
instruction(s) fi
3. Les structures itératives else
instruction(s)
4. La fonction fi

35 36

35 36

9
1. Structures conditionnelles 1. Structures conditionnelles

L’exemple suivant teste l’existence d’un fichier


if suite-de-conditions if [-e “/etc/shadow"]
then
then # séquence exécutée si suite-de-conditions rend une echo “fichier existe“
# valeur 0 else
echo “Erreur fichier inexistant“
else # séquence exécutée sinon
fi
bloc-instruction2 Pour vérifier que 2 arguments ont été passés au script
if [$# -ne 2]
fi then
echo “il faut 2 arguments vous en avez $#“
fi
Attention: ! Si bien est placé sur la 1ère ligne, séparer avec un ; Test numérique permet d’afficher si l’argument passé en paramètre est compris entre 5
et 10:
if condition ; then …
if [$1 –gt 5 –a $1 –lt 10]
then
echo “5<$1<10“
fi
37 38

37 38

1. Structures conditionnelles 1. Structures conditionnelles


Test numérique permet d’afficher si l’argument passé en paramètre est un nombre Si toto a eu une bonne note, on le félicite
positif, négatif ou nul: note=17
if [$1 -gt 0] if [$note -gt 16]
then then
echo “très bien!!!!“
echo “$1 est positive“
fi
elif [$1 -lt 0]
toto a-t-il fait son devoir lisiblement ?
then
fichier=/home/toto/devoir1.html
echo “$1 est négative“ if [-f $fichier -a -r $fichier]
elif [$1 -eq 0] then
then echo “je vais vérifier ton devoir.“
echo “$1 est zero“ elif [! -e $fichier]
else then
echo “ton devoir n’existe pas!!!!“
echo “Opps! $1 n’est pas nbre, donner un nombre“
else
fi
echo “je ne peux pas le lire!!!!“
fi
39 40

39 40

10
1. Structures conditionnelles

Supposons que le script exige la présence d’au moins un paramètre, il faut tester la Exercice 2
valeur de $#, est elle nulle?
if [$# = 0]  Écrire la commande tester qui :
then  si elle est appliquée à un répertoire retourne le
echo “erreur, la commande exige au moins un argument..“ nombre de fichiers de ce répertoire
exit 1  si elle est appliquée à un fichier, retourne la taille du
elif [$# = 1]
fichier
then
echo “Donner le second argument:“
read arg2
fi

41 42

41 42

Chapitre3: Structure de contrôle

Exercice 3 2. Choix multiples


Syntaxe:
case valeur in
 Écrire la commande dumper : expr1) commandes;;
expr2) commandes;;
 lorsqu'elleest appliquée à un répertoire écrit …
dans un fichier "resultat" la liste des fichiers esac
;; indique la fin du choix (cas).
du répertoire
 sinon renvoie une erreur Exemple:
Le script attent une langue de l’utilisateur
read langue
case $langue in
français) echo bonjour;;
anglais) echo hello;;
espagnol) echo buenos Dias;;
esac
43 44

43 44

11
2. Choix multiples Chapitre3: Structure de contrôle

Exemple1: 3. Structure itérative


case $param in
0|1|2|3|4|5|6|7|8|9) echo $param est un chiffre;;
[0-9]*) echo $param est un nombre;;
[a-zA-Z]*) echo $param est un nom;; 3.1 La boucle for
*) echo $param de type non prévu;;
esac 3.2 La boucle while
3.3 La boucle until
Exemple2:
3.4 Interruption & reprise d’une boucle
case $1 in
one) X=un;;
two) X=deux;;
three) X=trois;;
*) X=$1;;
esac
45 46

45 46

3. Structure itérative 3.1 Boucle for

3.1 Boucle for Supposons que nous voulions parcourir tous les sous-répertoires du répertoire courant pour
faire cette même manipulation. Nous pourrons taper:
for REP in `find . -type d`
Syntaxe: do
for variable in liste for FICH in $REP/*.tar.gz
do do
Commandes (utilisant $variable) if [-f $FICH]
done then
mv $FICH $FICH.old
Pour chaque valeur de la variable dans la liste de valeurs, exécuter le ou la suite de commande. else
echo On ne renomme pas $FICH car ce n\’est pas un fichier
fi
Exemples: done
Supposons que nous souhaitons renommer tous nos fichiers *.tar.gz en *.tar.gz.old, nous done
taperons le script suivant:
#Une boucle for avec une [liste] générée par une substitution de commande.
for I in *.tar.gz
NOMBRE=“9 7 3 8 37.53“
do #tous les fichiers $I sont renommés $I.old
for nombre in ‘echo $NOMBRE’ # ou bien for nombre in 9 7 3 8 37.53
echo “$I-> $I.old“
mv $I $I.old do
#on finit notre boucle echo –n “$nombre“
done done

47 48

47 48

12
3. Structure itérative 3.2 La boucle while
Exemples:
3.2 La boucle while Supposons, par exemples que vous souhaitiez afficher les 100 premiers nombres
(pour une obscure raison), alors vous taperez:
i=0
<tant que> le résultat commande est vraie. La commande while consiste en while [$i –lt 100]
l’exécution d’une commande en fonction de la valeur de retour d’une autre do
commande. Si la valeur de retour est différente de zéro, l’exécution de la boucle echo $i
est interrompue. i=$(($i+1))
done
Supposons, par exemples que vous souhaitiez lire un nom à partir du clavier , alors
Syntaxe: vous taperez:
echo –e “Entrez un nom de fichier“
while suite de commande
read fich
do while [-z “$fich“]
Commandes do
echo –e “Saisie à recommencer “
done
read fich
done
49 50

49 50

3.2 La boucle while 3. Structure itérative

Supposons, par exemples que vous souhaitiez afficher les 10 premiers nombre, alors
vous taperez:
3.3 La boucle until
var0=0 <jusqu’à ce que> le résultat de la commande soit vrai.
LIMITE=10 La commande until est exécutée jusqu’à ce que la dernière commande de la liste de
while [“$var0“ –lt “$LIMITE“] commandes placée derrière until renvoie une valeur vraie soit 0.
do Syntaxe:
echo –n “$var0“ # -n supprime le retour chariot.
until suite de commandes
var0=‘expr $var0+1’ #var0=$(($var0+1)) fonctionne aussi.
done do
Supposons, par exemples que vous souhaitiez quitter si le paramètre donné est « Commandes
fin », alors vous taperez: done
while [“$var1“!=“fin"] Exemple:
do
until [“$var1“=fin] # condition du test ici, en haut de la boucle.
echo “Variable d’entrée #1 (quitte avec fin)“ do
read var1 echo "variable d’entrée #1“
echo “(fin pour sortir)"
echo “variable #1 = $var1“ read var1
done echo “variable #1 =$var1”
done
51 52

51 52

13
Chapitre3: Structure de contrôle 4. Fonctions
Les commandes contenues dans une fonction pourront utiliser :
4. Fonctions les paramètre positionnels ($0, $1, $2, ..., $9),
les variables automatiques (?, #, *, $, −, @, !),
Le shell permet la déclaration de fonctions qui pourront être appelées au sein d’une les structures de contrôle (if, for, case, while, until),
procédure ou en direct sur l’interprète. les redirections d’entrées/sorties,
L’appel à une fonction est plus rapide que l’appel à un script. les tubes (pipe "|").
Une fonction regroupe des commandes qui seront lancées à l’appel à cette fonction. Exemple :
$ info ( )
Contrairement aux procédures, une fonction peut modifier l’environnement d’un
{
shell.
date
nom_de_fonction ( ) pwd
{ }
commande1 $ info
commande2 Fri Sep 16 16:05:06 MET 2018
/home/enetcom
commande3
$
}
53 54

53 54

4. Fonctions Exemple
Les fonctions accèdent à leurs arguments par les paramètres positionnels ($0, $1, ...). Elles
peuvent également consulter les variables automatiques ($#, $*, ...). function affSigne() function carré()
$ dir ( ) { {
> ls $* local signe {
>} if [ $n -lt 0 ] return $[ $1 * $1 ]
$ dir / then
signe=négatif }
Il est possible de rediriger les entrées/sorties d’une fonction, ou encore de les combiner par
des pipes. Il est également possible de les exécuter dans des structures de contrôle. elif [ $n -gt 0 ]
then On peut utiliser ces deux fonctions dans un
$ dir / > /tmp/out
signe=positif script comme suit:
$ dir / | wc
else
3 15 198 echo -n "Entrez un nombre: "
$ signe=nul read n
Chaque commande shell de la fonction est exécutée en séquence. Si une commande retourne fi
echo "Le nombre $1 est $signe" affSigne $n
un statut à faux, la commande suivante est exécutée quand même. La fonction retourne le
statut de la dernière commande lancée. } carré $n
return n permet de quitter la fonction en retournant n comme statut. n=$?
echo "Le carré du nombre choisi est $n"

55 56

55 56

14
Exemple

factorielle() Exercice 4
{
if [ $# -ne 1 ] || [ $1 -lt 0 ] ; then
echo "Usage: factorielle n (avec n >= 0)"
On peut utiliser cette fonction dans
un script comme suit:
• Créer un script qui vous propose le menu
1>&2 n=0
suivant :
else
resultat=1
until [ $n -eq 14 ] 1 - Vérifier l'existence d'un utilisateur
do
n=$1
resultat=$(factorielle $n)
2 - Connaître l'UID d'un utilisateur
while [ $n -gt 1 ] ; do
let $[ resultat *= n] echo "$n! = $resultat" q - Quitter
let $(n -= 1) let $(n += 1)
done
done
echo "$resultat"
fi
}
57 58

57 58

15