SHELL Program Mat Ion Shell Sous Unix-Orsys Lacoste

Programmation Shell sous Unix
Jean-Marc LACOSTE
Ambre Systems
3 chemin des Friches
Hameau de La Brosse
91 640 JANVRY
http://www.ambre-systems.com
Juillet 2005. Jean-Marc LACOSTE - Ambre-Systems
Ce document est protégé par un copyright. Aucune partie de ce document ne peut être reproduite sans
l’autorisation préalable et écrite de Ambre-Systems et de Jean-Marc LACOSTE (loi du 11 mars 1957,
article 40, alinéa 1). Une reproduction sans l’accord de l’auteur par quelque procédé que ce soit constituerait
une contrefa¸con sanctionnée par les articles 425 et suivants du Code Pénal.
Version 1.0 - Janvier 2005 - Première édition

Version 1.1 - Juillet 2005 - Corrections
Table des matières
1 Introduction 1
1.1 Principes fondamentaux de la programmation shell . . . . . . 2
1.2 Documentation disponible . . . . . . . . . . . . . . . . . . . . 3
1.2.1 Site Internet . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.2 Livres . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Notions de base en shell 5

2.1 Rappel sur l’entrée en session . . . . . . . . . . . . . . . . . . 6
2.2 Étude des différents fichiers de démarrage . . . . . . . . . . . 7
2.3 Variables et environnement . . . . . . . . . . . . . . . . . . . . 8
2.4 Notion d’environnement : instruction export . . . . . . . . . . 8
2.4.1 Afficher la liste de toutes les variables, celles de l’environnement et celles qui ne s’y trou
2.4.2 Afficher la liste des variables de l’environnement . . . . 9
2.5 Quelques variables système . . . . . . . . . . . . . . . . . . . . 9
2.5.1 Exemples d’utilisation . . . . . . . . . . . . . . . . . . 10
2.6 Compléments sur les variables . . . . . . . . . . . . . . . . . . 11
2.7 Caractères spéciaux . . . . . . . . . . . . . . . . . . . . . . . . 12
2.7.1 Expressions génériques composées du Korn-shell . . . . 13
2.7.2 Substitutions de commandes . . . . . . . . . . . . . . . 13
2.7.3 Caractères de protections . . . . . . . . . . . . . . . . . 14
2.7.4 Procédures et paramètres . . . . . . . . . . . . . . . . 14
2.8 Structure et exécution d’un script shell . . . . . . . . . . . . . 14
2.9 Commentaire et shell interpréteur d’un script . . . . . . . . . 15
2.10 Code retour et traitement associé . . . . . . . . . . . . . . . . 15
2.11 Interprétation d’une ligne de commande . . . . . . . . . . . . 15
2.12 Paramètres du script . . . . . . . . . . . . . . . . . . . . . . . 16
3 Programmation shell 17
3.1 Instructions conditionnelles et tests . . . . . . . . . . . . . . . 18
3.1.1 L’instruction if . . . . . . . . . . . . . . . . . . . . . . 18
3.1.2 Instructions conditionnelles composées : if imbriqués . . 18
3.1.3 Instructions conditionnelles compactes : opérateurs && et || 19
3.1.4 La commande test . . . . . . . . . . . . . . . . . . . . 19
3.1.5 Enrichissement de la commande test du Korn-Shell . . 20
3.2 Traitement sur flux : les boucles . . . . . . . . . . . . . . . . . 21
3.2.1 La boucle for . . . . . . . . . . . . . . . . . . . . . . . 21
3.2.2 Les boucles while et until . . . . . . . . . . . . . . . . 21
3.3 Lectures au clavier : read . . . . . . . . . . . . . . . . . . . . . 22
juillet 2005 - Ambre systems - Programmation Shell sous UNIX- SHL - JML/07-2005
TABLE DES MATIÈRES
3.3.1 Nouvelles possibilités en Korn-shell . . . . . . . . . . . 23

3.4 Expressions arithmétiques . . . . . . . . . . . . . . . . . . . . 23
3.4.1 La commande expr (Bourne shell) . . . . . . . . . . . . 23
3.4.2 Expressions arithmétiques Korn shell . . . . . . . . . . 23
3.4.3 Possibilités complémentaires . . . . . . . . . . . . . . . 24
3.5 Branchements . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.5.1 Instruction case . . . . . . . . . . . . . . . . . . . . . . 24
3.5.2 Instruction select du Korn-Shell . . . . . . . . . . . . . 25
3.6 Fonctionnalités complémentaires . . . . . . . . . . . . . . . . . 26
3.6.1 Tableaux du Korn-Shell . . . . . . . . . . . . . . . . . 26
3.6.2 Redirections particulières de lentrée standard : Script en ligne 26
3.6.3 Gestion des Entrées / Sorties : Compléments . . . . . . 27
3.6.4 La variable IFS . . . . . . . . . . . . . . . . . . . . . . 29
3.6.5 L’opérateur shift . . . . . . . . . . . . . . . . . . . . . 29
3.6.6 L’opérateur set . . . . . . . . . . . . . . . . . . . . . . 29
3.6.7 Gestion des signaux . . . . . . . . . . . . . . . . . . . . 31
3.6.8 Autres commandes internes . . . . . . . . . . . . . . . 31
3.7 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.7.1 Principe et propriétés . . . . . . . . . . . . . . . . . . . 33
4 Utilitaires et commandes Unix 39

4.1 Les différentes licences . . . . . . . . . . . . . . . . . . . . . . 40
4.2 Quelques filtres simples . . . . . . . . . . . . . . . . . . . . . . 40
4.2.1 Utilitaire de tri : sort . . . . . . . . . . . . . . . . . . . 41
4.2.2 Utilisation des champs . . . . . . . . . . . . . . . . . . 41
4.3 Transformations de caractères : tr . . . . . . . . . . . . . . . . 42
4.4 Rappel des expressions régulières . . . . . . . . . . . . . . . . 42
4.5 Recherche d’expressions : grep . . . . . . . . . . . . . . . . . . 43
5 sed & awk 45

5.1 Edition (non interactive) de fichiers : sed . . . . . . . . . . . . 46
5.2 Introduction au langage awk . . . . . . . . . . . . . . . . . . . 47
5.2.1 Les motifs . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.2.2 Les actions . . . . . . . . . . . . . . . . . . . . . . . . 48
5.2.3 Les tableaux associatifs . . . . . . . . . . . . . . . . . . 48
5.2.4 Aide-mmoire rsum de awk . . . . . . . . . . . . . . . . 49
5.2.5 Instructions de contrle . . . . . . . . . . . . . . . . . . 50
5.2.6 Quelques fonctions intgres . . . . . . . . . . . . . . . . 50
A Énoncé des exercices 51

A.1 Principes fondamentaux d’Unix . . . . . . . . . . . . . . . . . 52
A.2 TP1 Traitement de la ligne de commandes et utilisation de la commande test sur les fi
A.3 TP1-bis Traitement de la ligne de commandes et utilisation de la commande test sur l
A.4 TP2 Exemple de boucle for . . . . . . . . . . . . . . . . . . . 53
A.5 TP2-bis Exemple de boucle for et d’utilisation des expressions arithmétiques 53
A.6 TP3 Exemple de boucle while et de lecture clavier . . . . . . 53
A.7 TP4 Exemple d’aiguillage case . . . . . . . . . . . . . . . . . 53
A.8 TP5 Instruction select , Expressions arithmétiques et tableaux 54
www.ambre-systems.com SHL - JML/07-2005

TABLE DES MATIÈRES
A.9 Un plus dans le script est de prévoir lopération Modulo . . . . 54

A.10 TP6 Exemple de traitement des interruptions, utilisation des fonctions et de la boucle while 5
A.11 ENONCES D’EXERCICES SUR LES FILTRES . . . . . . . . 54
A.11.1 Exercice 1 Utilitaire de tri sort sur le fichier exemple . 55
A.11.2 Exercice 2 Utilitaire de tri sort sur des commandes ou fichiers du système 55
A.11.3 Exercice 3 Transformation de caractères : tr en sortie de commande ls 55
A.11.4 Exercice 4 Recherche dexpressions avec grep sur le fichier exemple 55
A.11.5 Exercice 5 Recherche dexpressions avec grep sur le fichier /etc/passwd 55
A.11.6 Exercice 6 Edition non interactive de fichiers : sed sur le fichier exemple 56
A.11.7 Exercice 7 Traı̂tement sur le fichier exemple avec loutil awk 56
A.12 ENONCES D’EXERCICES DE L’ATELIER DE PROGRAMMATION SHELL 56
A.13 Atelier 1 Modification de nom de fichiers avec confirmation éventuelle et gestion de la ligne de
A.14 Atelier 2 Autre script de modification de nom de fichiers . . . 57
A.14.1 Atelier 3 Traitements sur les fichiers : test . . . . . . . 57
A.14.2 Atelier4 Menu simple avec case et appel de commandes UNIX 57
A.14.3 Atelier 5 Gestion de la ligne de commande et traitement sur les fichiers 58
A.14.4 Atelier 6 Traitements sur les fichiers et Expressions arithmétiques 58
A.14.5 Atelier 7 Habillage de la commande find et utilisation de fonctions 58
A.14.6 Atelier 8 Traitement de la ligne de commande . . . . . 58
juillet 2005 - Ambre systems - Programmation Shell sous UNIX- SHL - JML/07-2005
1
Chapitre 1
Introduction
Objectifs
Rappels sur les principes d’un système d’exploitation
Rappels sur certaines commandes de base
Rappel sur l’utilisation du manuel
Programmation Shell sous UNIX - 2005 Ambre systems 1-1

2 Chapitre 1 Introduction
1.1 Principes fondamentaux de la

programmation shell
Principes fondamentaux
Système d’exploitation multi-tâche
Complexe et puissant
Nombreuses applications intégrées
Grande collaboration avec le ”Domaine

Public”
On souhaite prsenter l’essentiel des syntaxes du shell telles qu’on les utilise
classiquement dans des scripts ”professionnels”. En ce sens, on ne prtend
pas tre exhaustif et couvrir l’intgralit de certaines tournures syntaxiques.
Ce document comporte, en tant que tel, relativement peu d’exemples car il
sera accompagn, par ailleurs, d’un nombre important d’exercices de mise en
uvre.
On ne fera plus forcment la distinction entre le traditionnel ”Bourne-shell”
et les extensions apportes par le ”Korn-shell” car on suppose que celui-ci
est largement standardis aujourd’hui et que son utilisation, dans le cadre de
scripts d’entreprise, est tout fait ”dans les murs”.
Enfin, la version ”ksh93” ( dernire volution du langage ) n’est pas prsente
car elle n’est pas souvent disponible dans les implmentations commerciales
d UNIX.. Le site Internet ”www.kornshell.com” donne des prcisions sur ce
point et permet de rcuprer ventuellement des versions binaires du ”ksh93”
qui tarde s’imposer comme standard officiel.
1-2 Programmation Shell sous UNIX - 2005 Ambre systems

Chapitre 1 Introduction 3
1.2 Documentation disponible

Documentation

Public”
1.2.1 Site Internet

http:www.kornshell.com
1.2.2 Livres
The New KornShell Command and Programming Language
( Morris Bolksy & David Korn , Prentice Hall, 1995 )
Learning the KornShell
( Bill Rosenblatt , O’Reilly & Associates, 1993 )
Korn Shell Programming Tutorial ( Barry Rosenberg ,
Addison-Wesley, 1991 )
Langages de scripts sous Linux ( Blaess, Eyrolles, 12/2001 )
Unix nieme ed JM Rifflet

5
Chapitre 2
Notions de base en shell
Objectifs
Rappels sur l’entrée en session
Fichiers de démarrage

6 Chapitre 2 Notions de base en shell
2.1 Rappel sur l’entrée en session

