systemesdeproduction.blogspot.

com

Le langage de commandes

Bourne Shell

LAZREK Mohamed
 LE SHELL
Notions et mécanismes de base
Le Shell est l’interpréteur de commandes d'UNIX.

Il est lancé automatiquement lors de la connexion.

C'est un programme qui lit les commandes qui lui sont transmises
et les interprète.

Par exemple, lorsque vous saisissez une commande au clavier,

celle-ci est lue par le shell qui transmet au noyau les tâches à
exécuter,
Ce mode est appelé mode interactif
Le Shell peut également lire ses données dans un fichier de commandes,
Ce mode non interactif fait l'objet des paragraphes suivants.
Enfin, le Shell est un langage de programmation structuré, muni de
nombreuses commande de contrôle et directement interprété.
Un shell est un programme qui lit une commande sur le clavier,
analyse ses paramètres et l’exécute en lui transmettant ces paramètres :
programme shell :
Répéter
lire ligne commande
analyser et traiter les paramètres
exécuter commande
jusqu’à commande = logout ou fin fichier entrée
Le Shell est l'interface de commande du système

Il est possible pour un utilisateur d’exécuter plusieurs commandes shell :

$ps
$sh sh sh sh sh
$ps Shell Shell Shell ps
$sh Shell

$sh ^D ^D ^D
$ps ps ps
^D
^D ps ps

^D
^D
 Variables
Les variables sont désignées par des mots, elles ne se déclarent pas, et leur
type (numérique ou chaîne) dépend de leur interprétation par les
commandes.
La valeur est une chaîne de caractères :
Cours=unix poids=156

L'initialisation d'une variable se fait par une affectation :

variable=valeur
sachant qu'il n'a pas d'espaces de chaque coté du symbole =

Expansion des variables

La prise de valeur d’une variable ou d’un paramètre est réalisée par l’opérateur
$ placé devant le nom de la variable ou du paramètre.
$ N=1
$ echo $N
1

deux types de variables

- créées par l'utilisateur
- créées et maintenues par le système
 Variables Shell prédéfinies
HOME nom du répertoire personnel
exemple : /home/enim/prof1
PATH règles de recherche des commandes
LOGNAME : exemple ali
PS1 invite primaire, Par défaut, le dollar
PS2 invite secondaire; Par défaut , le >
$ echo ‘ ceci est une
> très longue
> phrase ‘
Ceci est une très longue phrase
$
Remarques :
• Une variable peut être détruite par la
commande interne unset, mais les variables
PATH, PS1, PS2 ne peuvent être détruites.
• On peut modifier la valeur des variables
prédéfinis dont le nom suit la syntaxe du
SHELL.
• La commande set imprime les variables du
Shell
 Lectures et affichages

La commande interne read admet en paramètre

une ou plusieurs variables séparées par un
séparateur de mot.

La commande echo n’a pas d’option, et admet

dans ses paramètres des séquences
d’échappement pour afficher des caractères
spéciaux.
$ cours=unix
$ echo la valeur du cours est $cours
la valeur du cours est unix
$ moi=/home/ali
$ cd /
$ pwd
/
$ cd $moi
$ pwd
/home/ali
$
 Variables Shell locales
Une variable ordinaire est une variable locale; elle n’est connue que dans le
Shell où elle été créée.
Une variable de même nom créée dans un sous-Shell, sera une variable
distincte. La valeur de la même variable dans le Shell père n’est pas
modifiée.
Tout Shell a ses propres variable globales appartenant à son environnement
Variables Shell globales
La portée d’une variable est le processus qui l’a créée. Pour être dans les
processus Shell qui seront créés par la suite, une variable doit être exportée
par la command interne export : elle est alors placée dans l’environnement
du processus, environnement dont héritent ses fils :

export N
N est visible dans les sous-programme Shell activés ultérieurement. Un
processus voit une variable externe exportée par son père, mais il n’en voit
qu’une copie dans son environnement.
La liste des variables visibles à un instant donné est obtenue par la commande
interneset , et la liste des variables exportées dans l’environnement est
obtenue par la commande env.
$ cours=unix
$ echo $cours
unix
$ sh
$ echo $cours

$ cours=dos
$echo $cours
dos
$^d
$ echo $cours
unix
$ cours=unix
$ export cours
$ echo $cours
unix
$ sh
$ echo $cours
unix
$ cours=dos
$echo $cours
dos
$^d
$ echo $cours
unix
 Sous - programmes

echo Cher utilisateur, quel est ton nom \ ?

read nom
echo Ravi de te connaître, $nom

Le " backslash " permet d’inhiber

l’interprétation du caractère spécial ?
résultat :

Cher utilisateur, quel est ton nom ?

ali
Ravi de te connaître, ali G1 G2 à faire
 Manipulation :

 éditeur de texte
 taper le programme
 le sauvegarder
 changer les permissions :
chmod u+x nom du programme
 l’exécuter :

nom du programme
 Arguments
La plus part des commandes Shell acceptent des
arguments:

$ mv f1 f2

notation :
$1 premier argument
$2 second argument
... etc

G3 G4 à refair
 Variables spéciales :

$0 : nom de la commande en cours

$* : liste des paramètres positionnels
$# : nombre d’arguments
$$ : n° de processus du Shell courant,
(exemple : création d’un fichier temporaire : f$$.t)
$! : n° du processus du dernier processus en
background
Exemple :
echo je suis le shell script $0
echo mes arguments sont $*
echo mon premier arguments est $1

$ programme moi les arguments

je suis le shell script programme
mes arguments sont moi les arguments
le premier argument est moi

Remarque :
S’il y a plus de 9 paramètres, il faut utiliser shift
TP 1:
Écrire le script shell qui permet :
d’afficher le nom de ce script shell
d’afficher tous les paramètres
de lister sur l’écran le 2° fichier
de copier le 1° fichier dans le 3° fichiers
 Boucle : for
forme général

for variable in valeur 1 valeur 2 ...

do
commandes
done
Exemple 1 :

for i in A B C
do
echo $i
done

Remarque :
for i in A B C ; do ; echo $i ; done
Exemple 2 :

for i in $*
do
echo $i
done

Appel :

$ programme A B C
Exemple 3 :

$ programme 1 a b c d
1a
1b
1c
1d
x= $1
shift
for i in $*
do
echo $x $i
done
Exemple 4 :
Recherche d’un mot dans une suite de fichiers,
le mot et les fichiers sont passés en arguments.

Appel :

$ rech ali f1 f2 f3

Utilisation de : grep
 1° solution :
grep $1 $*
Faux

2° solution :
Mot= $1
shift
grep $mot $*

3° solution :
à partir de if
Exemple 5 :

Sauvegarder tous les fichiers dont l’extension

est c
dans des fichiers appelés oldc et
dont l’extension est le nom de ces fichiers

ab.c => oldc.ab.c

for fich in *.c
do

cp $fich oldc.$fich
done
Exemple 6 :

echo sujets /?
read sujets
for i in $sujets
do
echo $i
done
Exemple 7 :

for i in
do
` cat sujets.f `
echo $i

done
Exemple 8 : (TP 2)

Afficher les 10 premières lignes des programmes

dont l’extension est c
for prog in *.c
do
echo $prog

head -10 $prog

done

Autre solution :
head -10 *.c

Pb : pas de nom des fichiers

 Notion d’état de sortie
( exit status )
Variable spéciale :
( en plus de $0, $*, $#, $$, $! )
$? : état de sortie de la dernière commande
exécutée
Terminaison correcte ===> exit 0

Terminaison incorrecte ===> exit n° # 0

Remarque :
dans un SC on peut mettre exit N°
Exemple :

$ grep mot fichier

1 : mot non trouvé

$ echo $?

0 : mot trouvé
 Boucle conditionnelle : « while »

while commande_de_contrôle
do
commandes
done

A chaque pas de boucle

la commande_de_contrôle est exécutée:

- exit 0 ==> exécution corps de la boucle

- sinon ==> sortie de la boucle
Remarque :

Les instructions while et if testent l’état de sortie

d’une commande, et non les résultats qu’elles
produisent.
Exemple :

Recherche du 1° fichier qui ne contient pas une

chaîne dans une liste de chaînes,
la chaine et la liste des fichiers sont en
paramètres

$ rech ali f1 f2 f3 f4
mot=$1
shift

while grep –v $mot $1

do
shift
done
echo $1 : le premier fichier qui ne contient
pas $mot

Pb : si tous les fichiers contiennent la chaîne ?

Exemple :

Programme qui affiche ses arguments :

$ prg un deux trois

un
deux
trois
while test $# -ne 0
do
echo $1
shift
done
 L’instruction « if »
if commande_de_contrôle
then
commandes
else
commandes
fi
if commande_de_contrôle
then
commandes
fi
Exemple :
Programme qui permet de tester si le nombre de
ses paramètres est 1

$ prg a b c
il faut un seul paramètre

$ prg a
il y a un seul paramètre
if test $# -eq 1
then
echo il y a un seul paramètre
else
echo il faut un seul paramètre
fi
Exemple :

Le script Shell qui permet de supprimer un fichier

passé en argument s’il existe,
et s’il n’existe pas afficher un message.
if rm $1 2>fichier
then
echo fichier $1 supprimé
else
echo le fichier $1 n\’existe pas
fi

Problème ?
Si le fichier n‘existe pas : affichage
d’un message de rm
Exemple :

Le script shell qui permet de supprimer le 1°

fichier passé en argument si son contenu est
identique au 2° fichier passé en argument
if cmp
cmp $1 $2 $2
-s $1
then
rm $1
echo $1 et $2 sont identiques
Else
echo $1 et $2 ne sont pas identiques
fi

Problème : si $1 n’existe pas ?

 L’instruction « case »

case valeur in
choix_1) commandes ;;
choix_2) commandes ;;
...
*) commandes ;; # cas par défaut
esac
Exemple :
echo N° de la commande que vous souhaitez \?
echo1- date 2- who
echo3- ls 4- pwd
read choix
case $choix in
1) date;;
2) who;;
3) ls;;
4) pwd;;
*) echo choix incorrect
esac
TP 3 :
Un programme qui permet de supprimer tous les
fichiers dont l’extension est old
De sauvegarder les fichiers dont l’extension est c
dans le sous répertoire sauvec du répertoire
courant
De sauvegarder les fichiers dont l’extension est f
dans le sous répertoire sauvef du répertoire
courant
Les autres fichiers à garder dans le répertoire
courant
for fich in *
do
case $fich in
*.old) rm $fich;;
*.c) mv $fich sauvec;;
*.f) mv $fich sauvef;;
esac
done