Entrée en session
Mode commande
Interface Graphique : CDE, Gnome, KDE

Chapitre 2 Notions de base en shell 7
2.2 Étude des différents fichiers de

démarrage
Fichiers de démarrage
Entrée en session
Démarrage d’un nouveau processus
Fin de session
Une connexion consiste en un processus correspondant à l’exécution d’un

shell. Ce shell est celui choisi par l’administrateur lors de la création du
compte.
Ce shell est à la fois un interpréteur de commandes et un langage de
programmation permettant l’écriture de procédures utilitaires et
constituant un des outils de travail de l’administrateur.
Les shells essentiels du monde UNIX sont, dans l’ordre chronologique :
Bourne-shell
C-shell
Korn-shell
Posix Shell ( version normalisée du Korn-Shell retenue par
l’organisme X/Open )
Bash ( pour Bourne Again Shell : le shell de Linux )
tcsh
Z-shell
Dans la suite, les références au shell sont celles des environnements

Korn-shell bien standardisés aujourd’hui.

2.3 Variables et environnement
La notion de variable concerne surtout l’aspect programmation. Cependant,

il existe un certain nombre de variables système prédéfinies ayant un rôle
important vis à vis de l’utilisateur interactif.
Une variable shell contient une chaı̂ne de caractères quelconque. Son nom
peut être constitué de lettres, de chiffres et du caractère ( souligné ) , il ne
peut pas commencer par un chiffre ( conventions des identificateurs du
langage C ).
Le caractère = ( signe égal ) est le symbole d’affectation de variable. Le
caractère permet de désigner la valeur d’une variable.
La commande unset permet d’annuler la définition d’une variable.
$ mavariable=ambre $ echo $mavariable

beijaflore
$ unset mavariable
$ echo $mavariable
2.4 Notion d’environnement : instruction

export
L’environnement shell ( variables exportées ) est constitué de l’ensemble des

variables qui sont transmises à un processus ”fils” par le mécanisme de
”fork”.
Une variable non exportée n’est pas connue dans le processus fils.
Les modifications, dans les processus fils, des variables exportées s’opèrent
sur des copies locales et n’altèrent donc en rien les valeurs des variables
dans le processus ”parent”.
2.4.1 Afficher la liste de toutes les variables, celles de

l’environnement et celles qui ne s’y trouvent pas
$ set |more
LANG=C
PATH=/usr/bin :/usr/bin/X11
EDITOR=/usr/bin/vi
...

2.4.2 Afficher la liste des variables de l’environnement
$ env |more
LANG=C
PATH=/usr/bin :/usr/bin/X11
EDITOR=/usr/bin/vi LOGNAME=stage1
MAIL=/var/mail/stage1
SHELL=/usr/bin/ksh
TIMEOUT=0
HOME=/home/stage1
...
TERM=vt100
PWD=/home/stage1
TZ= :CEST
...
Placer une variable dans l’environnement
$ variable=valeur
$ export variable
$ env
...
$ variable=valeur
Note : Avec le ksh la syntaxe directe export variable=valeur est

possible.
2.5 Quelques variables système
Certaines variables ont un rôle plus ou moins important pour l’utilisateur

du shell. Ces variables système peuvent avoir une valeur par défaut ou être
initialisées à diverses étapes de la procédure de connexion. A ce niveau,
l’administrateur doit décharger au maximum le travail de l’utilisateur.

Variable Description
PATH Liste des noms de répertoires dans lesquels le système cherche
les commandes
PS1 Prompt principal ( par défaut )
PS2 Prompt secondaire ( >par défaut )
Le prompt secondaire apparaı̂t si la commande doit se
continuer sur la ligne suivante
TERM Type du terminal ( émulation )
Une bonne valeur est nécessaire notamment au bon
fonctionnement de vi
EDITOR Editeur indirect utilisé par certains utilitaires nécessitant une
édition
HOME Nom complet du répertoire de connexion
LOGNAME Nom de connexion
PWD† Nom du répertoire courant
Cette variable est tenue à jour par la commande cd
OLDPWD† Nom du répertoire courant précédent
( On peut utiliser la commande cd - pour y retourner )
PPID† Valeur du PID du processus père
TMOUT † Nombre de secondes d’inactivité, sous le prompt du shell,
avant déconnexion
( TMOUT=0 - pas de déconnexion )
( : Variables spécifiques au Korn-shell )
Autres variables utiles gérées par le shell
Variable Description
$ PID du shell interpréteur
! PID du dernier fils lancé en arrière-plan
? Code de retour de la dernière commande appelée
2.5.1 Exemples d’utilisation

Avoir comme prompt principal le nom du répertoire courant
$ PS1=’$PWD $ ’
/home/stage1 $ cd ..
/home $ cd
Redéfinir le prompt secondaire
$ PS2=’suite : ’
echo "bonjour cher
suite : ami"
bonjour cher
ami

Gérer le PATH et le mettre à jour si besoin

$ echo $PATH
/usr/bin :/usr/bin/X11
$ mount
ksh : mount : not found
$ /usr/sbin/mount
/ on /dev/root read/write/setuid on Nov 25 16 :03 :29
/stand on /dev/dsk/c0t0d0sa read/write on Nov 25 16 :03 :30
/home on /dev/dsk/c0t0d0s4 read/write/setuid on Nov 25
16 :03 :43
...
$ PATH=$PATH :/usr/sbin
$ echo $PATH
/usr/bin :/usr/bin/X11 :/usr/sbin
$ mount
/ on /dev/root read/write/setuid on Nov 25 16 :03 :29
/stand on /dev/dsk/c0t0d0sa read/write on Nov 25 16 :03 :30
/home on /dev/dsk/c0t0d0s4 read/write/setuid on Nov 25
16 :03 :43
...
Annuler la définition de la variable TERM

$ unset TERM
$ vi
Visual needs addressable cursor or upline capability
:q
$ TERM=bidon ; export TERM
$ vi
bidon : Unknown terminal type
Visual needs addressable cursor or upline capability
:q
$ TERM=vt100
$ export TERM
2.6 Compléments sur les variables

On sait que la valeur d’une variable est donnée par le symbole . Des
notations complémentaires sont disponibles pour permettre de lever des
ambigutés syntaxiques, et récupérer la taille des variables.
${var} Permet d’opérer correctement des concaténations
$ nom=ambre
$ var=systems
$ echo $nom $var
systems
$ echo ${nom} $var
ambre systems

${#var} Longueur d’une variable

$ echo $HOME
/home/stage1
$ echo ${#HOME}
12
2.7 Caractères spéciaux

Une des premières fonctions du shell est d’interpréter un certain nombre de
caractères avant l’appel des commandes. Il est à noter que les commandes
Unix ne traitent pas les caractères spéciaux. Elles héritent d’une liste de
paramètres déjà résolue et ne se préoccupent pas de mécanismes comme les
redirections ou le ”pipeline”. Ce principe de base favorise grandement
l’activité de programmation et s’inscrit parfaitement dans la démarche
”boı̂te à outils” modulaire voulue par les concepteurs du système.
Rappel des caractères déjà évoqués

Caractère Description
< Redirection de l’entrée standard
>et >> Redirections de la sortie standard
2<et 2<< Redirections de l’erreur standard
; Processus séquentiels
| Mécanisme du ”pipeline”
& Mode arrière-plan
() Grouper des commandes
= Affectation de variable
Contenu d’une variable
Expressions génériques simples

* N’importe quelle chaı̂ne dans un nom de fichier
Utilisé seul, signifie : ”Tous les fichiers du
répertoire courant”
( Ne sélectionne pas les fichiers commenant par . (
point ) )
? Présence d’un caractère quelconque dans un nom
de fichier
[ensemble de caractères]
Présence d’un caractère de l’ensemble
[ !ensemble de caractères]
Présence d’un caractère ne figurant pas dans
l’ensemble
Exemple :
$ touch fic1 fic2 essai99 fic.txt exemple
$ echo *
fic1 fic2 essai99 fic.txt exemple

$
$ .[ !.]*
.profile
.sh history
2.7.1 Expressions génériques composées du

Korn-shell
En complément aux expressions génériques simples (ci-dessus) largement
utilisées, les notations suivantes existent en Korn-shell :
*(expr1 Un nombre quelconque d’apparitions d’une des
|expr2 |...) expressions
( éventuellement aucune )
Un nombre quelconque d’apparitions d’une des
+(expr1|expr2|...)
expressions
( au moins une )
Au plus une apparition d’une des expressions
?(expr1|expr2|...)
Exactement une des expressions
@(expr1|expr2|...)
Aucune des expressions
!(expr1|expr2|...)
Exemples :
*([A-Z]|[0-9]) Chaı̂ne dont chaque élément est soit une majuscule
soit un chiffre OU chaı̂ne vide
+([A-Z]|[0-9]) Chaı̂ne dont chaque élément est soit une majuscule
soit un chiffre (chaı̂ne vide exclue)
([A-Z]|[0-9]) Chaı̂ne vide ou d’un élément qui est soit une
majuscule soit un chiffre
@([A-Z]|[0-9]) Chaı̂ne d’un élément qui est soit une majuscule
soit un chiffre
!([A-Z]|[0-9]) Chaı̂ne ne comportant ni majuscule ni chiffre
2.7.2 Substitutions de commandes

‘commande‘ Le résultat de la commande est inséré dans la liste
d’arguments
(commande) Syntaxe spécifique au ksh
$ rep=‘pwd‘
$ echo "Repertoire courant : $rep"
Repertoire courant : /home/stage1
$ echo " Il est $(date +%H :%M :%S)"

Il est 15 :47 :47

2.7.3 Caractères de protections

Le caractère qui suit perd son rôle fonctionnel
’’ Tous les caractères situés entre les simples quotes
perdent leur rôle fonctionnel
”” Tous les caractères situés entre les doubles quotes
perdent leur rôle fonctionnel sauf :
Valeur de variable
‘commande‘ Résultat de commande
Possibilité de
banaliser et ‘
Afficher ou non le caractère *

$ echo *
fic1 fic2 essai99 fic.txt
$ echo
Annuler ou non la substitution de commandes

$ echo "La date est ‘date‘"
La date est Mon Jan 03 15 :58 :39 GMT 2000
$ echo ’La date est ‘date‘’
La date est ‘date‘
2.7.4 Procédures et paramètres

Des séquences de commandes et d’instructions shell peuvent être regroupées
dans un fichier qui devient ainsi une nouvelle commande ou ”procédure” ou
”script” .
2.8 Structure et exécution d’un script shell

Un script shell peut contenir de manière générale :
Un ligne de désignation de l’interpréteur ;

des commandes UNIX, des commandes internes shell ;
des structures de contrôle (instructions conditionnelles, boucles,
aiguillages, etc...) ;
des commentaires.

L’exécution est demandée de manière implicite en appelant le nom du

script :
$ vi prog.ksh
....
$ chmod +x prog.ksh
$ prog.ksh
2.9 Commentaire et shell interpréteur d’un

script
Le caractère # introduit un commentaire jusqu’à la fin de la ligne en cours.
Par défaut, le script est interprété par un shell fils du shell de connexion et
ne reoit que les variables de l’environnement validées grce à l’instruction
export .
La première ligne du script est importante car elle permet d’indiquer
l’interpréteur choisi pour l’exécuter. Si cette ligne est omise, le shell
interpréteur choisi sera par défaut le même que le shell interactif d’o est
lancé l’exécution. Il est recommandé de toujours faire apparaı̂tre
explicitement cette désignation de l’interpréteur.
2.10 Code retour et traitement associé

Les scripts peuvent retourner un code retour via l’ instruction de sortie exit
n . La tradition est de retourner 0 en cas de succès et une valeur dans
l’intervalle [ 1 , 255 ] sinon.
Sortir du script en retournant la valeur 3
$ cat prog.ksh
# !/usr/bin/ksh
...
exit 3
...
2.11 Interprétation d’une ligne de

commande
Le shell interprète chaque ligne d’un script suivant un ordre donné :
Substitutions de variables,
Substitutions de commandes,
Traitement des redirections et tubes ,
Traitement des caractères spéciaux sur les noms de fichiers ,
Appel de la commande ( via ”fork” ) ou de l’instruction .

2.12 Paramètres du script

Il est possible de fournir de l’information au script lors de son exécution en
utilisant des paramètres (ou arguments) sur la ligne de commande. Les
valeurs saisies (chaı̂nes de caractères) sont automatiquement mises dans les
variables système 1, 2, 3, 4,... Les variables complémentaires # et *
contiennent alors respectivement le nombre de paramètres saisis et la liste
concaténée de tous les paramètres.
Premier Exemple de procédure élémentaire gérant les paramètres de la ligne
de commandes
$ cat prog.ksh
# !/usr/bin/ksh
echo "Premier argument : $1"
echo "Nombre d’arguments : $#"
echo "Liste des arguments : $*"
Résultat d’une exécution
$ prog.ksh un deux quatre
Premier argument : un
Nombre d’arguments : 3
Liste des arguments : un deux quatre
Deuxième Exemple de procédure élémentaire affichant la taille en octets du
fichier passé en premier argument, et retournant le code 3 d’erreur sinon.
$ cat prog.ksh
# !/usr/bin/ksh
echo "Taille du fichier : $(wc -c $1)"
exit 3
Résultat d’une exécution lorsque le fichier exemple existe
$ prog.ksh exemple
Taille du fichier : 1242 exemple
e-center> echo $ ?
3

17
Chapitre 3
Programmation shell
Objectifs
xxx

18 Chapitre 3 Programmation shell
3.1 Instructions conditionnelles et tests

Gestion des mots de passe
Historique des mots de passe
/etc/security/passhistory
Critères de sélection plus stricts
3.1.1 L’instruction if
Syntaxe if commande then liste de commandes fi
ou if commande ; then liste de commandes fi
ou
if commande then liste de commandes else liste de commandes fi
Note : Il est possible de placer plusieurs commandes après le ”if” . Dans ce
cas, le test prend en compte le code retour de la dernière de ces commandes.
Exemples simples de syntaxe

if who | grep stage1 > /dev/null ; then
echo ?stage1 est connecte?
fi
if date ; who | grep root > /dev/null

then
echo "root est connecte"
else
echo "root nest pas connecte"
fi
3.1.2 Instructions conditionnelles composées : if

imbriqués
Syntaxe
if commande then liste de commandes else if commande then
liste de commandes else if commande then liste de commandes .... .... else
Ce ”else” est bien sr facultatif liste de commandes fi fi fi

Chapitre 3 Programmation shell 19
Attention ! Lutilisation de la syntaxe en deux mots : else if nécessite

autant de fi que de if.
Autre forme ( elif ) ( ne nécessite qu’un seul ”fi” )

if commande then liste de commandes elif commande then
liste de commandes elif commande then liste de commandes .... .... else Ce
”else” est bien sr facultatif liste de commandes fi
3.1.3 Instructions conditionnelles compactes :

opérateurs && et ||
Ces notations exploitent le code retour. Elles permettent de faire des
instructions conditionnelles sur une ligne.
cde1 && cde2 Lancer la deuxième commande si la première a réussi ( exit
0 ).
cde1 ||cde2 Lancer la deuxième commande si la première a échoué ( exit
avec code retour != 0 ).
$ ? Code retour de la dernière commande appelée.
Exemples
$ ( who |grep stage1 ) ||echo "stage1 non connecte"
stage1 non connecte
$ ls exemple >/dev/null 2>&1 && lp exemple
3.1.4 La commande test

Cette commande évalue une expression booléenne et retourne la valeur 0 si
cette expression est vraie. Il sagit donc dune commande assez indispensable
pour réaliser certains tests via les instructions du shell.
test expression ou [ expression ] ( Les crochets doivent être délimités par
des espaces )
Quelques expressions possibles
chaine1 = chaine2 Les deux chaı̂nes sont identiques chaine1 != chaine2 Les
deux chaı̂nes sont différentes
-z chaı̂ne La chaı̂ne est de longueur nulle -n chaı̂ne La chaı̂ne est de
longueur non nulle
entier1 -eq entier2 Les deux entiers sont égaux Autres opérateurs ”entiers”
-ne -gt -ge -lt -le
-r fichier Droit de lecture sur ”fichier” -w fichier Droit décriture sur ”fichier”
-x fichier Droit dexécution sur ”fichier” -u fichier Le bit SUID est positionné
-g fichier Le bit SGID est positionné -k fichier Le ”sticky bit” est positionné
-f fichier Il sagit dun fichier ordinaire -d fichier Il sagit dun répertoire -c
fichier Il sagit dun fichier spécial de type caractère -b fichier Il sagit dun
fichier spécial de type bloc -L fichier Il sagit dun lien symbolique
-s fichier Le fichier est de taille non nulle
! Négation -o OU -a ET ( plus prioritaire que le OU )
Exemples simples de syntaxe
if test # -eq 0 ; then echo ”Usage : 0 argument” ; exit 1 fi

if test -f $1
then
echo "$1 est un fichier ordinaire"
elif [ -d $1 ]
then
echo "$1 est un repertoire"
elif [ -L $1 ]
then
echo "$1 est un lien symbolique"
else
echo "Ni fichier ordinaire, ni repertoire, ni lien symbolique"
fi
if test -f $1 -a -x $1
then
echo "$1 est un fichier ordinaire et executable"
fi
midi=12
heure=‘date ’+%H’‘
if test $heure -ge $midi

then
echo "Il est plus de midi"
else
echo "Il n’est pas encore midi"
fi
if [ ! -d $1 -a ! -L $1 ] ; then
echo "$1 ressemble a un fichier ordinaire"
fi
3.1.5 Enrichissement de la commande test du

Korn-Shell
Le ksh introduit quelques nouvelles expressions disponibles :
-a fichier Le fichier existe ? -O fichier On est propriétaire du fichier ? -G
fichier On fait partie du groupe propriétaire du fichier ? fic1 -nt fic2 Le
premier fichier est plus récent que le deuxième fichier ? fic1 -ot fic2 Le
premier fichier est plus ancien que le deuxième fichier ? fic1 -ef fic2 Il s’agit
de deux liens sur le même fichier physique ?
Exemple :
if [ $1 -ot $2 -a $3 -ef $2 ]
then
echo "$1 est plus ancien que $2"
echo "$2 et $3 sont deux liens sur le meme fichier"
fi
Nouvelle syntaxe possible en ksh

[[ expression ]]
L’intérêt essentiel de cette nouvelle syntaxe est la possibilité d’utiliser des
expressions génériques (simples ou composées). L’analyse sémantique de
chaı̂nes de caractères sera désormais possible dans l’instruction de test.
Par ailleurs les opérateurs logiques ET et OU sont remplacés par :
||OU ( remplace lopérateur o ) && ET plus prioritaire que le OU (
remplace lopérateur a )
Exemple de syntaxe

#! /usr/bin/ksh
if [[$option = @(+|-)+([a-z]) && $var = ?(+|-)+([0-9]) ]]

then
...
fi
3.2 Traitement sur flux : les boucles

3.2.1 La boucle for
Cette boucle permet dexécuter plusieurs fois une liste de commandes. A
chaque pas de boucle, la variable choisie comme indice prend une valeur
dans une liste donnée.
for variable in liste de valeurs do liste de commandes done
Quelques exemples
1) Boucler sur tous les paramètres de la procédure
for i in $*
do
liste\_de\_commandes
done
Note : La première ligne de cette boucle peut sabréger en for i
2) Boucler sur tous les noms de fichiers du répertoire courant

f
or i in *
do
done
3) Faire cinq fois un traitement

for i in 1 2 3 4 5
do
done
3.2.2 Les boucles while et until

La boucle while permet dexécuter une liste de commandes tant quune
condition est réalisée. La boucle until permet dexécuter une liste de
commandes jusqu’à ce quune condition soit réalisée.
while condition réalisée do liste de commandes done
ou
until condition réalisée do liste de commandes done
Exemple de syntaxe
who | grep $1 > /dev/null
while [ $? -eq 0 ]
do
echo "$1 est connecte"
sleep 15
who | grep $1 > /dev/null
done
echo "$1 n’est pas ou n’est plus connecte"

subsectionInstructions de branchement
Il est possible d’utiliser des instructions de branchement pour sortir
brutalement des boucles ou pour sauter les instructions restantes du corps
de boucle :
break [ n ] Quitter brutalement une boucle. L’éventuel paramètre n permet
de quitter n niveaux de boucles imbriquées.
continue [ n ] Retourner au test ( while et until ) , passer à la valeur
suivante ( for ). ( éventuellement pour n niveaux )
Exemples :
Ne pas faire la deuxième partie du traitement pour la 5ème itération de la
boucle :
while [ $i -lt 100 ]

do
...
if [ $i = 5 ] ; then
continue
fi
...
done
Quitter la 2ème boucle imbriquée au premier répertoire trouvé :

while true
do
...
for f in *.txt
do
if [[ -d $f ]]
then
break 2
fi
...
done
done
3.3 Lectures au clavier : read

read liste de variables
Cette commande lit une ligne au clavier.
#!/usr/bin/ksh
echo "Entrez la valeur : \c"
read var
Dans le cas o la commande read a plusieurs variables en arguments, la ligne

lue au clavier est ”découpée” en champs. Le séparateur par défaut en
lecture est : espace ou tabulation.
#!/usr/bin/ksh
echo "Entrez les valeurs : \c"
read i j k
echo "valeur de i : $i"
echo "valeur de j : $j"
echo "valeur de k : $k"

Exécution :
$ prog.ksh
Entrez les valeurs : 12 4 143 (saisie clavier)
valeur de i : 12
valeur de j : 4
valeur de k : 143
Note : Dans la commande ”test” notamment, il est important de gérer la

possible lecture vide en utilisant judicieusement les doubles quotes ou via
un test préalable. Il convient en effet de toujours fournir le nombre
darguments attendus à cette commande.
3.3.1 Nouvelles possibilités en Korn-shell

On peut poser une question et lire la réponse en une seule instruction.
read reponse ?"Voici la question ? "
équivaut à
echo "Voici la question ?
c" ; read reponse
3.4 Expressions arithmétiques

3.4.1 La commande expr (Bourne shell)
La commande expr permet dinterpréter des variables shell comme des
entiers dans le cadre dune expression numérique. Le résultat de cette
évaluation peut être stockée dans une variable résultat via l’opérateur de
substitution de commande.
Les opérateurs disponibles sont : + - * / ( division entière ) % ( modulo )
while [ $n -lt 100 ]
do
<traitement>
n=‘expr $n + 1‘
done
a=5 ; b=11
mult=‘expr $a \* $b‘
div=‘expr $a / $b‘
3.4.2 Expressions arithmétiques Korn shell

Le Korn-Shell possède une commande interne qui permet d’évaluer des
expressions arithmétiques. Les opérateurs utilisables sont proches de ceux
du langage C.
Syntaxe
let expression ou (( expression ))
Exemples de syntaxe
x=10 let x=x+1 On ne doit pas utiliser d’espaces avec la commande let

x=3 (( x = x * 2 )) Les doubles parenthèses permettent de mettre des

espaces
x=3 (( x=(x-2)*3 )) Les parenthèses modifient les priorités des opérateurs
3.4.3 Possibilités complémentaires