Problème :
Si le sous répertoire sauvec ( et/ou sauvef )
n’existe pas?
 L’instruction « test »

La commande test permet d’effectuer divers

types de tests:

 test d’état de fichier

 test de comparaison de chaînes
 test de comparaison numérique

à l’aide d’une panoplie d’opérateurs distincts.

 Test d’état de fichier

test - r fichier vrai, si existe et droit en lecture

-w …………………………….écriture
-f ……………………..non répertoire
-d ……………..……………répertoire
-s …………………………….taille > 0
-x ………………………….exécutable
 Test de comparaison de chaînes
= != -n -z

test chaîne1 = chaîne2 # égalité

test chaîne1 != chaîne2 # non égalité
test -n chaîne # longueur non égal à 0
test -z chaîne # longueur zero
test chaîne # chaîne nulle
 Test de comparaison numérique
-eq -ne -gt -lt -ge -le

test n1 -eq n2 # égalité

test n1 -ne n2 # non égalité
test n1 -gt n2 # supérieur
test n1 -lt n2 # inférieur
test n1 -ge n2 # supérieur ou égal
test n1 -le n2 # inférieur ou égal
Test et opérations logiques

! négation
-a et logique
-o ou logique
Exemple :

$ test ! –r fich
$ echo $? (c’est 0=vrai ou 1=faux)
Vrai si fich existe et si pas de droit en lecture

if test –r fich1 –a w fich2

Vrai si droit en lecture sur fich1 et si droit en
écriture sur fich2
 Calcul arithmétique « expr »
expr interprète, évalue une expression arithmétique,
le résultat est produit en sortie

$ expr 3 + 5
8
$ expr 9 - 2
7
$ expr 4 * 3
syntax error
$ expr 4 \* 3
12
$ expr 12 / 3
4
$ expr 14 / 5
2
$ expr 14 % 5
4
`
$ N= expr $N + 1 ` # incrémentation de la variable N
Exemple :
Convertir chaque argument de minute en
seconde

On ne connaît pas le nombre de paramètre

while test $1
do
echo `expr 60 \* $1`
shift
done
Exemple :
Supprimer tous les fichiers en .o qui ont leur .c

Option de compilation :

-c : suppression de l’édition de lien, création du .o

(compilation séparée)

gcc –c proc.c proc.o

for prog in *.o
do

if [ -f `basename $prog `
.o .c ]
then
rm $prog
fi
done
Problème :
Le script shell qui permet de chercher et
d’afficher tous les sous répertoires,
à partir d’un répertoire donné en second
argument,
qui contiennent un fichier,
donné en premier argument.

$ cherche / fichier.ext
cd $2
if test –f $1
then
echo le fichier $1 est dans le sous repertoire `pwd`
fi
for i in *
do
if test –d $i
then
$HOME/cherche
cherche $1 $i $1 $i
fi
done
Cette commande aurait pu s’écrire en utilisant la
commande find :

$ find $2 –name $1 -print

TP 4 :
Script shell qui permet de calculer le nombre de
fichiers, dans une liste, contenant une chaîne
de caractères.
La liste de fichier ainsi que la chaîne de
caractères sont passés en paramètres.

Il faut tester l’existence de chaque fichier.

Exemple :
calcul ali f1 f2 f3 f4
TP 5 :
Compléter les TPs précédents