let et (( )) peuvent être utilisées directement dans un test, afin d’effectuer
des comparaisons numériques. Il faut alors utiliser les notations <, <=, >,
>= (issues du langage C).
while (( i < 100 ))
do
...
done
integer peut être utilisée pour déclarer des variables comme des entiers ;
cela permet de btir une expression ”entière” directement :
integer i=0 i=i+1
Note : integer est un alias de la commande typeset i revue plus tard dans
le support.
3.5 Branchements
3.5.1 Instruction case
case valeur in
motif1) liste_de_commandes
;;
motif2) liste_de_commandes
;;
.......
esac
Les différents motifs sont examinés dans l’ordre. Si un des motifs

correspond à la valeur de test, la liste de commandes correspondante est
exécutée et il y a ensuite sortie de l’instruction.
Les motifs peuvent contenir des expressions génériques simples ou
composées.
On peut citer notamment :
Le caractère |peut être utilisé pour réaliser un OU .
Le motif * peut être utilisé comme dernier motif et jouer ainsi le rôle de
”cas par défaut”.
Exemple simple de syntaxe
#! /usr/bin/sh
case $# in
1|2) echo "On a recu 1 ou 2 arguments"
echo "on enchaine apres l’aiguillage"
;;
3) echo "On a recu 3 arguments"
echo "on enchaine apres l’aiguillage"

;;
*) echo "Mauvais appel, il faut 1 ou 2 ou 3 arguments"
exit 1
;;
esac
echo "Suite du traitement"
3.5.2 Instruction select du Korn-Shell

Cette instruction est proposée pour programmer des menus.
Elle se comporte comme une boucle et enchaı̂ne les opérations suivantes :
Affichage d’une suite de libellés numérotés automatiquement,

Affichage de la variable système PS3,
Lecture clavier du choix de l’utilisateur,
La valeur d’index est positionnée avec le libellé correspondant au
choix et la variable système REPLY contient le numéro
correspondant. En cas de choix impossible, la valeur dindex contient
la chaı̂ne vide. En cas de réponse vide, le menu est réaffiché.
select variable in liste de libellés do Aiguillage sur variable ou REPLY

done
Exemple de syntaxe
PS3="Tapez votre choix : "
select i in "Liste" "Ajout" "Modification" "Sortie"

do
case $REPLY in
1|2|3) echo $i
;;
4) echo $i
exit 0
;;
*) echo "Choix impossible"
;;
esac
done
Résultat d’une exécution :

$ menu.ksh
1) Liste
2) Ajout
3) Modification
4) Sortie
Entrez votre choix : 1
Liste
Modification
Entrez votre choix : (Saisie vide)
1) Liste
2) Ajout
3) Modification
4) Sortie


Choix impossible
Sortie
$
3.6 Fonctionnalités complémentaires

3.6.1 Tableaux du Korn-Shell
Le Korn-shell permet la manipulation de tableaux unidimensionnels. Un
tableau est vu par le shell comme un empilement de variables classiques
(chaı̂nes de caractères ASCII) manipulées avec une convention de
nommage. Il n’y a aucune réservation préalable en mémoire. Lindice 0
désigne le premier élément du tableau.
Affectation globale par initialisation dun tableau ( si le tableau existe
déjà, il est réinitialisé )
$ set -A tab valeur1 valeur2 valeur3
Désignation des éléments
$ echo ${tab[2]} Le troisième élément valeur3 (les indices commencent
à zéro)
$ echo $tab Le premier élément. tab ou {tab[0]} sont valeur1 deux
autres notations pour le premier élément
$ echo ${tab[*]} Tous les éléments valeur2 valeur 3
Affectation d’un élément
$ tab[0]=premier
$ echo ${tab[*]}
premier valeur2 valeur3
Nombre d’éléments
$ echo $#tab[*]
3
Conformément à sa structure d’empilement de variables, on peut affecter
n’importe quel élément (éventuellement hors de la plage de départ). Dans
ce dernier cas, tous les éléments d’indice intermédiaire n’existent pas, ils ne
sont donc pas comptés dans le nombre d’éléments du tableau.
$ tab[100]=dernier
$ echo ${tab[*]}
premier valeur2 valeur3 dernier
$ echo ${#tab[*]}
4
3.6.2 Redirections particulières de lentrée standard :

Script en ligne
<<mot ”mot” marquera la fin de lentrée standard, les caractères spéciaux
éventuels y seront interprétés.

<<\mot ”mot” marquera la fin de lentrée standard, les caractères spéciaux

éventuels ne seront pas interprétés.
Exemples
1) Afficher au terminal du texte et réaliser les expansions de variable et
commandes si besoin
#! /usr/bin/sh
cat << fin
Ceci est l’entree standard de la commande
Type du terminal = $TERM
Il est $(date +%H:%M )
fin
Résultat dune exécution

Ceci est l’entree standard de la commande Type du terminal = vt100 Il est
10 :05
2) Afficher au terminal du texte et NE PAS réaliser les expansions de
variables, ni commandes
#!/usr/bin/sh
cat << \fin
Ceci est l’entree standard de la commande
Type du terminal = $TERM
Il est $(date +%H:%M )
fin
Résultat dune exécution

Ceci est l’entree standard de la commande Type du terminal =
T ERMIlest(date +
3) Envoyer un mail depuis un script
$ cat prog.ksh
#!/usr/bin/ksh
mail $1 -s test << FIN
Ce mail vous est envoy\’e automatiquement par $0 a $(date)
Excellente journ\’ee \‘a vous !
FIN
Exemple dune exécution

e-center¿ prog.ksh foo.bar@beijaflore.com e-center¿
3.6.3 Gestion des Entrées / Sorties : Compléments

A lintérieur dun script, la commande exec permet douvrir des fichiers en
leur associant des descripteurs. Les numéros 0 , 1 et 2 sont déjà attribués
aux fichiers standards ( entrée, sortie, erreur ).
On peut, par exemple, utiliser les notations suivantes :
exec n<fichier Ouverture dun fichier en lecture ( descripteur n ) exec
n>fichier Ouverture dun fichier en écriture ( descripteur n )
Par la suite, une utilisation des redirections Unix en mentionnant le numéro
de descripteur permet de lire ( <&n ), notamment avec read, ou décrire (
>&n ) , notamment avec echo dans les fichiers correspondants. C’est en

particulier le seul moyen propre de lire un fichier texte ligne à ligne dans un
script.
On dispose également des notations <&- et >&- pour fermer les
descripteurs :
exec <&- Fermeture du descripteur de fichier n exec >&- Fermeture du
descripteur de fichier n
Exemple de syntaxe
#! /usr/bin/sh
#Ouverture du 1er fichier en lecture
exec 3< fic1
#Ouverture du 2eme fichier en ecriture
exec 4> fic2
#Lecture ligne par ligne depuis le 1er fichier
while read <&3 ligne
do
#Ecriture sur la sortie standard
echo $ligne
echo "Copier(o/n - lecture vide pour sortir)? \c"
#Lecture depuis lent\’ee standard
read rep
if test -z "$rep
then
break
fi
if test "$rep" = o
then
#Ecriture dans le 2eme fichier
echo $ligne >&4
fi
done
Exemple de syntaxe dans le cas particulier des commandes internes

read/print du Korn-Shell :
Les commandes read et print sont intégrées au Korn-Shell et possèdent une
option u permettant de préciser le descripteur à traiter.
#!/usr/bin/ksh
#Ouverture du 1er fichier en lecture
exec 3< fic1
#Ouverture du 2eme fichier en ecriture
exec 4> fic2
#Lecture ligne par ligne depuis le 1er fichier
while read -u3 ligne
do
#Ecriture sur la sortie standard
print $ligne
print "Copier(o/n - lecture vide pour sortir)? \c"
#Lecture depuis lent\’ee standard
read rep
if test -z "$rep"
then
break
fi
if test "$rep" = o
then
#Ecriture dans le 2eme fichier
print -u4 $ligne
fi
done

3.6.4 La variable IFS

La variable système IFS indique quel est le séparateur de champs lors des
lectures ( read ) et des résultats de substitutions de commande ou de
paramètres. Sa valeur par défaut est : Espace, Tabulation et Interligne.
Exemple
IFS=:
for i in $PATH
do
echo $i
done
Note : Le shell utilise aussi cette variable lors de l’évaluation de la ligne de

commande : le caractère défini par IFS est remplacé par un blanc avant le
lancement de la commande. En particulier, la commande echo IFS n’est
pas un bon moyen de connaı̂tre la valeur de IFS !
3.6.5 L’opérateur shift

Il permet de parcourir la liste des paramètres en renommant ceux-ci à
partir du deuxième. ( 1 disparaı̂t, 2 devient 1, 3 devient 2 etc... )
Bien entendu, le nombre de paramètres # est décrémenté et la liste * est
mise à jour.
En Bourne-shell, on ne peut désigner que 9 paramètres à la fois, la notation
10 nexiste pas.
En Korn-shell, cette limitation est levée via des notations telles que {10} .
Concrètement, lopérateur shift peut servir dans les commandes à options
pour se positionner, après traitement syntaxique de ces dites options, au
début de la liste des véritables arguments.
Note : Il est possible de décaler plusieurs arguments à la fois : shift n
Exemple :
#!/usr/bin/sh
# Exemples d’utilisation de shift pour afficher le premier
# argument et le dernier
echo "premier : $1 "

shift $#-1
echo "dernier : $1 "
3.6.6 L’opérateur set

Cet opérateur présente de multiples facettes à usages plus ou moins
fréquents.
Les possibilités les plus utiles sont les suivantes :
- Sans arguments, il donne la liste de toutes les variables définies.
- Avec des arguments, l’opérateur permet de repositionner un nouvel
ensemble de paramètres ( 1 , 2 ... ).
Exemple

e-center> set un deux trois

e-center> echo $*
un deux trois
e-center> who -r
. run-level 2 Jun 21 14:10 2 0 S
e-center> set ‘who -r‘
e-center> echo $5 $4 $6
21 Jun 14:10
Note : Avec deux signes –, lopérateur set permet, en une seule commande,
de libérer tous les paramètres de position
e-center> set --
e-center> echo $*
ksh: *: parameter not set
e-center>
- Avec des options, il permet différents paramétrages du shell. Les options

peuvent être abrégées ( voir détail ci-dessous ).
set o option Active loption set +o option Désactive loption set o Affiche les
options et leur état respectif
Quelques options possibles :
allexport ( -a ) Exportation systématique de toute variable du shell errexit
( -e ) Sortie du shell sur toute erreur ignoreeof Sortie du shell par exit ( pas
de ”Ctrl-d” ) monitor Avertissement lors de fin de tche noclobber Pas
décrasement via les redirections ( on doit forcer par >|) noexec ( -n )
Analyse mais nexécute pas ( pour chercher des erreurs de syntaxe ) noglob
( -f ) Pas de traitement des caractères spéciaux nounset ( -u ) Génération
dune erreur sur tentative daccès à une variable non existante verbose ( -v )
Mode trace ( pour chercher les erreurs ) vi Mode de rappel et édition de
commandes avec vi xtrace ( -x ) Autre mode trace sans expansion des
variables etc... Exemples
e-center> set -o
Current option settings
...
noclobber off
...
e-center> set -o noclobber
e-center> set -o
...
noclobber on
...
e-center> ls la / > liste
e-center> ls ial /usr > liste
ksh: /tmp/liste: file already exists
e-center> ls ial /usr >| liste
e-center> set +o noclobber
e-center> set -o
...
noclobber off
...
e-center>

3.6.7 Gestion des signaux

Exécuter une action lorsque se produit un certain événement.
Syntaxe
trap action événement
action - Liste de commandes - Commande vide ” ( pour ignorer un
événement ) - Le signe - ( moins ou action non mentionnée ) rétablit le
comportement par défaut
événement - Nom ou numéro dun signal 2 ( INTR ) Interruption clavier 3 (
QUIT ) Interruption clavier ( Ctrl \) générant un fichier ”core” 15 ( TERM
) Commande : ”kill PID” 0 ou EXIT Déconnexion ( fin du shell ) ERR
Erreur retournée par une commande
Exemples
fictemp=/tmp/fic$$
trap ’rm -f $fictemp ; exit 1 INTR
trap 2 3
trap - 2 3
trap $HOME/.logout EXIT
3.6.8 Autres commandes internes

: ( deux points ) Commande vide retournant toujours 0 ( permet
notamment de constituer des boucles infinies )
while : do ... done
typeset Affecter des attributs à des variables
-u Transformation des minuscules en MAJUSCULES -l Transformation des
MAJUSCULES en minuscules -r Lecture seulement ( variable non
modifiable ) -i Type entier ( integer est un alias sur typeset -i ) etc...
e-center> typeset -u var=abcd
e-center> echo $var
ABCD
e-center>
print et printf La commande ”print” veut mettre fin aux diverses variantes
de la commande echo Elle accepte les caractères conventionnels suivants :
\a Signal sonore \n Saut de ligne \b Retour arrière \r Retour chariot \c
Pas de saut de ligne \t Tabulation \f Effacement d’écran ou saut de page
\v Tabulation verticale
print intégrée au Korn-Shell possède une option u permettant de préciser le
descripteur à traiter. L’option -u2 permet d’écrire sur l’erreur standard :
e-center> print -u2 "Ceci est un message d’erreur"
Ceci est un message d’erreur
e-center>
La commande ”printf” est très similaire à la fonction de même nom du

langage C et permet de réaliser des sorties formatées.

eval Le shell étend les arguments de ”eval” en les séparant par un espace
puis traite la chaı̂ne résultat comme une commande. Cette double
évaluation est utile lorsque les arguments de ”eval” contiennent des
symboles de redirection ou des substitutions de variables
Quelques exemples
e-center> var=toto ; toto=100
e-center> print \$$var
$toto
e-center> eval print \$$var
100
e-center> cat essai

#!/usr/bin/sh
print "Le dernier argument est \$$#"
eval print "Le dernier argument est \$$#"
Lancement de la procédure essai :

e-center> essai a b c d
Le dernier argument est $4
Le dernier argument est d
e-center>
Créer une variable uid avec la valeur de lUID du login en cours :

e-center> id
uid=2001(ecole1) gid=2000(ecole)
e-center> eval ‘id | cut d’(’ f1‘
e-center> echo $uid
2001
whence [ -v ] commande La commande whence trouve le chemin daccès à la

commande. Avec loption v, la commande whence signale sil sagit dun alias
ou dune commande interne.
Exemples
e-center> whence ps
/usr/bin/ps
e-center> whence -v ps
ps is /usr/bin/ps
e-center>
e-center> whence echo

echo
e-center> whence -v echo
echo is a shell builtin
e-center>
e-center> whence l
/usr/bin/ls -al
e-center> whence -v l
l is an alias for /usr/bin/ls -al
e-center>

wait [ n | \%n ] Attendre la fin dun processus lanc\’e en arri\‘ere-plan

Le nombre n indique le PID du processus concern\’e, \%n le num\’ero de job
Sans arguments, wait attend la fin de tous les processus descendants
Exemple
Attendre la fin du processus de PID 11902
{\scriptsize{\begin{verbatim}
e-center> sleep 20 &
[1] 11902
e-center> wait 11902
e-center>
Attendre la fin du premier processus lancé en arrière plan : job

[1] 11904
[2] 11905
e-center> wait %1
3.7 Fonctions
3.7.1 Principe et propriétés
Une fonction est un sous-programme qui peut être appelé de la même
manière quun commande depuis le programme principal.
Syntaxe function nom { ......... }
NB : L ”ancienne syntaxe” compatible Bourne-shell est aussi disponible :
nom ( ) { .......... }
Pour pouvoir être appelée par un script, une fonction doit être disponible
dans le shell interpréteur du script. Pour cela, le moyen le plus simple
consiste à écrire la fonction dans le même fichier que le programme
appelant. Nous verrons par la suite des solutions permettant de partager
des fonctions entre programmes.
Les fonctions peuvent :
- Recevoir des arguments ( qui seront traités comme des paramètres de
position ) , - Modifier un argument re¸cu, - Retourner une valeur via
linstruction ”return n” ( qui positionnera ? à la valeur de n ) , - Utiliser
des variables locales définies via linstruction ”typeset” .
Transmission d’arguments
Le programme appelant la fonction peut lui fournir des arguments. Ils
seront récupérés par les variables 1, 2, 3 qui deviennent donc locales à la
fonction rendant les arguments passés au programme inaccessibles.
Exemple :
#!/usr/bin/ksh
function f
{
echo $1 $2
}
echo bonjour
f marseille paris

Execution :
e-center> prog.ksh
bonjour
marseille paris
Modification d’un argument re¸cu Il est possible d’utiliser une chaı̂ne de

caractères transmise en argument pour créer ou modifier une variable. Ce
mécanisme repose sur le fait que les variables shell sont globales par défaut
(visibles et modifiables par tous les sous-programmes)
Exemple :
#!/usr/bin/ksh
function f
{
echo "debut de l’execution de la fonction"
echo "saisir la valeur de $1 : \c"
read $1
echo "fin de l’execution de la fonction"
}
echo bonjour
f var
echo "valeur de var dans le programme principal : $var"
Exécution :
e-center> prog.ksh
bonjour
debut de l’execution de la fonction
saisir la valeur de var : 1250
fin de l’execution de la fonction
valeur de var dans le programme principal : 1250
Envoi d’un code retour avec return

Linstruction return pour la fonction joue exactement le rôle de exit pour le
programme principal, cest à dire : - elle interrompt lexécution de la fonction
et revient au programme principal ; - elle donne aussi la possibilité denvoyer
une valeur qui sera le code retour de lexécution de la fonction (cette valeur
sera donc mise dans la variable ?)
Exemple :
#!/usr/bin/ksh
function f
{
if [ $# = 0 ] ; then
echo "pas darguments pour f" ; return 1
fi
...
}
echo bonjour
f
echo "code retour de f : $?" ; echo fin
Exécution :
e-center> proc.ksh
bonjour
pas darguments pour f
code retour de f : 1
fin

Utilisation de variables locales

Par défaut, les variables shell sont globales. Afin de disposer de variables de
travail dont la portée est restreinte à la fonction, il est possible de définir
des variables locales avec l’instruction typeset.
Note : L’éventuelle valeur initiale de la variable est sauvegardée et

restaurée au retour dans le programme principal
Exemple :
#!/usr/bin/ksh
function f
{
typeset var=marseille
echo "valeur de var dans f : $var"
}
echo bonjour
var=paris
f
echo "valeur de var dans proc : $var"
echo fin
Exécution :
e-center> proc.ksh
bonjour
valeur de var dans f : marseille
valeur de var dans proc : paris
fin
Partage de fonctions
Il est possible de partager des fonctions entre différents programmes shell,
suivant 2 modes : statique ou dynamique
Partage statique
Le principe est de rendre la fonction disponible dans le shell interpréteur du
nouveau programme, en for¸cant son chargement. Cette opération est réalisée
à l’aide de l’opérateur . (point) L’inconvénient principal de cette méthode
est le possible chargement dans le shell interpréteur de fonctions inutiles.
Exemple :
e-center> cat /var/fonctions/lib.ksh

#!/usr/bin/ksh
function f
{
echo "bienvenu dans f !"
}
Utilisation :

e-center> cat prog.ksh

#!/usr/bin/ksh
. /var/fonctions/lib.ksh
echo "appel de f : "
f
echo fin
Exécution :
e-center> prog.ksh
Appel de f :
Bienvenu dans f !
fin
Partage dynamique en Korn-shell

Plus performante, cette méthode consiste à provoquer le chargement de la
fonction uniquement lors de son premier appel. Par la suite, la fonction
reste chargée en mémoire.
Mise en oeuvre :
1. Définition d’un fichier ENV dans le fichier .profile (en général,
.kshrc) ;
2. Création d’un fichier de même nom que la fonction contenant le code
de la fonction ;
3. dans ENV, définir la variable FPATH donnant le chemin du fichier
de la fonction à partager ET appeler l’instruction autoload sur la
fonction ;
4. dans tous les scripts appelant la fonction, forcer l’exécution dans le
shell courant du ENV.
La commande typeset -fu permet de lister les fonction ”autochargées” dans
le shell courant.
Exemple :
e-center> cat $HOME/$ENV
...
FPATH=/var/fonctions_autoload
autoload f
...
e-center> cat /var/fonctions_autoload/f
function f
{
echo "bienvenu dans f !"
}
e-center>
Utilisation :
e-center> cat prog.ksh
#!/usr/bin/ksh
. $ENV
echo "appel de f : "
f
echo fin

Exécution :
e-center> prog.ksh
appel de f :
Bienvenu dans f !
fin
e-center>

39
Chapitre 4
Utilitaires et commandes Unix
Objectifs
xxx

40 Chapitre 4 Utilitaires et commandes Unix
4.1 Les différentes licences

Les filtres sont des utilitaires standards, présents sur tous les systèmes Unix.
Ils permettent de multiples traitements sur les fichiers de texte ( organisés
en lignes ) et constituent des outils très intéressants, aussi bien pour le
développeur que pour l’utilisateur.
Leur appellation provient du fait quils apparaissent assez souvent dans des
”pipelines” pour mettre en forme des résultats de commandes.
Ces résultats sont écrits sur la sortie standard. On utilise des redirections
pour les archiver dans des fichiers.
4.2 Quelques filtres simples

head Affichage des premières lignes d’un fichier
head [-n] [fichier]
-n Nombre de lignes souhaitées ( défaut 10 )
tail Affichage des dernières lignes d’un fichier
tail [ +/-[n] [l—b—c] ] [-f] [fichier]
+n Affichage à partir de la ligne de numéro n -n Affichage des n dernières
lignes ( défaut 10 ) l n est exprimé en lignes ( défaut ) b n est exprimé en
blocs de 512 octets c n est exprimé en caractères f Attente de nouvelles
lignes ( sortie par BREAK )
wc Compter les lignes, mots et caractères dun fichier
wc [ -lwc ] fichier
-l nombre de lignes -w nombre de mots -c nombre de caractères
cut Sélection de caractères ou de mots dans une ligne
cut -fliste [-dsep] [-s] [fichier...] cut -cliste [fichier...]

Chapitre 4 Utilitaires et commandes Unix 41
liste n-m ou n,m ou -m (à partir du début de ligne) ou m- (jusqu‘à la fin de

la ligne) -c Sélection de caractères -f Sélection de mots -dsep Redéfinition
du séparateur -s Suppression des lignes sans séparateurs
tee Mémoriser les résultats intermédiaires dans le fichier donné en argument
tee [-a ] fichier
-a permet une utilisation en mode ”ajout”
Quelques exemples
$ ls -la |tail +2 Liste de tous les fichiers du répertoire de travail en
éliminant la première ligne
$ head -15 exemple |tail +10 Affichage des lignes 10 à 15 du fichier
exemple
$ ls |wc -l Afficher le nombre de fichiers du répertoire courant
$ ls |wc -l |tee liste Afficher le nombre de fichiers du répertoire
courant et le mémoriser dans le fichier liste
$ wc -lc exemple Nombre de mots et lignes du fichier exemple
$ cut -d : -f 1,3,6,7 /etc/passwd Sélection des champs nom, UID,
répertoire de connexion et shell de connexion du fichier administratif
/etc/passwd
$ cut -c1-9,64- exemple Sélection de lintervalle de
colonnes 1 à 9 et 64 à fin de ligne du fichier exemple
4.2.1 Utilitaire de tri : sort

sort [options] [ -k keydef ] [ -o fichier ] [ - tcar ]
fichiers...
Lunité de traitement est la ligne ou le mot ( champ ). Le critère de tri par
défaut est le code ascii. De multiples options permettent de choisir des
critères plus réalistes ( alphabétique, numérique ... ).
Si aucun fichier n’est donné en argument ou si on utilise le caractère - (
signe moins ), la commande traite son entrée standard. Le résultat du tri
est écrit sur la sortie standard.
Quelques options
-b Pour une bonne gestion du nombre variable d’espaces ou de tabulations
entre les champs ( option quasiment indispensable pour des tris
alphabétiques ) -d Seuls les lettres, chiffres, espaces et tabulations sont
significatifs pour le tri -f Minuscules et MAJUSCULES sont confondues -n
Tri numérique -r Résultat en ordre décroissant -u Suppression de lignes
multiples dans le résultat -o fichier Sauvegarde du résultat dans le fichier
spécifié ( Ce fichier peut être un des fichiers d’entrée ) -tcar Redéfinition du
caractère séparateur etc...
4.2.2 Utilisation des champs

La notation -k keydef permet dindiquer que le tri doit seffectuer
uniquement sur certains champs de la ligne. Il est possible dindiquer
plusieurs couples de clés pour opérer un tri à plusieurs passes.
Ces clés sexpriment sous la forme [ début [type] [,fin [type] ]

début , fin Portion de ligne à traiter en indiquant les Numéros du champ

type Une ou plusieurs options parmi b , d , f , i , n ou r Le type b, sil est
positionné, sapplique sur le champ souhaité en plus de loption b
Quelques exemples
$ sort -k2,2 fic Tri ( critère Ascii ) sur le deuxième champ du fichier
fic
$ sort -bf -k2,2 fic Tri alphabétique sur le deuxième champ. Ignorer
le nombre d espaces avant et après le champ
$ sort -t : -rn -o fichier.out -k3,3 fic
Tri ( critère numérique, ordre décroissant ) sur le troisième champ avec
redéfinition du séparateur de champs Sauvegarde du résultat dans le fichier
fichier.out
4.3 Transformations de caractères : tr

tr [options] [ chaine1 [ chaine2 ] ]
Ce filtre lit l’entrée standard pour effectuer des substitutions ou des
suppressions de caractères. Les résultats sont écrits sur la sortie standard.
Dans la syntaxe de base, les caractères mentionnés dans ”chaine1” sont
remplacés par ceux de même position dans ”chaine2”.
Des abréviations sont possibles pour désigner des ensembles de caractères :
[a-z] Les lettres minuscules ( intervalle ) [a*n] n fois le caractère a ( * seul
signifie : ”un nombre quelconque” ) \xyz Code Ascii en octal du caractère
[ :class :] Indique une classe de
caractères :lower : :upper : :alpha : :alnum : :digit : :space :
Options -d Supprimer les caractères apparaissant dans ”chaine1” -s Les
caractères consécutifs identiques sont réduits à un seul exemplaire -c
Négation -¿ Les caractères n’apparaissant pas dans ”chaine1”
Quelques exemples
$ tr "[a-z]" "[A-Z]" <fichier Transformer les minuscules en
MAJUSCULES.
$ tr "[ :lower :]" "[ :upper :]" <fichier Idem en utilisant les
classes de caractères.
$ tr -d "abcd" <fichier Les caractères a , b , c et d sont supprimés.
$ tr -sc "[A-Z][a-z]" "[\012*]" <fichier Les caractères non
alphabétiques sont transformés en un saut de ligne. Les sauts de ligne
consécutifs sont éliminés. On obtient un mot alphabétique par ligne.
4.4 Rappel des expressions régulières

Les expressions régulières forment un langage de description densembles de
chaı̂nes de caractères.
Parmi les différents utilitaires UNIX utilisant la notion dexpressions
régulières, citons ex ( appelé depuis le mode de commandes syntaxique de
vi ), les filtres awk, grep, sed.

Début de ligne

Chapitre 4 Utilitaires et commandes Unix 43
Fin de ligne
. Présence dun caractère quelconque
[caractères] Un caractère parmi un ensemble donné

[ caractères] Un caractère ne figurant pas dans l’ensemble
* Un nombre quelconque d’apparitions d’un caractère ( éventuellement
aucune apparition )
\Annuler la sémantique dun caractère dans lexpression
Les expressions régulières enrichies introduisent des caractères
supplémentaires :
+ Un nombre quelconque d’apparitions d’un caractère ( au moins une
apparition )
? Aucune ou une seule apparition d’un caractère
( ) Regroupement de composants
|Ou
NB : Certaines expressions régulières enrichies ne sont pas utilisables avec
sed et awk. Elles sont accessible avec le grep conforme à la norme XPG4.
Quelques exemples à déchiffrer

[abc]
a b ou c en début de chaı̂ne
[ abc] tout caractère sauf a b et c en début de chaı̂ne

[ ] tout caractère autre que en début de chaı̂ne
ab ?c ac ou abc
(ab)+c abc ou ababc ou abababc etc

ab—cde * ab en début de chaı̂ne ou cde suivi d’espaces éventuels en fin
de chaı̂ne

[0-9]+ chaı̂ne constituée uniquement de chiffres
4.5 Recherche d’expressions : grep

Ce filtre permet de rechercher des expressions littérales ou ”régulières” dans
des fichiers. Les lignes comportant les expressions recherchées sont affichées
sur la sortie standard.
Le filtre grep présenté ici est celui conforme au guide XPG4. Sur de
nombreuses versions d’UNIX, le grep par défaut est une ancienne version
qui ne sait pas utiliser les expressions régulières enrichies.
grep [-E |-F] [-c |-l |-q] [options] expr fichiers ... ou grep [-E |-F] [-c |-l |-q]
[options] [ -e expr ... ] [ -f fichier ... ] fichiers ...
Quelques Options
-E Lexpression est traitée comme expression régulière enrichie (
anciennement egrep). -F Lexpression est traitée comme expression littérale
(anciennement fgrep).
-c Afficher le nombre de lignes trouvées -l Afficher uniquement les noms des
fichiers -q Supprime laffichage des lignes résultat
-i MAJUSCULES et minuscules sont confondues -n Chaque ligne est
précédée de son numéro dans le fichier -v Les lignes ne comportant pas
l’expression -x Les lignes exactement identiques à l’expression
-e expr Permet de chercher plusieurs expressions Permet aussi de chercher
une expression commenant par - ( signe moins )

-f fichier Les expressions cherchées sont décrites dans un fichier ( une par
ligne )
Notations fréquentes et utiles

Ligne vide ( un début et une fin )
. Ligne non vide
.* ”Reste de la ligne” ou ”ligne complète” suivant le contexte
Quelques exemples
$ grep ’àbc’ fichier Lignes commenant par la chaı̂ne ”abc”
$ grep E ’àbc’ fichier Idem

$ grep F ’àbc’ fichier Lignes contenant la chaı̂ne ” abc”
$ grep ’`[abc]’ fichier Lignes commenant par a ou b ou c
$ grep ’`[`0-9]’ fichier Lignes ne commenant pas par un chiffre
$ grep ’abc.$’ fichier Lignes se terminant par la chaı̂ne ”abc” suivie
dun caractère quelconque
$ grep E ’`[0-9]+$’ fichier Lignes constituées d au moins un et
uniquement de chiffres.
$ grep -n ’`’ fichier Numéroter toutes les lignes ( toutes les lignes
ont un début )
$ grep -f motifs fichier Recherche des expressions régulières
indiquées dans le fichier ”motifs”
$ grep -i ’expr *$’ fichier Lignes se terminant par la chaı̂ne ”expr”
( minuscules ou majuscules ) suivie dun nombre quelconque despaces
$ grep -e ’àbc’ e ’ef *$’ fichier Lignes commenant par la
chaı̂ne ”abc” ou bien se terminant par la chaı̂ne ”ef” suivie dun nombre
quelconque despaces
$ grep -E ’àbc|ef *$’ fichier Idem

45
Chapitre 5
sed & awk
Objectifs
xxx

46 Chapitre 5 sed & awk
5.1 Edition (non interactive) de fichiers : sed
Ce filtre est un diteur non interactif qui copie les fichiers d’entre sur la
sortie standard aprs leur avoir appliqu un certain nombre de commandes.
sed [-n] ’commandes sed’ fichiers... ou sed [-n] -f fichier commandes fichiers...
Syntaxe des commandes sed et principe de fonctionnement
[ adresse1[,adresse2] ]action[arguments]
Les crochets indiquent un aspect facultatif et napparaissent pas dans les
commandes. Tous ces lments ne sont spars par aucun espace. En labsence
dadresses de slection, laction a lieu sur toutes les lignes des fichiers dentre.
Laction par dfaut est dafficher la ligne sur la sortie standard. L’option -n
permet de supprimer cette sortie systmatique des lignes.
Une adresse peut tre :
- Un numro de ligne - Le caractre dsignant la dernire ligne - Une
expression littrale ou rgulire entre deux caractres /
Quelques actions usuelles
d Ne pas afficher la ligne p Afficher la ligne ( sutilise souvent avec l’option
-n ) q Abandonner le traitement s/expr1/expr2/ Remplacer la premire
expression par la seconde, une seule fois par ligne s/expr1/expr2/g
Remplacer la premire expression par la seconde, plusieurs fois par ligne si
ncessaire s/expr1// Supprimer l’expression s/expr1/...&.../ Expanser la
premire expression ( elle-mme + ”quelque chose” ) ( La notation & signifie
”reprendre la premire expression” ) = Afficher le numro de ligne
Quelques exemples
sed ’s/monsieur/madame/g’ fichier Remplacer une chane par une autre
plusieurs fois par ligne

Chapitre 5 sed & awk 47

sed ’s/ / /’ fichier Dcaler le dbut de chaque ligne par des espaces

sed ’/./s/ / /’ fichier Idem uniquement sur les lignes non vides
sed -n ’/expression/ !p’ fichier Afficher les lignes ne contenant pas
lexpression ( Le ! indique la ngation de lexpression )
sed -n ’20,30p’ fichier Afficher les lignes de numro 20 30
sed ’1,10d’ fichier Ne pas afficher les 10 premires lignes
sed -n ’/./p’ fichier Afficher uniquement les lignes non vides

sed ’/ /d’ fichier Mme traitement
sed ’/expression/q’ fichier Afficher jusqu trouver une expression donne
sed -n ’/expression/=’ fichier Afficher les numros des lignes contenant une
expression donne
sed ’s/[0-9][0-9]*/(&)/g’ fichier Mettre entre parenthses les nombres entiers
plusieurs fois par ligne si ncessaire
5.2 Introduction au langage awk

Cet utilitaire awk tire son nom de ceux de ses concepteurs. ( Alfred AHO ,
Peter WEINBERGER , Brian KERNIGHAN )
C’est un outil trs adapt pour raliser des tches de manipulation de donnes
sans avoir les programmer dans un langage classique comme le C. En effet,
beaucoup de choses sont implicitement rsolues. ( les entres, la gestion des
”champs”, la gestion mmoire, les dclarations, les initialisations ... )
Syntaxe et principe de fonctionnement
awk ’liste-de-commandes’ fichiers... ou awk -f fichier commandes fichiers...
Une commande est constitue ainsi : motif action
Le motif sert dexpression de slection des lignes pour y appliquer laction
associe. Si le motif est absent, toutes les lignes sont concernes par laction.
Laction par dfaut consiste afficher la ligne.
Chaque ligne d’entre est automatiquement divise en champs. Les diffrents
champs sont nomms respectivement : 1 2 3 ... NF NF reprsente le
nombre de champs de la ligne en cours de traitement.
Le sparateur de champs peut tre positionn un caractre particulier. Pour ce
faire, on peut procder de deux faons :
1) On utilise comme premire commande : BEGIN { FS = ”caractre” } ou
2) A l’appel de ”awk”, on utilise l’option -Fcaractre
Dautres variables intressantes sont prdfinies :
0 La ligne entire NR Numro de la ligne courante FILENAME Nom du
fichier courant d’entre etc...
5.2.1 Les motifs

Les programmes peuvent souvent se rsumer une suite de motifs puisque
l’action par dfaut est l’impression des lignes slectionnes. ”awk” est donc un
outil trs puissant de slection.
Quelques motifs possibles
- Expression btie avec des oprateurs trs proches de ceux du langage C
3 <10 3 < 2 + 10 && 4 == ”dupont”
- Expression littrale ou rgulire entre deux caractres /

/dupont/ / [0-9]/
- Intervalle de numros de lignes
NR == 10 , NR == 15
- Le motif BEGIN
Laction associe est excute avant le traitement des fichiers dentre
- Le motif END
Laction associe est excute aprs le traitement des fichiers dentre
5.2.2 Les actions

Une action est une suite d’instructions. Chaque instruction est termine par
un ; ( point-virgule ) ou un saut de ligne.
Instructions disponibles
- Les fonctions d’affichage print ( affichage brut ) et printf ( affichage
format ) - Instruction btie avec des oprateurs trs proches de ceux du
langage C - Instructions de contrle ( tests, boucles, fonctions intgres ... )
Quelques premiers exemples
awk ’ 3 >1000 { print 1 , 2 , 3 } ’ fichier Pour toutes les lignes o le
troisime champ est suprieur mille, on affiche la valeur des trois premiers
champs
awk ’ { print NR , 0 } ’ fichier Numroter les lignes dun fichier
awk ’ { printf ”%4d %s\n” , NR , 0 } ’ fichier Mme traitement avec
formatage
awk ’ 3 ¿ 1000 { val++ } END { print val }’ fichier Afficher le nombre de
lignes o le troisime champ est suprieur 1000
awk ’ 3 ¿ max { max = 3 ; maxnom = 2 } END { print max , maxnom }’
fichier Afficher la valeur maximum du troisime champ ainsi que celle du
deuxime champ associ
awk ’ { noms = noms 2 ” ” } END { print noms }’ fichier Afficher la
concatnation de tous les deuximes champs ( Concatnation par juxtaposition
)
awk ’BEGIN { printf ”Calcul du maximum et de la moyenne\n”} { somme
+= 3 } 3 >max { max = 3 } END { printf ”Maximum = %10.2f
Moyenne = %10.2f\n”, max, somme/NR } ’ fichier
5.2.3 Les tableaux associatifs

On peut manipuler des tableaux de couples ”cl = valeur” ( cl unique ). En
gnral, cette cl prend toutes les valeurs possibles d’un des champs du fichier
trait.
Contenu du fichier ”exemple”
roger martin 12000 cd1 rene duval 500 cd1 marie pervenche 12010 cd3
Marcel dupond 600 cd2 paul martin 10000 cd4 roger martin 12500 cd1
Rene DUVAL 510 cd1 marie pervenche 13000 cd3 marie martin 13000 cd3
Sophie Martinez 6512 cd2 Sylvie Martinelli 45678 cd2 Paul Legrand 4560
cd5 michel DUVAL 54500 cd1 Mireille Duvalier 12345 cd2 Paul LEGRAND

Chapitre 5 sed & awk 49
14560 cd5 Rene Pervenche 5400 cd3 Paul martinez 5600 cd2 Andre dupond
650 cd5
Soit le fichier prog contenant les instructions suivantes :
BEGIN { printf "EXEMPLE DE TABLEAU ASSOCIATIF\n" }

{ tab[$2] += $3 }
END { for ( nom in tab ) printf "%-20s %6d\n" , nom , tab[nom] }
On construit dynamiquement un tableau associatif ”tab” dont les indices

(cls) sont toutes les valeurs possibles du deuxime champ. Pour une cl donne,
la valeur associe consiste faire la somme des valeurs du troisime champ.
On obtient lexcution :
$ awk -f prog exemple

EXEMPLE DE TABLEAU ASSOCIATIF
dupond 1250
Legrand 4560
martin 47500
LEGRAND 14560
pervenche 25010
martinez 5600
Pervenche 5400
Duvalier 12345
DUVAL 55010
duval 500
Martinelli 45678
Martinez 6512
5.2.4 Aide-mmoire rsum de awk

Variables prdfinies
ARGC Nombre d’arguments de la ligne de commande ARGV Tableau
contenant les arguments de la ligne de commande FILENAME Nom du
fichier d’entre courant FNR Numro d’enregistrement dans le fichier courant
FS Sparateur de champs en entre ( ”espace” par dfaut ) NF Nombre de
champs dans l’enregistrement courant NR Nombre d’enregistrements lus
jusqu’ prsent OFMT Format d’affichage pour les nombres ( ”%.6g” par
dfaut ) OFS Sparateur de champs l’affichage ( ”espace” par dfaut ) ORS
Sparateur d’enregistrements l’affichage ( ”\n” par dfaut ) RLENGTH
Longueur de la concordance obtenue par la fonction ”match” RS Sparateur
d’enregistrements en entre ( ”\n” par dfaut ) RSTART Premire position
dans la chane qui concorde avec la fonction ”match”
Oprateurs
= += -= *= /= %= ˆ= Affectation
? : Si Alors Sinon
| | Ou logique
&& ET logique
˜ !˜ Concordance ( ou non ) avec une expression rgulire
< <= > >= != = = Oprateurs de comparaison
+ -Addition, soustraction
* / % Multiplication, division, modulo
+ - ! Plus unaire, moins unaire, NON logique
ˆ ( ou ** ) Puissance
++ --Incrmentation et dcrmentation

5.2.5 Instructions de contrle

{ instructions } if ( expression ) instruction if ( expression ) instruction1
else instruction2 while ( expression ) instruction for ( expression1 ;
expression2 ; expression3 ) instruction for ( variable in tableau ) instruction
do instruction while ( expression ) break continue next exit expression
5.2.6 Quelques fonctions intgres

atan2 ( x, y ) Arctangente cos ( x ) Cosinus exp ( x ) Exponentielle int ( x )
Partie entire log ( x ) Logarithme rand ( ) Nombre alatoire dans l’intervalle
[0,1] sin ( x ) Sinus sqrt ( x ) Racine carre
gsub ( r , s , t ) Remplace globalement par s chaque occurrence de r dans la
chane t ( 0 par dfaut ). Retourne le nombre de remplacements effectus
index ( s , t ) Premire position de t dans s length ( s ) Longueur de la chane
match ( s , r ) Position de la sous-chane en concordance avec l’expression r
Mise jour des variables RSTART et RLENGTH split ( s , t , sc )
Dcomposition de s en un tableau t selon le sparateur sc ( FS est le
sparateur par dfaut ) sub ( r , s , t ) Remplace par s la premire occurrence
de r dans la chane t substr ( s , i , n ) Sous-chane de longueur n de s
dbutant en position i
system ( commande ) Excution d’une commande getline Lecture de donnes
via l’entre standard, un fichier ou un ”pipe” getline getline var getline
<fichier getline var <fichier commande |getline commande |getline var

Annexe A
Annexe A
Énoncé des exercices
Objectifs
Rappels sur les principes d’un système d’exploitation
Rappels sur certaines commandes de base
Rappel sur l’utilisation du manuel
Index-51
Annexe A
A.1 TP DE PROGRAMMATION SHELL

Principes fondamentaux

Public”
A.1.1 TP1 Traitement de la ligne de commandes et

utilisation de la commande test sur les fichiers
Ecrire un script tp1.ksh qui re¸coit un fichier en argument Le script vérifie
quun argument est passé sur la ligne de commandes Si c’est un répertoire,
le script liste son contenu avec ls S’il s’agit d’un fichier ordinaire ”texte”, le
script laffiche en mode paginé avec more
Appel : tp1.ksh fichier
A.1.2 TP1-bis Traitement de la ligne de commandes

et utilisation de la commande test sur les
fichiers
Idem TP1, avec le test en syntaxe Korn Shell Le nom du script est
tp1bis.ksh
Appel : tp1bis.ksh fichier
A.1.3 TP2 Exemple de boucle for

Ecrire un script tp2.ksh qui liste dans une boucle for les commandes d’un
répertoire donné en argument Sil ny a aucun argument, le scripte traite le
répertoire courant
Note : Une commande est un fichier ordinaire et exécutable
Index-52
Annexe A
Appel : tp2.ksh [ fichier ]
A.1.4 TP2-bis Exemple de boucle for et d’utilisation

des expressions arithmétiques
Idem TP2, avec le comptage du nombre de commandes situées dans le
répertoire Le nom du script est tp2bis.ksh
Appel : tp2bis.ksh [ fichier ]
A.1.5 TP3 Exemple de boucle while et de lecture

clavier
Ecrire un script tp3.ksh qui affiche un message au terminal à une heure
donnée Il récupère l’heure du système sous la forme hh :mm Il réalise la
lecture au clavier dune heure au même format hh :mm Il vérifie dans le cas
dune saisie non vide que lheure est postérieure sinon il quitte le programme
Dans une boucle while, le script attend cette heure en recalculant l’heure
système toutes les 10 secondes pour afficher un message au terminal de
lutilisateur
Note : Penser à utiliser la commande date avec le format suivant : date

+%H :%M
Appel : tp3.ksh
A.1.6 TP4 Exemple d’aiguillage case

Ecrire un script tp4.ksh qui re¸coit deux noms de fichiers fic1 et fic2 en
arguments Le traitement est une boucle sur la lecture des informations au
clavier La fin fin de la boucle a lieu sur saisie vide A laide de laiguillage
case, les lignes ne comportant que des lettres sont ajoutées dans le fichier
fic1, les lignes ne comportant que des chiffres sont ajoutées dans le fichier
fic2 Les autres lignes sont rejetées
Le script affichera le nombre de lignes pour les trois cas en fin de traitement
Appel : tp4.ksh fic1 fic2
A.1.7 TP5 Instruction select , Expressions

arithmétiques et tableaux
Ecrire un script tp5.ksh qui réalise une opération sur 2 entiers
Les opérations suivantes sont disponibles : Addition, Soustraction, Division,
Multiplication
La structure select du Korn Shell est utilisée pour valider le type
dopération souhaitée, afficher la liste des toutes ces opérations et sortir du
script Après saisie des 2 entiers, le script vérifie que les nombres sont des
entiers et réalise lopération demandée par lutilisateur
Index-53
Annexe A
A.1.8 Un plus dans le script est de prévoir lopération

Modulo
Appel : tp5.ksh
A.1.9 TP6 Exemple de traitement des interruptions,

utilisation des fonctions et de la boucle while
Ecrire un script tp6.ksh qui réalise dans une boucle infinie while la création
puis le grossissement dun fichier par la redirection dun message dans le
fichier
Le script intercepte les signaux INT, QUIT et TERM comme suit : - Ignore
le signal QUIT ( 3 ) - Sur réception du signal INT ( 2 ) ou TERM ( 15),
appelle une fonction de déroutement qui supprime le fichier
Appel : tp6.ksh
A.2 ENONCES D’EXERCICES SUR LES

FILTRES
Dans la suite la référence au fichier ”exemple” est faite à partir du contenu
vu ci-dessous :
roger martin 12000 cd1 rene duval 500 cd1 marie pervenche 12010 cd3
Marcel dupond 600 cd2 paul martin 10000 cd4 roger martin 12500 cd1
Rene DUVAL 510 cd1 marie pervenche 13000 cd3 marie martin 13000 cd3
Sophie Martinez 6512 cd2 Sylvie Martinelli 45678 cd2 Paul Legrand 4560
cd5 michel DUVAL 54500 cd1 Mireille Duvalier 12345 cd2 Paul LEGRAND
14560 cd5 Rene Pervenche 5400 cd3 Paul martinez 5600 cd2 Andre dupond
650 cd5
A.2.1 Exercice 1 Utilitaire de tri sort sur le fichier

exemple
1) Trier sur le troisième champ en ordre décroissant
2) Trier sur le deuxième champ ( minuscules et majuscules confondues )
3) Trier sur le deuxième champ ( minuscules et majuscules confondues )
puis deuxième passage sur le premier champ ( même critère ) puis troisième
passage sur le troisième champ
4) Trier sur les trois premiers caractères du deuxième champ ( critère code
ascii )
A.2.2 Exercice 2 Utilitaire de tri sort sur des

commandes ou fichiers du système
1) Trier le résultat de ”ls -al” daprès la taille des fichiers
2) Trier le fichier /etc/passwd daprès le numéro de login ( UID ) en ordre
décroissant
Index-54
Annexe A
A.2.3 Exercice 3 Transformation de caractères : tr

en sortie de commande ls
1) Afficher la liste des fichiers du répertoire courant en majuscules
2) Remplacer, dans le résultat de ”ls -al”, tout caractère nétant ni un
chiffre, ni un espace, ni un saut de ligne par la lettre X
A.2.4 Exercice 4 Recherche dexpressions avec grep

sur le fichier exemple
1) Rechercher les lignes du fichier ”exemple” qui commencent par m ou M
2) Rechercher les lignes du fichier ”exemple” qui comportent la lettre a en
deuxième position
3) Rechercher les lignes du fichier ”exemple” qui se terminent par 1 ou 2
4) Rechercher les lignes du fichier ”exemple” qui commencent par une
majuscule OU qui se terminent par la chaı̂ne ”cd1”
5) Rechercher les lignes du fichier ”exemple” qui commencent par une
majuscule ET qui se terminent par la chaı̂ne ”cd2” ( avec le résultat trié
sur le troisième champ en ordre décroissant )
A.2.5 Exercice 5 Recherche dexpressions avec grep

sur le fichier /etc/passwd
1) Dans le fichier /etc/passwd, rechercher les lignes correspondant aux
utilisateurs du Korn-shell
2) Même question pour les utilisateurs potentiels du Bourne-shell
A.2.6 Exercice 6 Edition non interactive de fichiers :

sed sur le fichier exemple
1) Dans les lignes du fichier ”exemple” qui ne contiennent pas la chaı̂ne
”cd1”, remplacer la chaı̂ne ”cd” par la chaı̂ne ”code”
2) Afficher le fichier ”exemple” jusquà trouver la chaı̂ne ”cd5” ( ligne non
comprise )
3) Décaler, de quelques espaces, le début des lignes du fichier ”exemple”
commen¸cant par une majuscule
4) Mettre des parenthèses autour des lignes du fichier ”exemple” qui se
terminent par ”cd1”
5) Idem ”question 4” mais en naffichant que les lignes modifiées, triées sur
le deuxième champ ( minuscules et majuscules confondues ) avec une
deuxième passe sur le troisième champ en ordre décroissant
6) Remplacer tous les ”0” du fichier exemple par des ”X” et tous les ”1”
par des ”Y”
Index-55
Annexe A
A.2.7 Exercice 7 Traı̂tement sur le fichier exemple

avec loutil awk
1) Afficher le fichier en numérotant les lignes et en permutant les deux
premières colonnes
2) Afficher noms et prénoms des personnes correspondant aux codes
”cd1”ou ”cd2” Afficher en final le nombre de ces personnes
3) Afficher la ligne pour laquelle le nombre ( 3ème colonne ) est le plus
grand
4) Pour chaque code, afficher le total des nombres ( 3ème colonne ) Afficher
en final la moyenne des nombres
A.3 ENONCES D’EXERCICES DE

L’ATELIER DE PROGRAMMATION
SHELL
Les ateliers ci-dessous ne sont pas proposés dans un ordre croissant de
difficulté. On peut donc les aborder dans un ordre quelconque selon leur
thème respectif ou selon ses préférences personnelles
A.4 Atelier 1 Modification de nom de

fichiers avec confirmation éventuelle et
gestion de la ligne de commandes
Ecrire un script atelier1.ksh qui re¸coit deux arguments .ext1 et .ext2 Le but
du script est de renommer tous les fichiers dextension .ext1 du répertoire
courant en *.ext2 Le script vérifie que les arguments sont des extensions :
” . ” suivi de lextension en minuscules
Si on donne l’option ” -i ”, le script propose la confirmation pour chaque
fichier
Note : Penser à utiliser la commande basename sur les noms de fichiers à

traiter
Syntaxe : basename string [suffix]

Appel : atelier1.ksh [ -i ] .ext1 .ext2
A.5 Atelier 2 Autre script de modification

de nom de fichiers
Ecrire un script atelier2.ksh qui re¸coit des noms de fichiers en arguments
Pour chaque argument, s’il s’agit d’un fichier ordinaire dont le nom ne
contient que des MAJUSCULES, on le renomme en minuscules
Appel : atelier2.ksh liste fichiers
Index-56
Annexe A
A.5.1 Atelier 3 Traitements sur les fichiers : test

Ecrire un script atelier3.ksh qui re¸coit des noms de fichiers en arguments Si
le fichier existe et est un fichier ordinaire, on affiche sa taille Si le fichier
n’existe pas, on le créée de taille 0
Si l’option ”-c” est utilisée, le script ne créée pas le fichier s’il n’existe pas
Appel : atelier3.ksh [ -c ] liste fichiers
A.5.2 Atelier4 Menu simple avec case et appel de

commandes UNIX
Ecrire un script atelier4.ksh sous la forme dun menu dans une boucle until
Le script prévoit avec la structure case : 1. Laffichage de l’heure 2. Le
changement de répertoire courant 3. La sauvegarde au format tar
compressé des fichiers ordinaires du répertoire courant après avoir vérifié
qu’il y en a Après saisie du nom de larchive souhaité, la création de celle-ci
se fait sous /tmp 4. La liste du contenu d’une archive dont on saisit le nom
5. La Restauration interactive de fichiers d’une archive 0. La Sortie
Rappel sur la syntaxe de tar :
Création dune archive : tar -cvf fichier archive liste a sauvegarder Lecture
dune archive : tar -tvf fichier archive |more Restauration dune archive : tar
-xvf fichier archive liste a restaurer
Appel : atelier4.ksh
A.5.3 Atelier 5 Gestion de la ligne de commande et

traitement sur les fichiers
Ecrire un script atelier5.ksh qui re¸coit en premier argument un entier et
ensuite une liste de fichiers Le script vérifie que le premier argument est un
entier Il affiche pour chaque fichier les lignes plus longues que cette valeur
et le nombre de lignes
Appel : atelier5.ksh valeur liste fichiers
A.5.4 Atelier 6 Traitements sur les fichiers et

Expressions arithmétiques
Ecrire un script atelier6.ksh qui recoit une liste de noms de fichiers en
arguments Le script ne conserve de la liste d’arguments que les fichiers
ordinaires et affiche la taille en octets de chacun, la taille totale ainsi que le
nom du plus gros fichier
Appel : atelier6.ksh liste fichiers
A.5.5 Atelier 7 Habillage de la commande find et

utilisation de fonctions
Le script atelier7.ksh propose par menu dexécuter la commande find
Index-57
Annexe A
Les critères suivants sont proposés : nom Le script appelle loption -name de
find
proprietaire Le script appelle loption -user de find Le script vérifie qu’on
donne un ”login” existant
dates Le script propose dans un sous-menu lune des options de find
suivantes : -mtime , -atime ou -newer
Pour chaque critère, le script fait la saisie au clavier de l’argument
correspondant à loption choisie Le script affiche la commande
correspondant aux choix de l’utilisateur Celle-ci est lancée après
confirmation de lutilisateur
Le script permet dinterrompre lexécution de la commande find sans quitter
le programme complet
Appel : atelier7.ksh
A.5.6 Atelier 8 Traitement de la ligne de commande

Ecrire un script atelier8.ksh qui traite la ligne de commande comme suit :
Si on a saisi ” u user” Le script affiche le nom des groupes de ”user” après
vérification quil sagit dun ”user” existant Sans l’option, il affiche ses
propres groupes
” t” Le script affiche le type de terminal de connexion
S’il y a des arguments, le script les affiche tels quels
Note : Il est possible dutiliser getopts
Appel : atelier8.ksh [ u user ] [ t ]
Index-58

SHELL Program Mat Ion Shell Sous Unix-Orsys Lacoste

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

SHELL Program Mat Ion Shell Sous Unix-Orsys Lacoste

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Shell sous Unix

Version 1.0 - Janvier 2005 - Première édition

2 Notions de base en shell 5

3.3.1 Nouvelles possibilités en Korn-shell . . . . . . . . . . . 23

4 Utilitaires et commandes Unix 39

5 sed & awk 45

A Énoncé des exercices 51

www.ambre-systems.com SHL - JML/07-2005

A.9 Un plus dans le script est de prévoir lopération Modulo . . . . 54

Programmation Shell sous UNIX - 2005 Ambre systems 1-1

1.1 Principes fondamentaux de la

Système d’exploitation multi-tâche

Nombreuses applications intégrées

Grande collaboration avec le ”Domaine

1-2 Programmation Shell sous UNIX - 2005 Ambre systems

1.2 Documentation disponible

Système d’exploitation multi-tâche

Nombreuses applications intégrées

Grande collaboration avec le ”Domaine

1.2.1 Site Internet

Programmation Shell sous UNIX - 2005 Ambre systems 1-3

Notions de base en shell

Programmation Shell sous UNIX - 2005 Ambre systems 2-5

2.1 Rappel sur l’entrée en session

Interface Graphique : CDE, Gnome, KDE

2-6 Programmation Shell sous UNIX - 2005 Ambre systems

2.2 Étude des différents fichiers de

Démarrage d’un nouveau processus

Une connexion consiste en un processus correspondant à l’exécution d’un

Dans la suite, les références au shell sont celles des environnements

Programmation Shell sous UNIX - 2005 Ambre systems 2-7

2.3 Variables et environnement

La notion de variable concerne surtout l’aspect programmation. Cependant,

$ mavariable=ambre $ echo $mavariable

2.4 Notion d’environnement : instruction

L’environnement shell ( variables exportées ) est constitué de l’ensemble des

2.4.1 Afficher la liste de toutes les variables, celles de

2-8 Programmation Shell sous UNIX - 2005 Ambre systems

2.4.2 Afficher la liste des variables de l’environnement

Placer une variable dans l’environnement

Note : Avec le ksh la syntaxe directe export variable=valeur est

2.5 Quelques variables système

Certaines variables ont un rôle plus ou moins important pour l’utilisateur

Programmation Shell sous UNIX - 2005 Ambre systems 2-9

2.5.1 Exemples d’utilisation

Redéfinir le prompt secondaire

2-10 Programmation Shell sous UNIX - 2005 Ambre systems

Gérer le PATH et le mettre à jour si besoin

Annuler la définition de la variable TERM

2.6 Compléments sur les variables

Programmation Shell sous UNIX - 2005 Ambre systems 2-11

${#var} Longueur d’une variable

2.7 Caractères spéciaux

Rappel des caractères déjà évoqués

Expressions génériques simples

2-12 Programmation Shell sous UNIX - 2005 Ambre systems

2.7.1 Expressions génériques composées du

2.7.2 Substitutions de commandes

$ echo " Il est $(date +%H :%M :%S)"

Programmation Shell sous UNIX - 2005 Ambre systems 2-13

2.7.3 Caractères de protections

Afficher ou non le caractère *

Annuler ou non la substitution de commandes

2.7.4 Procédures et paramètres

select variable in liste de libellés do Aiguillage sur variable ou REPLY