Unix PDF

23/02/2015
Unix Shell
Pr. M.D. El Kettani
ISO 27001 LI – ITILv3
ENSIAS
Université Mohammed V – Souissi
Plan
1. Présentation et rappels
2. Programmation par scripts
3. Mécanismes de base
4. Fonctionnement en interactif
5. Construction de shell-scripts portables (ksh/bash)
6. Mécanismes complémentaires
7. Extensions du Korn Shell et Bash
8. Automatisation avec les shell scripts
9. Les filtres: Grep, ed, sed et les expressions régulières
10. Les filitres programmables: le langage awk
11. Publication des données
2
12. Outils et commandes sur les fichiers
1
23/02/2015
Présentation et rappels
Plan
Introduction
Le rôle du shell
Les différents shells
Les fonctionnalités des différents shells
Le rappel de commandes
1ère connexion
2013-2014 Pr. M.D. El Kettani 3
Introduction
Le shell:
Définition : ensemble de fonctions permettant
d’exécuter les commandes de l’utilisateur
Possibilité d’écrire nos propres commandes
contrairement aux appels système.
Intermédiaire entre l’homme et la machine.
Plusieurs versions du shell:
Bourne Shell : sh,
C Shell : csh,
Korn Shell : ksh,
etc. 4
2013-2014 Pr. M.D. El Kettani
2
23/02/2015
Introduction
Les outils:
Définition : utilitaires servant généralement à
développer et mettre au point les programmes
Constitué de:
Commandes générales
Editeurs de texte ( vi ) ;
Compilateurs de programmes ( langage C ;
fortran ; cobol …), éditeur de liens …
Traitement de texte (nroff, troff, …)
Le rôle du shell
Shell = Interpréteur de commandes

Définition
Programme gérant l’interface entre l’utilisateur et
le système
Tout dialogue avec la machine se fait par
l’intermédiaire du Shell (pas de compilation)
Caractéristiques
1 exemplaire particulier du Shell par utilisateur
Il peut lancer +ieurs Shells sur sa session 6
3
23/02/2015
Le rôle du shell
Exercice:
Afficher la valeur de votre shell par défaut
Afficher la liste des shells disponibles
Afficher la liste des shells supportés
Modifier votre shell par défaut
Les différents shells

sh ("Bourne shell", Steve Bourne, AT&T)
shell historique (/usr/old/bin/sh, ou bsh)
csh ("C-shell", Bill Joy, UCB)

shell BSD (disponible sur tous les Unix)
ksh ("Korn shell", David Korn, AT&T)

Complète le shell Bourne et intègre avantages du C-shell
Les Shells
sh (shell normalisé POSIX P1003.2 et ISO 9945.2)
Dérivé du shell Bourne et intègre fonctionnalités ksh
bash ("Bourne again shell" de Brian Fox & C. Ramey)

shell libre de droit, compatible shell POSIX (par défaut Linux)
zsh ("Zero shell")

ksh du domaine public (installé sur toutes les machines)
rsh ("Bourne shell réduit", cd, <, > inopérants)

8
2013-2014 tcsh ("Toronto C-shell") Pr. M.D. El Kettani
4
23/02/2015
Fonctionnalités des shells
Comparaison des Shells

Shell program. histo aliases gestion tableaux var. num
chaînes arith. C
bsh std non non - non non
sh-POSIX norme oui oui oui - oui
csh non std oui oui non oui oui
tcsh non std oui oui non oui oui
ksh std oui oui oui oui oui
bash norme oui oui oui - oui
zsh norme oui oui oui - oui
Comparaison des Shells

Shell Programmation
sh sûre (standard)
csh à déconseiller
tcsh à déconseiller
ksh normalisée
bash normalisée
zsh normalisée
+ extensions
5
23/02/2015
Algorithme du shell
Ouverture initiale de 3 fichiers standard
entrée standard (stdin, fd=0), par défaut le clavier
sortie standard (stdout, fd=1), par défaut l'écran
sortie erreur standard (stderr, fd=2), par défaut
l'écran
Le shell lit sur son entrée standard
lecture de la commande jusqu'à la fin de ligne (\n)
et interprétation des métacaractères et opérateurs
lecture des lignes de commandes jusqu'à la fin de
2013-2014 fichier (^D) Pr. M.D. El Kettani 11
Algorithme du shell
Lancement d'une commande
recherche du nom de la commande à l'aide du
PATH (path)
en premier plan :
fork() exec(commande) wait() prompt
en arrière plan :
fork() exec(commande) prompt
6
23/02/2015
Rappels de commandes
Caractères de contrôle au clavier

Caractères de contrôle:
<cr> fin de ligne (retour chariot) mappé en <cr>
<lf> fin de ligne (nouvelle ligne) mappé en <cr><lf>
<tab> tabulation
<bs> ^H, backspace, effacement du caractère
précédent
<del> ^?, souvent identique à <bs>
<^C> interruption d'un processus attaché au terminal
<^\> arrêt d'un processus avec vidage mémoire
(core)
Caractères de contrôle au clavier

Caractères de contrôle (suite):
<^Z> suspension d'un processus en premier plan
<Û> effacement de la ligne complète
<^W> effacement du mot qui précède
<^D> fin de fichier => si le shell lit, fin d'un shell
<^S> suspension de l'affichage écran (Xoff)
<^Q> reprise de l'affichage écran (Xon)
Gestion des caractères de contrôle par stty
stty erase ^H kill Û intr ^C susp ^Z quit ^\ eof ^D
7
23/02/2015
Format d'une commande:

Invite (le prompt) principale
$ en mode utilisateur
# en mode super-utilisateur
variable PS1
Invite secondaire
> en mode interactif
variable PS2
Format d'une commande:
Commande simple
une commande simple est une séquence de mots
séparés par un séparateur blanc et de redirections.
Le premier mot désigne le nom de la commande à
exécuter, les mots suivants sont passés en
arguments à la commande.
la valeur retournée d'une commande est celle de
son exit.
Chemin de recherche du nom d'une
commande : PATH ou path (csh)
PATH=/usr/ucb:/bin:/usr/bin:/usr/local/bin:~/bin:.
16
8
23/02/2015
Enchaînement de commandes:
Commande simple (en premier plan)
$ commande [ arg ... ]
Commande simple (en arrière plan)
$ commande [ arg ... ] &
Pipeline (tube de communication)
$ commande1 [ arg ... ] | commande2 [ arg ...] | ...
Séquencement de commandes (en premier
plan)
$ commande1 [ arg ... ]; commande2 [ arg ... ]; cmd3 ...
Enchaînement de commandes:
Exécution par un nouveau shell ()
$ sh commande [ arg ... ]
$ (commande [ arg ... ])
$ (commande [ arg ... ]) &
Regroupement de commandes
$ (com1 [ arg ... ]; com2 [ arg ... ]; com3 ...)
$ (com1 [ arg ... ]; com2 [ arg ... ]; com3 ...)&
9
23/02/2015
Le mode vi:
<ESC> Passer en mode rappel de commande
k, j Remonter ou descendre d’une commande
h, l Déplacer le curseur à gauche ou à droite
351G Rappel de la commande n°351
/wh Rappel de la commande contenant la chaine wh
x Détruire le caractère courant
a…<ESC> Ajout après le curseur
i…<ESC> Ajout avant le curseur
r Remplace lePr.caractère
M.D. El Kettani
courant 19
2013-2014
Exercice:
Ecrire un shell script Unix ‘ordonne’ qui réordonne les lignes
d’un fichier texte ‘losange’ correspondant à un losange
dont les lignes sont disposées dans l’ordre inverse
Indication:
- Utiliser les commandes head et tail
- Optimiser le shell script en utilisant les pipes
10
23/02/2015
Le mode fc:
Afficher les dernières commandes avec leur n° d’ordre
$ fc –l # ou history
Afficher les 25 dernières commandes
$ fc –ln –25
Afficher les commandes depuis 40 jusqu’à 50
$ fc –l 40 50
Afficher un domaine délimité par 2 commandes
$ fc –lr vi cc
Le mode fc:
Afficher le calendrier 1953 (7ème commande)
$ cal 1953
Editer puis exécuter la commande numéro 7
$ fc 7
Remplacer 1952 par 1953 dans la 7ème commande
$ fc –e –1952=1953 7
Editer puis exécuter les commandes entre 382 et 400
$ fc 382 400
11
23/02/2015
Paramétrage du rappel de commandes:

Utiliser le mode vi
$ set –o vi
Choisir le nom du fichier historique
$ HISTFILE=~/.histo
(par défaut ~/.sh_history)
Choisir la taille du fichier
$ HISTSIZE=300
(par défaut 128)
1ère connexion
Le cas Linux: Fiche produit
Sous-système de communication réseau:
TCP/IP v4 et v6, IPX/SPX, AppleTalk, X25, Ethernet, …
Serveur de messagerie SMTP, POP et IMAP
Serveur Web Apache avec sécurisation SSL
Serveur de fichiers FTP, noms DNS, news
Fonctions DHCP, NIS, Bootp, PAM, annuaire LDAP, Telnet, NAT,
Masq, Tunneling, IP Mobile, VPN, multicast
Outils d’administration SNMP
Utilisation dédiée: routeur, pare-feu, proxy
Sous-système d’interface utilisateur:
Architecture C/S X Window
Interface mode texte disponible 24
12
23/02/2015
1ère connexion
Termes à connaître :
Super Utilisateur : root , il s’occupe de
l’administration du système UNIX ( installation des
logiciels, création des profiles utilisateurs,
sauvegarde et restauration des données etc…)
Hôte (serveur) : système centrale sur lequel
peuvent se connecter les utilisateurs
Terminal (console) : machine composée
généralement d’un écran et d’un clavier, branchée
directement à la machine Hôte
1ère connexion
Les configurations possibles
Terminal
Architecture Client / Serveur native
Architecture Client / Serveur allégée
(émulation de terminal)
13
23/02/2015
1ère connexion
Les étapes d’une connexion
Pré-requis :
une machine Hôte tournant sous Unix
des postes clients connectés soit directement
(liaison série) soit par l’intermédiaire d’une
connexion réseau (carte réseau; et protocole
TCP/IP)
Connexion au serveur Unix par l'instruction :
telnet <serveur_Unix>
Création préalable des utilisateurs sur l’Hôte:
Utilitaire < smit sous AIX >, <sysadm> sous SCO ou
la commande <adduser> sous Linux etc . 27
1ère connexion
Étape 1/3 : connexion machine (login)
côté serveur:
chargement du noyau
lecture du fichier /etc/rc
attente de connexion des utilisateurs
côté client :
séquence login/password
information stockée dans le fichier
/etc/passwd 28
14
23/02/2015
1ère connexion
Étape 1/3 : connexion machine (login)
une entrée dans le fichier /etc/passwd contient:
nom de l ’usager: son login
mot de passe encrypté associé
UID
GID
commentaire
home directory (répertoire de travail)
programme à lancer après le login (shell)
1ère connexion
Étape 2/3 : la session de travail
initialisation du terminal
lecture du fichier /etc/motd
mise en place de l’environnement système
chargement du profil de l ’utilisateur
(lecture des fichiers .login et .cshrc)
attente des instructions en affichant un
prompt
15
23/02/2015
1ère connexion
Étapes 3/3 : déconnexion (logout)
Fermeture de session
‘logout’ ou ‘exit’ ou ‘ctrl+d’
Remarques :
Configuration de l’environnement utilisateur
Introduction des commandes nécessaires dans
un fichier du répertoire de connexion:
fichier .profile : utilisateurs du Bourne ou Korn Shell,
fichiers .login et .cshrc : utilisateurs du C Shell
1ère connexion
Les premières commandes Unix:
syntaxe : <commande> <liste d’arguments>
distinction entre majuscules et minuscules
importance du séparateur ‘ ‘
le manuel en ligne : man <commande Unix>
Application:
les premières commandes Unix
changement du mot de passe
changement de répertoire
16
23/02/2015
Programmation
par script
Plan
Le principe du script
Les commentaires
Exécution d’un script
Mise au point
Options du shell
Affichage de messages
Programmation
par script
Le principe du script
À réaliser $ cat le_script

1) signaler le démarrage echo début de la copie
2) sauver les fichiers tar cvf *.data
3) Détruire les temporaires rm *.tmp
4) Avertir que la sauvegarde echo copie terminée
est terminée
Exécution sh le_script
17
23/02/2015
Programmation
par script
Les commentaires
$ more le_script
#!/bin/sh
# Ce script sera exécuté par la comande
# /bin/sh
# Un commentaire se termine en fin de ligne
# @(#) Commentaire SCCS, affiché par la

# @(#) commande what
date # Affiche la date et l’heure
: pseudo commentaire, toujours vrai

Programmation
par script
Les commentaires
La commande what:
Package CSSC
Installer le package
what commande
18
23/02/2015
Programmation
par script
Exécution d’un script
Exécution d’un script grâce à sh (shell fils)

Cas 1: $ /bin/sh le_script
Cas 2: $ sh < le_script
Cas 3: $ ./le_script
Prérequis au cas 3: Création d’une nouvelle commande
$ chmod u+x le_script
$ le_script # la variable PATH doit être définie correctement
$ ./le_script
Exécution d’un script par le shell courant

$ . le_script
Programmation
par script
Mise au point
Activation/Désactivation du mode trace dans le

script
Syntaxe:
#!/bin/sh
set –x
# l’option x (eXtra output: affiche les étapes de subtitution
Commandes tracées
set –
# echo Revient au mode normal
19
23/02/2015
Programmation
par script
Mise au point
Activation/Désactivation du mode trace dans le

script
[user@localhost ~]$ ./ordonner
Exemple: /\
+ (( i=2 ))
+ (( i<=3 ))
#!/bin/bash + head -1
tail -1 losange + tail -2 losange
/ \
set -x + (( i++ ))
for ((i=2;i<=3;i++)) + (( i<=3 ))
+ head -1
do + tail -3 losange
tail -$i losange | head -1 / \
+ (( i++ ))
done + (( i<=3 ))
set - + set -
\/
head -1 losange [user@localhost ~]$
39
Programmation
par script
Mise au point
Exécution d’un script, affiche la trace des

commandes [user@localhost ~]$ bash -v ./ordonner
$ sh –v le_script #!/bin/bash
tail -1 losange
/\
# set -x
for ((i=2;i<=3;i++))
do
tail -$i losange | head -1
done
/ \
/ \
# set -
head -1 losange
\/
[user@localhost ~]$
$ sh –xv le_script 40
20
23/02/2015
La programmation
du shell
Mise au point
L’option x:
affiche les étapes de substitution, signalées par la ligne +
L’option v (verbose):
affiche la ligne telle qu’elle est écrite dans le script, avant que le
shell ne l’interprète
L’option n:
permet de seulement vérifier la syntaxe
L’option e:
provoque la fin d’exécution d’un script si une commande se
termine avec un code de retour différent de zero
Programmation
par script
Options du shell
Gestion des options

set –o # liste des drapeaux
set –o drapeau [shell_script] # lève un drapeau
set +o drapeau [shell_script] # abaisse un drapeau
21
23/02/2015
Programmation
par script
Options du shell
Principales options
ignoreeof Oblige utiliser exit et interdit usage ^D pour déconnecter
noclobber Interdit à une redirection > d’effacer un fichier
history Active l’historique dans le tampon (HISTSIZE)
vi utilise le mode vi de rappel de commandes
emacs utilise le mode emacs de rappel de commandes
bgnice exécute les tâches de fond avec une faible priorité
nounset génère erreur quand on utilise variable non définie
noglob n’interprète pas les jockers * et ?
verbose affiche l’entrée du shell en cours d’exécution
xtrace active le mode trace 43
Programmation
par script
Affichage de messages:
echo, print (ksh)
• La commande echo:
$ echo "Salut"; echo "Il est midi"
Salut
Il est midi
$ echo –e "Salut \c"; echo "Il est midi"
Salut Il est midi
• La commande print (ksh):

$ print "Salut"; echo "Il est midi"
Salut
Il est midi
$ print -n "Salut"; echo "Il est midi"
Salut Il est midi
22
23/02/2015
Programmation
par script
Exercices
Quel résultat produira l’exécution de la commande suivante!
$ # pwd
Avec une seule commande d’affichage, affichez sur deux lignes le

message suivant:
Bonjour
Quelle heure est-il?
Dans votre répertoire de connexion, écrivez un script de nom script1, qui

affiche la date et la liste des utilisateurs connectés
Donner toutes les syntaxes possibles pour exécuter le script créé dans
l’exercice précédent, sans fournir son chemin absolu. Le répertoire de
connexion est le répertoire courant, et le script est exécutable
Exécuter le script script1 en mode trace. Le script doit afficher le résultat
de l’interprétation de chaque ligne avant l’exécution de la commande
Mécanismes
de base
Plan
Les variables
L’environnement
Les paramètres d’un script
La commande read
Le remplacement de variables
Les tableaux
23
23/02/2015
Mécanismes
de base
Les variables
Les types de variables :

Variables prédéfinies:
lors de la connexion
Variables positionnelles:
paramètres d’un script
Variables spéciales du shell:
maintenues par le shell
Variables créées par l’utilisateur
Mécanismes
de base
Les variables
Syntaxe:
Déclaration:
variable=valeur
Utilisation:
variable2=$variable
variable2=${variable}
Liste des variables:
set/env
Suppression des variables:
2013-2014
unset nom Pr. M.D. El Kettani 48
24
23/02/2015
Mécanismes
de base
Les variables
Syntaxe:
$ nom=ALI
$ adresse="2 bd de France"
$ echo $nom
ALI
$ echo $adresse
2 bd de France
$ unset adresse
$ set
HOME=/home/ali
PATH=/bin:/usr/bin
PS1=$
nom=ALI
Mécanismes
de base
Les variables
Exemple:
$ vehicule=voiture
$ echo "un $vehicule, des $vehicules"
un vehicule, des
$ echo "un $vehicule, des ${vehicule}s"
un vehicule, des vehicules
$ transport="air mer terre"
$ echo $transport
air mer terre
$ unset vehicule transport
$ echo "vehicule = $vehicule et transport = $transport"
vehicule = et transport =
25
23/02/2015
Mécanismes
de base
L’environnement
Définition:
Ensemble des variables dont un shell
fournit une copie à la descendance
La commande export :
Syntaxe:
export [variable[=valeur]]
Exemple
Mécanismes
de base
L’environnement
Exemples:
$ vehicule=voiture; export vehicule
$ fleur=rose
$ set
…
$ env
…
$ sh
$ env
…
$ vehicule=bicyclette
$ exit
$ env
…
la valeur originale de vehicule a été conservée dans le 1er shell 52
26
23/02/2015
Mécanismes
de base
L’environnement
Exemples (suite):
Quelle est la sortie de cette exécution?
$ more environ
#!/bin/bash
echo "(a): $VAR_LOCALE"
echo "(b): $VAR_GLOBALE"
$ VAR_LOCALE=Logan
$ VAR_GLOBALE=Renaut
$ export VAR_GLOBALE
$ environ
…
Mécanismes
de base
Les variables d’environnement

Créées lors de la connexion:
LOGNAME le nom de l’utilisateur
HOME chemin d'accès au répertoire initial de l'utilisateur
PWD répertoire courant de travail
PATH suite de chemins d'accès aux répertoires des exéc.
PS1 invite principale du shell en mode interpréteur
PS2 invite secondaire du shell en mode programmation
IFS séparateurs de champ des arguments
MAIL=[chemin] fichier boîte aux lettres utilisateur
MAILPATH =[chemin]:[chemin] (remplace MAIL)
MAILCHECK intervalle en sec au bout duquel le mail est contrôlé
CDPATH liste de chemins d'accès pour la commande cd
ENV nom du fichier des variables d'environnement
TERM nom du type de terminal
TMOUT délai avant la fermeture automatique d’une fenêtre inactive 54
27
23/02/2015
Mécanismes
de base
Les variables d’environnement

La commande d’environnement:
env:
Affiche la liste des variables exportables
set:
Affiche la liste des variables existantes
Mécanismes
de base
Le profil d’utilisateur
Fichiers d'initialisation (Bash):

Initialisations communes: /etc/profile
Initialisations personnalisées:
.bash_profile .bashrc .bash_logout
Templates: /etc/skel
Autres shells:
C-shell: .login .cshrc .logout
Bourne shell, Korn shell & POSIX: .profile
Zsh: .zshrc
T-csh: .tcshrc 56
28
23/02/2015
Mécanismes
de base
/etc/profile (sous System V):

Initialisation commune à tous les login-shells
point de passage obligé pour tous les login
fourni par constructeur/adapté par administrateur
non modifiable par l'utilisateur
Mécanismes complémentaires dans /etc/profile.d
Exemple :
PATH=$PATH:/usr/local/bin; export PATH
ENV=~/.bashrc; export ENV
PS1=‘$PWD‘ " ! ùname –n` $ « ; export PS1
TMOUT=600
umask 077
set –o ignoreeof
set –o vi
2013-2014 set –o noclobber Pr. M.D. El Kettani 57
Mécanismes
de base
Cas du bash:
.bash_profile:
Exécuté à chaque ouverture de session
Initialisation propre à l'utilisateur
situé dans le HOME de l'utilisateur : ~/.profile
redéfinition des variables proposées par /etc/profile
définition de nouvelles variables (var=valeur)
détection si le shell est interactif ou non
exécution ou non de scripts d'initialisation
configuration des paramètres du terminal (stty)
peut-être "ressourcé" (. ou source):
. profile (sh, ksh, bash, zsh)
source .profile (bash)
29
23/02/2015
Mécanismes
de base
Cas du bash:
.bashrc:
Spécificité des shells zsh et bash
Exécuté à chaque appel de terminal
Initialisation propre à l'utilisateur
situé dans le HOME de l'utilisateur : ~/.zshrc ~/.bashrc
redéfinition du prompt PS1
définition des aliases
définition de fonctions
peut-être "ressourcé": ~/.bashrc ou source ~/.bashrc . ~/.zshrc
ou source ~/.zshrc
– Exemple: alias ls='ls -F' alias ll='ls -laF' 59
Mécanismes
de base
Cas du bash:
.bash_logout:
Fichier de clôture d'une session bash
effacement des fichiers temporaires,
clear écran
attente de déconnexion
30
23/02/2015
Mécanismes
de base
Cas du C-shell:
.login, .cshrc, .tcshrc, .logout (en csh ou tcsh):
.login : Fichier d'initialisation d'un login C-shell
interprété à chaque login
définition de nouvelles variables
peut-être "ressourcé" par source .login
.cshrc/.tcshrc : Fichier d'initialisation d'un Csh
réinterprété à chaque invocation du csh/tcsh
définition des aliases (shells interactifs)
peut-être "ressourcé" par source .cshrc/.tcshrc
.logout : Fichier de clôture d'une session C-shell
effacement des fichiers temporaires, clear écran
Exemple: setenv EDITOR emacs
Mécanismes
de base
62
31
23/02/2015
Mécanismes
de base
Exercice:
Identifier les fichiers d’initialisation de session
communs à tous les utilisateurs du système
Identifier les fichiers d’initialisation de session
propres à votre compte de travail
Identifier et afficher les alias disponibles par
défaut
Modifier votre profile de facon à inclure l’alias
« la=ls –a »
Mécanismes
de base
Les paramètres
Les variables positionnelles:

Définition:
$0 nom du script (pathname)
$1,…, $9, $10,… arguments (du 1er au 9ème, 10ème,…)
$# nombre de paramètres passés au script
$* liste de tous les arguments sous forme d’un seul argument
$@ liste tous les paramètres, un argument par paramètre
Exemples:
$ more param
echo "la commande :$0"
echo "1er paramètre :$1"
echo "2ème paramètre :$2"
echo "Tous les paramètre :$*"
echo "Nombre de paramètres :$#"
32
23/02/2015
Mécanismes
de base
Les paramètres

La commande shift: décale les paramètres de n positions vers la
gauche (par défaut 1)
Syntaxe: shift [n]
La commande set: remplace les paramètres du script par les
arguments de la commande, ainsi que les variables #, * et @
Syntaxe: set argument1 …
Exemple: $ set un deux trois; echo $*
un deux trois $ shift; echo $*; echo $1
$ shift; echo $*; echo $1; echotrois
$#
deux trois trois
deux $ shift; echo $#
2013-2014 1 Pr. M.D. El Kettani
0
65
Mécanismes
de base
Les paramètres

Exercice:
Ecrire un shell script Unix qui initialise un tableau semaine en y inserant les
jours de la semaine. Afficher sur une ligne a part chaque jour de la
semaine. Utiliser la boucle while
Completer le shell script precedent en initialisant 2 tableaux week et
semaine contenant les jours de la semaine en francais et en anglais.
Afficher les jours de la semaine en francais et leur traduction en anglais sur
une meme ligne
$ shift; echo $*; echo $1

trois
trois
$ shift; echo $#
0
33
23/02/2015
Mécanismes
de base
Les paramètres
Les variables spéciales du shell:

$? code retourné par la dernière commande
$$ numéro de processus de ce shell
$! numéro du dermier processus en arrière plan
$- drapeaux fournis au shell par set (options du shell)
Mécanismes
de base
L’instruction read
Définition :
Syntaxe: read variable …
L’instruction readonly:
Crée une variable qu’on ne peut plus supprimer ni
modifier
Syntaxe: readonly variable=valeur
34
23/02/2015
Mécanismes
de base
Remplacement de variables
Syntaxe:
variable=$var :remplacée par ‘$var’ si ‘var’  sinon par rien
variable=${var} :remplacée par ‘$var’ si ‘var’ ∃ sinon par rien
Forme recommandée, afin de se prémunir de certaines
incohérences en cas de concaténations de chaînes de caractères
variable=${var:-val} :remplacée par ‘$var’ si ‘var’ ∃ sinon par ‘val’
variable=${var:+val} :remplacée par ‘val’ si ‘var’ ∃ sinon aucune substit.
variable=${var:?msg}:remplacée par ‘$var’ si ‘var’ ∃ sinon affiche err.‘msg’
variable=${var:=val} :remplacée par ‘$var’ si ‘var’ ∃, sinon
remplacée par ‘val’ et var<−val
69
Mécanismes
de base
Exemple:
$ reponse=non
$ echo ${reponse:-oui}
non
$ unset reponse
$ echo ${reponse:-oui}
oui
$ echo ${reponse:=oui}
oui 70
35
23/02/2015
Mécanismes
de base
Exercice : quelle est la trace des commandes?

$ V=""
$ [ "$V" = "" ] && echo "La variable V est vide ou non définie"
La variable V est vide ou non définie
$ jour=Lundi
$ mois=Janvier
$ echo "${jour:-Dimanche}"
Lundi
$ echo "${saison:-Hiver}"
Hiver
$ echo "${mois:-Avril}"
Janvier
Mécanismes
de base
Exercice (suite):
$ echo "${saison:+Hiver}froid"
froid
$ echo "${jour:?jour_incorrect}"
Lundi
$ echo "${jour1:?jour_incorrect}"
jour1: jour_incorrect
$ echo "${mois:=Avril}"
Janvier
$ echo "${vacances:=Juillet}"
Juillet
$ echo "$vacances est un mois de vacances"
2013-2014 Juillet est un mois de vacances
Pr. M.D. El Kettani 72
36
23/02/2015
Mécanismes
de base
Les tableaux (ksh)
Syntaxe:
Création:
set –A nom_tab arg1 arg2 arg3 …
set –A nom_tab $(commande)
Affectation:
nom_tab[n]=argument
Remplacement d’un élément:
${nom_tab[n]}
Remplace tout le tableau:
${nom_tab[*]} ou ${nom_tab[@]}
Lit la taille du tableau:
${#nom_tab [*]}
Mécanismes
de base
Les tableaux (ksh)
Exemple:
$ set –A table bleu blanc vert
$ echo ${table[0]}
bleu
$ echo ${table[0..1]}
bleu blanc
$ table[1]=beige
$ echo ${table[*]}
bleu beige vert
$ echo ${#table[*]}
3
37
23/02/2015
Mécanismes
de base
Les tableaux (ksh)
Exercice : quelle est la trace des commandes?

$ set –A fleurs Rose Tulipe Iris Jasmin
$ echo "${fleurs[*]} sont des noms de fleurs"
Rose Tulipe Iris Jasmin sont des noms de fleurs
$ echo "${fleurs[@]} sont des noms de fleurs"
Rose Tulipe Iris Jasmin sont des noms de fleurs
$ echo "Les ${fleurs[0]}s ont des épines"
Les Roses ont des épines
$ echo "J’ai ${#fleurs[*]} types de fleurs"
J’ai 4 types de fleurs
$ fleur[4]=Bégonia
$ echo "${fleurs[@]} sont des noms de fleurs"
Rose Tulipe Iris Jasmin Bégonia sont des noms de fleurs
$ echo "J’ai maintenant ${#fleurs[*]} types de fleurs"
2013-2014
J’ai 5 types de fleurs Pr. M.D. El Kettani 75
Mécanismes
de base
Les tableaux (ksh)
Exercice :
Dans le tableau fleur, inserer entre les positions 2 et 3 le type
marguerite
38
23/02/2015
Mécanismes
de base
Exercices
Écrire un shell script qui affiche les processus d’un utilisateur dont le nom est
passé à travers une variable d’environnement (par exemple LOGNAME)
Ecrire un shell script qui modifie la valeur de la variable d’environnement TZ
(timezone) en lui affectant par exemple la valeur GMT, et qui affiche ensuite
l’heure système. Après exécution, afficher de nouveau l’heure système, que
constatez vous?
Écrire un shell script qui génère des noms de fichiers différents à chaque
exécution, mais qui commencent par la racine du fichier
Écrire un script qui recherche un fichier dans une arborescence. Le nom du fichier
et la racine de l’arborescence doivent être passés en paramètre, dans cet ordre.
On suppose que le nombre et le type des paramètres sont corrects, le script n’en
effectue pas le contrôle
En utilisant la variable IFS, écrivez un script qui demande la saisie d’une date au
format jj/mm/aa (une seule chaine) et qui récupère cette dernière dans trois
variables: jour, mois et an
Comment appeler un script qui attend un seul paramètre avec comme argument
une chaine qui comporte des espaces (l’espace est un délimiteur!)
Fonctionnement
en interactif
Plan
Les jokers
Les caractères d’échappement
Les redirections et les tubes
Le remplacement de commandes
Les caractères spéciaux
39
23/02/2015
Fonctionnement
en interactif
Les jokers
Exemple:
$ ls
file1 file2 file23 file43
$ echo * *
file1 file2 file23 file43
?
{
$ echo file2* [aep]
file2 file23 [a-p]
[…]
$ echo file?3 [!aep]
file23 file43 [!a-p]
$ echo file[1234] # ou echo file[1-4]
file1 file2
Fonctionnement
en interactif
Les jokers
Exercice: Quelle est la trace des commandes suivantes?

$ ls -c
auto exercice f1 f2 f3
fichier.txt lisezmoi.txt p1 r1 s1
$ echo *
auto exercice f1 f2 f3 fichier.txt lisezmoi.txt p1 r1 s1
$ echo f* $ echo f[0-9]
f1 f2 f3 fichier.txt f1 f2 f3
$ echo f? $ echo f[!0-9]*
f1 f2 f3 fichier.txt
$ echo [aep]* $ echo *.dat
auto exercices p1 *.dat
$ echo [!aep]* # pas de remplacement de jockers
f1 f2 f3 fichier.txt lisezmoi.txt r1 s1 # car aucun nom de fichier ne
# correspond au modèle
40
23/02/2015
Fonctionnement
en interactif
Exemple: Protège tous les caractères sauf lui-même '

$ echo \* \~ \$ \\
*~$\
$ echo '* ~ $ \' \
*~$\
$ echo "~ * ' " '...'
~*'
$ echo " ‘echo‘ un \" $PS2" "…"
un " >
Protège tous les caractères sauf $, \, ‘ et lui-même "
Fonctionnement
en interactif

$ echo \\
\ $ echo " ' "
$ echo bon\ '
>jour $ echo ' " '
bonjour "
$ ls -c
exercices f1 f2 f3
fichier.dat lisezmoi.txt p1 r1 s1
$ echo le caractère * est un joker
le caractère exercices f1 f2 f3 fichier.dat lisezmoi.txt p1 r1 s1 est un joker
$ echo le caractère \* est un joker
le caractère * est un joker
$ echo "Pressez la touche <Entrée> pour continuer"
Pressez la touche <Entrée> pour continuer
$ echo 'Le prompt primaire est le caractère $, le prompt secondaire est le caractère >' >‘
Le prompt primaire est le caractère $, le prompt secondaire est le caractère > 82
41
23/02/2015
Fonctionnement
en interactif
Les fichiers d’E/S Standards :

Toutes les commandes utilisent les canaux
d’E/S pour lire ou transmettre leur résultat.
Ces canaux portent des noms spéciaux :
Canal d’entrée standard (0) : Clavier par défaut
Canal de sortie standard (1) : Écran par défaut
Canal de sortie erreur standard (2) : Écran par dft
Unités clavier-écran = périphériques,
(gérés par Unix en tant que fichiers spéciaux)
Fonctionnement
en interactif
Les fichiers d’E/S Standards :

En interne, toute écriture (resp. lecture) sur
le canal de la sortie (l’entrée) se traduit par
une écriture (lecture) dans le fichier spécial
associé.
Une des principales caractéristiques du shell
Définition:
Remplacement des fichiers spéciaux d’E/S
standard par d’autres fichiers normaux
(texte)
42
23/02/2015
Fonctionnement
en interactif
Les redirections (>, 1>, >>):

$ date > un_fichier >
$ more un_fichier
Sat Mar 15 11:11:11 GMT 2014 >>
$ who am i 1> un_fichier
$ more un_fichier <
ali tty01 Mar 15 11:11
$ date >> un_fichier 2>
$ more un_fichier
Sat Mar 15 11:11:11 GMT 2014 |
Fonctionnement
en interactif

$ who am i > fsortie
$ cat fsortie
ali tty03 mar 11:11:11
$ date '+Heure:%T' # Affiche l’heure précédée du message « Heure: »
Heure: 11:11:11
$ date '+Heure:%T‘ > fsortie
$ cat fsortie
Heure:11:11:11
$ echo "Liste des utilisateurs connectés" >> fsortie
$ who >> fsortie
$ cat fsortie
Heure:11:11:11
Liste des utilisateurs connectés
root tty01 mar 19 11:11
43
23/02/2015
Fonctionnement
en interactif
Les redirections (<, 0<):

$ write ali
La commande write permet de communiquer avec un autre utilisateur
en copiant les lignes de l’entrée standard sur son terminal, si ce dernier
l’a autorisé en utilisant la commande mesg –y
Ctrl-D
$ cat > message
Bonjour Ali ,
comment vas-tu?
Ctrl-D
$ write ali 0< message
Fonctionnement
en interactif

$ mail brahim # le message doit être saisi au clavier
Subject: Voeux
Bon travail
Et à bientôt
^D
$ cat > vœux # le message est enregistré dans le ficher voeux
Bon travail
Et à bientôt
^D
$ mail brahim <vœux # l’entrée de la commande mail est redirigée vers voeux
$ mail ali < voeux
$
44
23/02/2015
Fonctionnement
en interactif
Les redirections (<<):

Syntaxe : $ Commande << chaine
Permet d’envoyer à « commande » toutes les lignes
tapées en entrée, jusqu'à la chaîne saisie, méthode du
"here document"
Exemple :
$ wc -l << fin
"collez quelque chose avec la souris"
fin
Permet de compter le nombre de lignes
1
dans la chaîne saisie avant « fin ».
$
Fonctionnement
en interactif
Les redirections (2>):

$ ls –l /etc/group XYZ
ls: XYZ: No such file or directory
-rw-r--r-- 1 root root 288 Mar 22 2014 /etc/group
$ ls –l /etc/group XYZ 2> erreur

$ more erreur
$ ls –l /etc/group XYZ > sortie 2>&1

$ more sortie
90
45
23/02/2015
Fonctionnement
en interactif
Les redirections (2>>):

$ cc programme.c 2>> erreurs
Erreurs de compilation de programme.c redirigées vers le fichier erreurs.
• Syntaxe de redirection de fichiers:

descripteur>
descripteur>>
>&descripteur
>>&descripteur
Fonctionnement
en interactif

$ ls –l /etc/passwd /etc/password
ls : /etc/password not found: No such file or directory (error 2)
-rw-rw-r– 1 bin auth 1000 oct 17 12:12 /etc/passwd
$ ls –l /etc/passwd /etc/password 2> /dev/null
$ ls –l /etc/passwd /etc/password 2> fic.err
$ cat fic.err
$ ls –l /etc/passwd /etc/password > fic.out 2>&1 # mixe sortie et erreur
$ cat fic.out
46
23/02/2015
Fonctionnement
en interactif
Les redirections, les tubes (|):

Exemple:
$ who | wc - l (**)
who : liste de personnes connectés au système.

wc -l nom_fichier : Compte le nombre de lignes de ‘nom_fichier’.
La séquence (**) permet de compter le nombre de personnes

connectés, elle est équivalente à la ligne de commande suivante:
$ who>tmp ; wc -l tmp ; rm tmp
Fonctionnement
en interactif

La commande tee :
En utilisant des filtres le résultat de la commande1
n’est pas visualisé à l’écran, pour pouvoir le visualiser
on utilisera des tuyaux : commande tee.
Syntaxe:
$ commande1 | tee fichier1 | commande2
Redirige le résultat intermédiaire de commande1 vers
fichier1. Ce même résultat sera traité par la commande
commande2.
47
23/02/2015
Fonctionnement
en interactif

La commande tee
Exemple:
$ ls | grep poème | tee fichier1 | wc -l
1 2 3 4
1: Liste des fichiers dans le répertoire courant
2: Recherche des noms de fichiers qui contiennent la chaîne
de caractères poème.
3: Met le résultat de la commande précédente dans fichier1
4: compte le nombre de lignes ramenés par grep.
Fonctionnement
en interactif
Les redirections (>|) ksh:

$ set +o noclobber # par défaut
$ date > un_fichier
$ who am i > un_fichier
$ more un_fichier
$ set –o noclobber
$ cal > un_fichier
ksh: cannot create un_fichier: file exists
$ cal >| un_fichier

Pr. M.D. El Kettani 96
2013-2014 $
48
23/02/2015
Fonctionnement
en interactif

$ cat fsortie
ali tty03 mar 11:11:11
$ set –o noclobber # interdit l’écrasement en redirection avec le caractère >
$ date '+Heure:%T' # Affiche l’heure précédée du message « Heure: »
Heure: 11:11:11
$ date '+Heure:%T‘ > fsortie # %T affiche l’heure
Sh: File already exists
$ date '+Heure:%T‘ >| fsortie # force l’écrasement d’un fichier existant
$ cat fsortie
Heure:11:11:11
$ set +o noclobber
$ echo "Liste des utilisateurs connectés" >> fsortie
$ cat fsortie
root tty01 mar 19 11:11 97
Fonctionnement
en interactif
xargs et sh:
La commande xargs peut aider à exécuter un
flux:
-t pour avoir l'écho des commandes et -n pour
découper le flux d'entrée en paquets :
Exemple: $ xargs -t -n 2 diff <<fin
fic1 fic2 fic3
fic4 fic5 fic6
fin
diff fic1 fic2
diff fic3 fic4
diff fic5 fic6 Pr. M.D. El Kettani 98
2013-2014
49
23/02/2015
Fonctionnement
en interactif
xargs et sh:
La commande xargs peut aider à exécuter un
flux :
-i pour insérer le flux :
Exemple:
$ ls | xargs -t -i{} mv {} {}.old
mv chap1 chap1.old
mv chap2 chap2.old
mv chap3 chap3.old
Fonctionnement
en interactif
Le remplacement de
commandes
Exemple:
$ echo la date
la date
$ echo "date = `date`"

date = Sat 15 11:11:11 GMT 2014
$ echo "date = $(date)"

date = Sat 15 11:11:11 GMT 2014
2013-2014 Pr. M.D. El Kettani 100
50
23/02/2015
Fonctionnement
en interactif
Le remplacement de
commandes
$ cd ~ali
$ echo "`pwd` est le répertoire courant"
/home/ali est le répertoire courant
$ echo "$(pwd) est le répertoire courant"
/home/ali est le répertoire courant
$ cat > liste
ali
brahim
^D
$ mail `cat liste‘ # courrier pour ali et brahim
$ echo "Nombre de fichier du répertoire: \c `ls | wc –w`"
Nombre de fichier du répertoire: 24
$ echo "Utilisateurs connectés\n `who | cut –d ' ' –f1`"
Utilisateurs connectés
root
ali
brahim
101
Fonctionnement
en interactif
Panorama des
caractères spéciaux
Jockers:
*,?,[…]
Échappement
\, ‘…’, "…"
Redirection
<,0<,>,1>,2>,>>,<<,|
Groupement de commandes
;, &, &&, ||, (…), {…}
Divers
:, #,$,’…’,~ Pr. M.D. El Kettani 102
2013-2014
51
23/02/2015
Fonctionnement
en interactif
Exercices
Affichez la liste des fichiers du répertoire /usr/bin dont le nom est composé
d’au moins 3 caractères, le premier parmi les lettres a, s et t, le 3ème compris
entre a et f
Afficher de 3 facons différentes le message suivant:
Les caractères " et ' sont des délimiteurs de chaînes de caractères.
En utilisant les redirections, créez un fichier de nom mon_an.naiss contenant
le texte:
Le calendrier de mon année de naissance
Ajoutez au fichier mon_an.naiss le calendrier de votre année de naissance.
Envoyez le contenu du fichier mon_an.naiss dans votre boîte aux lettres.
Réalisez la même opération que dans l’exercice précédent, avec une autre
syntaxe.
Dans l’arborescence des utilisateurs (/home par exemple), affichez les noms
de tous les fichiers dont vous êtes propriétaire, en éliminant l’affichage
2013-2014
d’éventuels messages d’erreur.Pr. M.D. El Kettani 103
Construction de
scripts portables
Plan
Introduction
Code de retour
Programmation des choix &&, ||, if, case
Boucles while, until et for
Instructions liées aux boucles break,
continue
Chaînes de caractères
104
52
23/02/2015
Construction de
scripts portables
Introduction
Familles de commandes avancées:

Sélection
Aiguillage
Itération
Rupture de boucle
Commande de test
105
Construction de
scripts portables
Le code retour
$ ( echo OK ; exit 0 )
OK
$ echo $?
0
$ ( echo ERREUR ; exit 1 )

ERREUR
$ echo $?
1
$ ! ( echo inversion du code retour ; exit 2 )

inversion du code retour
$ echo $?
0 106
53
23/02/2015
Construction de
scripts portables
Programmation des choix
Sélection
Syntaxe :
Condition simple: if then ... fi
if commande ; then
liste de commandes
fi
Condition avec alternative: if then ... else ... fi
if commande ; then
liste de commandes
else
liste de commandes
fi
107
Construction de
scripts portables
Sélection
Syntaxe :
Condition multiple: if then ... elif then ... fi
if commande ; then
liste de commandes
elif commande ; then
liste de commandes
else
liste de commandes
fi
108
54
23/02/2015
Construction de
scripts portables
Sélection
Syntaxe :
Conditions multiples:
if [ condition1 ]||[ condition2 ] then ... else … fi
if [ condition1 –o condition2 ] then ... else … fi
if [ condition1 ] && [ condition2 ] then ... else … fi
if [ condition1 –a condition2 ] then ... else … fi
109
Construction de
scripts portables
Exemple:
if cmp $1 $2
then
echo fichiers
echo identiques
else
echo fichiers
echo différents
fi
110
55
23/02/2015
Construction de
scripts portables
Exercice: quelle est la sortie de l’exécution de la séquence suivante?

$ if grep ali /etc/passwd ; then
> echo "Ali possède un compte utilisateur dans ce système"
> fi
$ ls f?
f1 f2
$ cat f1
Bonjour
$ cat f2
Bonjour
$ if cmp f1 f2
> then
> echo "Les fichiers f1 et f2 sont identiques"
> echo "Suppression du fichier f2"
> rm f2
> fi
$ ls f?
111
Construction de
scripts portables
Exercice: quelle est la sortie de l’exécution de la séquence suivante?

$ if grep ali /etc/passwd ; then
> echo "Ali possède un compte utilisateur dans ce système"
> fi
Ali:x:501:Ali ALI:/home/ali:/bin/bash
Ali possède un compte utilisateur dans ce système
$ ls f?
f1 f2
$ cat f1
Bonjour
$ cat f2
Bonjour
$ if cmp f1 f2
> then
> echo "Les fichiers f1 et f2 sont identiques"
> echo "Suppression du fichier f2"
> rm f2
> fi
Les fichiers f1 et f2 sont identiques
Suppression du fichier f2
$ ls f?
f1 112
56
23/02/2015
Construction de
scripts portables
L’alternative avec
les opérateurs && et ||
Syntaxe:
cmd1 && cmd2
if cmd1 ; then cmd2 ; fi
cmd1 || cmd2
if cmd1 ; then : else cmd2 ; fi
113
Construction de
scripts portables
Exemples:
cmd1 && cmd2
if cmd1 ; then cmd2 ; fi
cmd1 || cmd2
if cmd1 ; then : else cmd2 ; fi
114
57
23/02/2015
Construction de
scripts portables
Exemples:
$ ls
f1 f2 exercices
$ ls newrep
ls: newrep not found
$ ls newrep || mkdir newrep
ls: newrep not found
$ ls -ld newrep
drwxr-xr-x 2 ali ali 512 déc 12 12:22 newrep
$ ls f1 || echo "Fichier f1 inexistant"
$
$ ls f1 >/dev/null && echo "Fichier f1 existe"
Fichier f1 existe
$ ls fnonexiste 2>/dev/null || echo "Fichier inexistant"
115
$
Construction de
scripts portables
La commande test
Syntaxe de la commande test (utilisée avec if):
• if test option ; then … fi
• if [ option ] ; then … fi
Principales options (test sur les attributs de fichiers):
test -b fichier, test -c fichier, test -d fichier, test -e fichier, test -f fichier,
test -L fichier, test -r fichier, test -s fichier, test -w fichier, test -x fichier
Exemple : if [ ! -d repert ]; then mkdir repert ; fi
Principales options (comparaison de chaines de caractères):
-z chaine (chaine nulle) -n chaine (chaine non nulle)
chaine1 = chaine2 chaine1 != chaine2
Comparaisons alphanumériques
test "$str1" = "chaine1" test "$str1" != "chaine1"
test "$str1" > "chaine1" test "$str1" < "chaine1" 116
test "$str1" >= "chaine1" test "$str1" <= "chaine1"
58
23/02/2015
Construction de
scripts portables
La commande test
Comparaisons algébriques
-eq : Exemple: $? -eq 0
-ne
-gt
-lt
-ge
-le
Opérateurs booléens
!
-a : Syntaxe: Expr.Logique1 –a Expr.Logique2 (and)
-o : Syntaxe: Expr.Logique1 –o Expr.Logique2 (or)
117
Construction de
scripts portables
La commande test
Exemple:
$ test –r $HOME/.profile # [ -r $HOME/.profile ] $ test_rep /bin/ls
$ echo $? Suite du programme
0 $ cat > reponse
$ grep ali /etc/passwd echo "Saisissez votre nom: \c"
$ if [ $? –eq 0 ] read nom
then if [ "$nom" != "" ]
echo "Ali possède un compte sur ce système" then
fi echo "Bienvenue Mme ou Mr $nom"
$ cat > test_rep else
# vérifie si le premier argument est un répertoire echo "Vous n’avez rien saisi"
if [ -d "$1" ] fi
then $ chmod u+x reponse
echo "$1 est un répertoire" $ reponse
fi Saisissez votre nom: Ali
echo "Suite du programme" Bienvenue Madame ou Monsieur Ali
^D $ reponse
$ chmod u+x test_rep Saisissez votre nom:
$ ./test_rep /etc Vous n’avez rien saisi
/etc est un répertoire
Suite du programme 118
59
23/02/2015
Construction de
scripts portables
Aiguillage
Aiguillage: case in … esac
Syntaxe:
case $variable in
motif1) liste de commandes ;;
[motif2) liste de commandes ;; …]
*) liste de commandes ;;
esac
Exemple :
case $# in
1) arg1=$1;;
2) arg1=$1; arg2=$2 ;;
0) echo "usage: $0 arg1 [ arg2 ] exit 1;;
esac 119
Construction de
scripts portables
Aiguillage
Exercice: que fait le script suivant?
$ cat > supprime
echo "Voulez-vous supprimer le fichier FICHIER?"
read reponse
case "$reponse" in
O*|o* ) rm FICHIER
echo "le fichier FICHIER est supprimé"
;;
N*|n* ) echo "le fichier FICHIER n’est pas supprimé"
;;
* ) echo "réponse incorrecte"
;;
esac
120
60
23/02/2015
Construction de
scripts portables
Itération
Itération: Boucle while do ... done

Syntaxe:
while commande
do
liste de commandes
done
Exemple:
while [ ! –f fic ]
do
sleep 10
done
echo fichier existe 121
Construction de
scripts portables
Aiguillage
$ cat > trouve_mot
# Boucle tant qu’on ne saisi pas le mot fin
echo "Entrez un mot: \c"
read mot
while [ "$mot" != "fin" ]
do
echo "Ce n’est pas le bon mot!"
read mot
done
echo "Vous avez trouvé, Bravo!!!!"
^D
122
61
23/02/2015
Construction de
scripts portables
Itération
Itération: Boucle until do ... done

Syntaxe:
until commande
do
l iste de commandes
done
Exemple:
until [ –f fic ]
do
sleep 10
done
echo fichier existe
123
Construction de
scripts portables
Aiguillage
$ cat > trouve_mot
# Boucle tant qu’on ne saisi pas le mot fin
read mot
until [ "$mot" = "fin" ]
do
echo "Ce n’est pas le bon mot!"
read mot
done
echo "Vous avez trouvé, Bravo!!!!"
^D
124
62
23/02/2015
Construction de
scripts portables
Itération
Itération: Boucle for do ... done

Syntaxe:
for var [ in ListeDeValeurs ]
do
liste;
done
Exemple:
for var in un deux trois
do
echo "var = $var"
done
Exercice:
récrire l’exemple précédent en utilisant la boucle for ((..))
125
Construction de
scripts portables
Les sauts inconditionnels
Instructions de rupture de boucle

Sortie de boucle : break [n]
sortir d'une ou n boucles for, while, until
donne le contrôle à la commande qui suit done
n = niveau de boucle à partir de la boucle la plus externe
continuation de boucle: continue [n]
interrompt exécution commande boucle for, while, until
donne le contrôle au début de la boucle
n = niveau de boucle à partir de la boucle la plus externe
Break et continue doivent être conditionnées par if ou
commandée par && ou ||
126
63
23/02/2015
Construction de
scripts portables

Syntaxe : Syntaxe:
while … ; do for var1 in ${liste1}
… do
for var2 in ${liste2}
if …; then do
continue if cmd2 ;
fi then
continue 2
if …; then fi
break done
fi done
… Sortie de programme: exit n
done sortir d'un script-shell avec un
… code de retour (n)
127
Construction de
scripts portables

Exemple: Quelle est la sortie du script suivant?
#!/bin/bash
liste1="a b c d e f"
liste2="1 2 3 4 5 6"
do
echo $var1
do
echo $var2
echo -n "voulez-vous continuer ? (Oui/Non) "
read a
if [ $a = Oui ]
then
continue 2
fi
echo "fin var2"
done
echo "fin var1" 128
done
64
23/02/2015
Construction de
scripts portables

$ cat > cree_fic3
# ignore les lignes blanches
while :
do
echo "Entrez une ligne d’au moins un caractère <fin> = quitter : \c"
read ligne
if [ -z $ligne ]
then
continue # n’enregistre pas les lignes blanches
fi
if [ $ligne = "fin" ]
then
break
fi
echo "$ligne" >> fic.lig3
done 129
^D
Construction de
scripts portables
Exercices
Écrire un Shell script UNIX ‘datef’, qui donne la date en français
Écrire un Shell script UNIX ‘ou_suis_je’, qui vous indique si vous vous trouvez
dans votre répertoire de travail par défaut ou pas
Écrire un Shell script UNIX ‘modfi’, qui prend un nom de fichier en entrée (au
clavier), et répond s’il peut être lu, écrit, ou exécuté (envisager les messages
d’erreur)
Ecrire un shell script Unix qui prend un nom de fichier en argument et
repond s'il peut etre lu, ecrit, execute. Il verifie si le fichier en question existe
ou pas. Le shell script affiche un message d'erreur si mauvaise utilisation de
modfi
Reprendre l’exercice précédent en respectant la syntaxe suivante, qui permet
de passer en revue deux arguments :
syntaxe : modfi2 [repertoire] fichier
130
65
23/02/2015
Construction de
scripts portables
Exercices
Écrire un Shell script UNIX ‘taille’, qui affiche la liste des répertoires
contenus dans un répertoire saisi en paramètre, ainsi que leur taille en ko :
en changeant de répertoire
sans changer de répertoire
Écrire un Shell script qui affiche le type d’un fichier, dont le nom est saisi
au clavier, qui demande si l’on veut continuer et ne s’arrête que lorsque
l’on répond « non » ou « NON »
Modifiez l’exercice précédent afin qu’il ne traite pas les fichiers qui ne sont
pas accessibles en lecture ou qui sont des répertoires
Écrire un script qui affiche les processus d’un utilisateur dont le nom est
passé en argument, et qui en l’absence de ce dernier, affiche la syntaxe
d’appel et renvoie 2 comme code de retour
Écrire un script qui demande la saisie du nom d’un interpréteur UNIX
(choix limité à sh, csh, ksh, rsh, rksh et bash), et qui affiche son nom
131
complet (shell bourne, Korn shell, etc.)
Construction de
scripts portables
Exercices
Écrire un shell script qui lance l’exécution d’un script dont le nom est
passé en paramètre, que ce dernier ait l’attribut d’exécution (droit x),
ou pas
Ecrire un shell script nbl affichant à partir d’un répertoire lu en
argument, la liste de tous les liens ordinaires liés à un fichier dont le
nom est lu en argument.
Ecrire un shell script nbl affichant à partir d’un répertoire lu en
argument, la liste de tous les liens symboliques liés à un fichier dont le
nom est lu en argument.
Ecrire une commande arbre qui liste soit tous les fichiers, soit
seulement les répertoires (avec l’option –d) du sous-arbre ayant pour
racine le répertoire spécifié, ou par défaut, le répertoire courant.
Ecrire un shell script Unix effacant tous les fichiers du répertoire
courant sauf 1 dont le nom est lu en argument.
132
66
23/02/2015
Construction de
scripts portables
Exercices
Ecrire une commande shell permettant de renommer une liste de fichiers
du répertoire de travail, en obéissant aux conditions suivantes:
On supposera que les références des fichiers à changer sont données en
paramètre de la commande, et plus précisément sont tous les paramètres à
partir du second.
Les nouvelles références seront obtenues à partir du préfixe commun donné
en premier argument, le suffixe étant constitué par un entier entre 1 et n, si n
est le nombre de fichiers à renommer.
Exemple : rename f g h i j va renommer g en f1, h en f2, i en f3 et j en f4. On
veillera à ce que la commande ne renomme que les fichiers ordinaires. On
veillera par ailleurs que si la commande n’a qu’un seul paramètre, tout le
répertoire de travail est traité. Enfin, on supposera qu’aucun nouveau nom ne
correspond à un lien existant dans le répertoire de travail.
133
Construction de
scripts portables
Exercices
Ecrire une commande shell appelable soit sans arguments, soit avec 3
arguments, et telle que, appelée sans argument, elle réalise la lecture au
clavier de 3 chaînes de caractères. Disposant alors dans tous les cas de
trois chaînes, elle indique si les trois chaînes sont identiques, ou si elles
sont toues différentes par un message sur la sortie standard. Le code de
retour de la commande est égal à 0 si les trois chaînes sont égales, 1 2
ou 3 selon que la chaîne en ième position est différente des deux autres,
4 si les trois chaînes sont différentes, et 5 si le nombre de paramètres est
incorrect.
134
67
23/02/2015
Mécanismes
complémentaires
Plan
Chaines de caractères:
Manipulations de chaînes (expr)
Expressions de variables
Extraction de chaînes
Expressions spécifiques du Korn Shell
Commandes dirname, basename
Arithmétique:
Commande expr
Arithmétique en ksh
La commande bc
135
Mécanismes
complémentaires
Les chaînes de caractères

expr: manipulation de chaînes
Calcul de la longueur d’une chaîne
expr chaîne: ".*"
Exemple:
$ expr "bonjour" : ".*"
7
Extraction d’une sous-chaîne
$…$
Exemple:
$ temps="Il fait beau" $ chemin=/usr/bin/ls
$ expr "$temps" : "$..$" $ expr "$chemin" : ".*/$.*$"
Il ls
$ expr "$temps" : ".*$….$" $ expr "$chemin" : "$.*$/"
beau /usr/bin
136
68
23/02/2015
Mécanismes
complémentaires
Expressions de variables:
var: chaine de caractères
str : modèle de chaîne
Syntaxe:
variable=${#var} : longueur en octet de la chaîne var
Suppression en début d’une chaîne:
variable=${var#str} : supprime en début de var la + petite des 2 chaînes
variable=${var##str} : supprime en début de var la + grande des 2 chaînes
Suppression en fin d’une chaîne:
variable=${var%str} : supprime en fin de var la + petite des 2 chaînes
variable=${var%%str} : supprime en fin de var la + grande des 2 chaînes
137
Mécanismes
complémentaires
Expressions de variables:
Exemples:
$ fic=/usr/local/bin/emacs
$ fic=/usr/local/bin/emacs $ user=`grep ali /etc/passwd`
$ echo ${fic##/*/} emacs
emacs
$ echo $user
$ echo ${fic#/*/} ali:501:501:Ali Benbrahim:/home/ali:/bin/bash
local/bin/emacs
$ echo ${fic##/*/}
$ echo ${fic%/*} emacs
/usr/local/bin
$ echo ${user%%:*:}
$ echo ${fic%%/*} ali
$ echo ${fic#/*/}
$ local/bin/emacs 138
69
23/02/2015
Mécanismes
complémentaires
Extractions de chaînes avec typeset (ksh):

Extraction de la partie gauche d’une chaîne
Syntaxe: typeset –Lnbcar chaine (nb_car caractères éliminés à gauche)
$ typeset –L4 A=abcdefgh
$ echo $A
abcd
Extraction de la partie gauche, on saute les blancs
Syntaxe: typeset –LZnbcar chaine (nb_car car. éliminés à gauche + sauter les blancs)
$ typeset –LZ3 A=" abcdefgh"
$ echo $A
abc
Extraction de la partie droite d’une chaîne
Syntaxe: typeset –Rnbcar chaine (nb_car caractères éliminés à droite)
$ typeset –R4 A=abcdefgh
$ echo $A
efgh 139
Mécanismes
complémentaires
Commandes basename et dirname:

Syntaxe:
basename chemin [suffixe]
dirname chemin
Exemples:
$ ediiteur=/usr/local/bin/vi
$ nom_fic=`basename $editeur`
$ rep=`dirname $editeur`
$ echo "Repertoire: $rep\nNom de fichier: $nom_fic"
Répertoire:/usr/local/bin
Nom de fichier: vi
$ basename /home/ali/prog.c # l’extension .c n’est pas supprimée
prog.c
$ basename /home/ali/prog.c .c # supprime aussi l’extension .c
prog
140
70
23/02/2015
Mécanismes
complémentaires
Quelques astuces:
Concaténation de chaînes
$ A=bon
$ B=$(A)jour
Utilisation de commandes sed, grep et cut
$ uid=$(id | sed 's/^[^=]*=//' | sed 's/(.*//')
$ root=$(grep '^root' /etc/passwd | cut –f3 –d:)
Élimination d’une répétition d’espaces dans la sortie
d’une commande
$ who | tr –s " " | cut –d " " –f2 # affiche les terminaux
Utilisation des paramètres positionnels
$ A=$(grep '^root' /etc/passwd)
$ ( IFS=: ; set $A; echo $3)
141
0
Mécanismes
complémentaires
Exercices:
Afficher le nombre de caractères de la chaîne contenue dans votre
variable PATH
Créer dans votre répertoire de connexion un sous-répertoire de
nom bin et rajoutez ce dernier à votre variable PATH (en dernière
position)
En utilisant les expressions régulières, extrayez le dernier chemin
de la liste de chemins stockée dans la variable PATH
Traitez l’exercice précédent avec une solution spécifique au Korn
shell (autre que les expessions régulières)
Écrivez un scripte qui doit être exécuté par un Korn shell, et qui
demande la saisie d’une chaîne comportant au maximum huit
caractères; le cas échéant le script doit éliminer les caractères en
trop et ne garder que les huits premiers.
142
71
23/02/2015
Mécanismes
complémentaires
Arithmétique
Arithmétique
Commande Unix expr
expr val1 oper val2
opérations : +, -, *, /, %
utilisation : substitution de commande en sh
peu performant : nécessite un fork()-exec()
Commande Shell (ksh, bash, zsh)
$[expression]
interne au shell -> performant
143
Mécanismes
complémentaires
Arithmétique
Expression
() parenthèse pour forcer une évaluation
+ addition - soustraction
/ division * multiplication
> supérieur < inférieur
>= supérieur <= inférieur
== égalité != inégalité
~ complément à 1 ! complément logique
% modulo ^ disjonction exclusive bit à
bit
>> décalage à droite << décalage à gauche
& conjonction bit à bit | disjonction bit à bit
&& conjonction || disjonction 144
72
23/02/2015
Mécanismes
complémentaires
Arithmétique
Arithmétique
Exemple: +,-,*,/,%
$ expr 3 + 2 =,<,<=,>,>=,!=,
5 |,&
$ expr 2 \* 5
10
$ a=3
$ a=$(expr $a + 1)
$ echo $a
4
145
Mécanismes
complémentaires
Arithmétique
Arithmétique (ksh)
Exemple:
+,-,*,/,%
$ integer a b c=5
$ ((a=32)) <<,>>,
$ let b=a+1 <,<=,>,>=,==,!=,
$ print $a, $b |,&&,
32,33 ||
$ let a='c<<2' ,^
$ let b='2#101' c='16#FF'
$ print "$b, $c"
5,255
$ echo $a
20 146
73
23/02/2015
Mécanismes
complémentaires
Arithmétique
Arithmétique: les boucles

Avec expr:
#!/bin/sh
I=0
while [ "$I" –lt 5 ]; do
echo bonjour
I=$(expr $I + 1)
done
En Ksh
#!/bin/ksh
Integer I
I =0
while ((I<<5)) ; do
echo bonjour
let I=I+1
done 147
Mécanismes
complémentaires
Arithmétique
La commande bc:
Avec expr:
$ bc
3.4 + 2
5.4
x=2
3+x
5
quit
$ echo 3+4 | bc
148
74
23/02/2015
Mécanismes
complémentaires
Application
La commande ‘pers_env’
Écrire un shell-script ‘pers_env’ qui personnalise la
commande ‘env’.
Lancer l’exécution de ‘pers_env’ comme une
commande (chmod u+x pers_env)et(#!/bin/bash)
Exemple:
% pers_env
Je suis l ’utilisateur ali
Je suis dans le répertoire /etc
Mon répertoire de travail par défaut est: /home/ali
149
Mécanismes
complémentaires
Arithmétique
Exercices:
À l’aide de la commande expr, calculer l’expression suivante:
(5-2)*(6+1)
Utiliser la commande bc pour calculer la surface d’un cercle qui
fait 2.5cm de rayon
Écrire un script qui convertit en mn et sec un temps exprimé en
seconde (le temps est passé en paramètre)
Écrire un script qui affiche les paramètres recus, chacun précédé
de son numéro d’ordre
Écrire un script qui affiche les n premiers nombres, n lui étant
passé en paramètre
150
75
23/02/2015
Mécanismes
complémentaires
Arithmétique
Exercices:
Écrire un Shell script UNIX ‘indice’, qui affiche l’indice d’une variable
dans un tableau saisi en argument
Écrire un Shell script UNIX ‘rep’, qui affiche le nombre et la liste des
répertoires qui se trouve dans le répertoire courant
Ecrire un shell script UNIX qui affiche le nombre et la liste des
répertoires qui se trouvent dans le répertoire courant. Etendre le
shell script de manière à effectuer un traitement similaire dans un
répertoire lu en argument.
151
Extensions du
Korn shell et Bash
Plan (alias et fonction)
Alias
Alias particuliers
Sous programmes sous forme de script
Sous programmes sous forme de fonction
Échange de données
Les bibliothèques de fonctions (ksh)
Exercices
152
76
23/02/2015
Extensions du
Korn shell et Bash
Généralités sur les alias (ksh)
Alias
Création d’un alias:
alias dir=‘ls –lba’
Utilisation d’un alias
dir
Liste des alias
alias
Suppression d’un alias
unalias dir
153
Extensions du
Korn shell et Bash
Alias particuliers (ksh)

Tracked alias (obsolète)
alias –t date
Remplacement de commandes
alias ls ls -la
Alias exporté (obsolète)
alias –x bye=exit
154
77
23/02/2015
Extensions du
Korn shell et Bash
Alias
Exemple1:
Vérifier que l’alias lR n’existe pas
Créer un alias lR correspondant à la commande ls –R
Vérifier la création de l’alias et l’utiliser
Supprimer l’alias lR
Rendre l’alias permanent pour toute session créée
Exemple 2:
Forcer le mode intéractif de la commande rm
Forcer à utiliser la commande rm au lieu de l’alias
155
Extensions du
Korn shell et Bash
Sous programme sous forme
de script
Script:
$ more programme
#!/bin/sh
echo "Début du programme"
sous_programme
echo "Fin du programme"
$ more sous_programme
#!/bin/bash
echo "---------------sous-programme--------------"
echo "---------------fin ss-programme-------------"
156
78
23/02/2015
Extensions du
Korn shell et Bash
de script
Script:
Script:
Exemple:
Exemple:
#!/bin/bash
# menu #!/bin/bash
clear
écrire
écrire
ununscript
script
permettant
permettant
# creation dede réaliser
réaliser
#!/bin/bashunun menu,
menu,
# suppression
composé
while : composé dede
3 options:
3 options:
echo -n nom fichier:
echo -n nom fichier:
read nom
do
1) 1)
créer
créer
ununfichier
fichier
echo création en cours...
echo " 1) Création d'un fihcier"
read nom
echo suppression en cours...
2) 2)
supprimer
supprimer unun fichier
fichier
sleep 3
echo " 2) Suppression d'un fichier" sleep 3
touch $nom 2>> erreur
3) 3)
quitter
quitter
echo " 3) Quitter"
read choix if [ $? -eq 0 ]; then
rm $nom 2>> erreur
if [ $? -eq 0 ]; then
LesLes
opérations
opérations
case $choix in dede création
création
echo et
$nomet
de de
créésuppression
suppression
echo $nom serontseront
supprimé
else
placées
placéesdans
dans
desdesscripts
1) bash creation;; scripts à part,
à part, enen
echo $nom non créé
tenant
tenant
else comptecompte des
2) bash suppression;;
conditions
des conditions
d’exécution
3) exit 3;; d’exécution
fi conviviales. conviviales.
fi
echo $nom non supprimé
*) echo choix incorrect; sleep 5;; sleep 3

sleep 3
esac
done 157
Extensions du
Korn shell et Bash
de fonction
Fonction
Syntaxe: [function] nom() {.........}
appel de fonction: nom [arg ...]
pas de déclaration d'arguments entre parenthèses ()
les fonctions doivent être définies avant leur utilisation
Exemple:
#!/bin/sh
usage() { echo "usage: $1 $2" ; }
main() {
if [ $# -ne 1 ]; then usage `basename $0` "fichier"; exit 1; fi ; }
main $*
158
79
23/02/2015
Extensions du
Korn shell et Bash
de fonction
Fonction
$ more programme
#!/bin/bash
sous_programme()
{
echo "---------------sous-programme--------------"
echo "------------------------fin-----------------------«
}

sous_programme
echo "Fin du programme" 159
Extensions du
Korn shell et Bash
de fonction
Fonction
Exemple:
1- Créer une fonction llr(), relative à la commande ls –lR
2- Créer une fonction trouve(), qui retourne la référence
absolue d’une commande lue en argument
3- Supprimer la fonction trouve()
4- Ecrire un shell script qui contient 2 fonctions
lire_ligne() et ecrire_ligne(), qui sont appelées
successivement pour lire puis afficher une ligne saisie en
argument, jusqu’à lecture de la chaine « fin »
160
80
23/02/2015
Extensions du
Korn shell et Bash
Scripts Fonctions
Les arguments d’appels (in)
Les fichiers (in/out)
L’environnement (in) L’ensemble des variables
(in/out)
La valeur retournée par exit La valeur retournée par return
(out) (out)
161
Extensions du
Korn shell et Bash
Bibliothèques de fonctions
(ksh)
$ more ~/fonctions/f1
f1()
{
echo Fonction f1
}
$ chmod u+x ~/fonctions/f1
$ FPATH=~/fonctions; export FPATH
$ more programme
#!/bin/ksh
f1
echo "Fin du programme" 162
81
23/02/2015
Extensions du
Korn shell et Bash
(ksh)
Exemples:
163
Extensions du
Korn shell et Bash
Exercices
Créer une nouvelle commande de nom heure, qui affiche

l’heure au format HH:MM:SS
Créez une nouvelle commande de nom attrib_dir, qui
affiche les attributs d’un répertoire
Comment forcer le shell à utiliser l’implémentation POSIX
de la commande echo à chaque fois que cette dernière est
lancée
Comment rendre les alias créés précédemmnt accessibles
à tous les scripts lancés dans cette sessions
Comment rendre permanents les alias précédents, pour
tous les shells intéractifs (ceux qui n’exécutent pas de
scripts et affichent une invite) lancés au cous des
sessions? 164
82
23/02/2015
Extensions du
Korn shell et Bash
Exercices
Créez une fonction qui convertit le contenu d’un fichier de

minuscules en majuscules
Écrivez un script modulaire qui appelle des fonctions de
gestion de répertoires à partir du menu suivant:
Afficher les attributs du répertoire
Lister les fichiers du répertoire
Créer un répertoire
Supprimer un répertoire
Quitter
Toutes les fonctions devront vérifier l’existence ou non du répertoire
avant de s’exécuter
165
Automatisation avec
les shell-scripts
La programmation multitâche
en shell
Panorama des commandes de gestion de ps:
cmd&
ps
kill
wait
nice
nohup
at
crontab
166
83
23/02/2015
Automatisation avec
les shell-scripts
en shell
La programmation parallèle en shell
Exécution séquentielle (avant plan)
Exécution parallèle (arrière plan)
Syntaxe d’exécution en arrière plan: cmd &
Exemple:
#!/bin/bash
cal
who
ls –lR / &
find / -print &
wait
date 167
La programmation
du shell
en shell
Regroupement de commandes:
Exécutées par le shell en cours:
{cmd; …; cmd;}
Exécutées par un shell fils:
(cmd; …; cmd;)
Exemple:
Bloc exécuté par le shell en cours:
{ date; ps } > taches.log
[ -d rep ] && { cd rep; mkdir rep/sousrep }
Bloc exécuté par un shell fils:
( cd /tmp; … ); pwd
Code de retour d’un bloc: celui de la dernière cmd168
84
23/02/2015
La programmation
du shell
en shell
Les variables $ et ! :
$
désigne le shell courant (pid du processus)
permet de tuer tous les ps lancés par le script
!
désigne le pid de la dernière tâche en arrière plan
Exemple:
#!/bin/bash
(
sleep 10; kill $$; echo suite
)&
echo "heure de départ ?\c" ; read heure; kill $!
echo "ps –ef > liste" | at $heure 169
La programmation
du shell
en shell
Les variables $ et ! :
Exemple:
#!/bin/bash
# script lance une tâche en arrière plan,
# qu’il tue au bout de dix secondes.
(
while :
do
sleep 4
echo bonjour >> fic.bon
done
)&
sleep 10
kill $! 170
85
23/02/2015
La programmation
du shell
en shell
Déroutements:
Séquence d'exception:
Syntaxe: trap 'liste de commandes'liste de signaux
Exemple : trap 'rm /tmp/appl.$$; exit 1' 2
Ignorance des signaux :
Syntaxe: trap '' liste de signaux
Exemple : trap '' 1 2 3 15
Réinitialisation
Syntaxe: trap liste de signaux
Exemple : trap 2 3
Liste des signaux
Syntaxe: trap
Exemple : trap 171
La programmation
du shell
en shell
La gestion des signaux: trap et kill
Exemple:
$ more programme $ programme &
#!/bin/sh [1] 215
trap "" INT $ je boucle
je boucle
trap "echo recu" HUP je boucle
trap "echo FIN; exit" TERM kill –INT 215
while : $ je boucle
do kill –HUP 215
sleep 10 $ recu
echo je boucle je boucle
done $ kill –TERM 215
$ FIN 172
Terminated
86
23/02/2015
La programmation
du shell
en shell
Les groupes de processus
Exemple:
for v in un deux trois
do
(
while : ; do
sleep 5
echo $v
done
)&
done
sleep 20
kill –TERM -$$ 173
La programmation
du shell
en shell
L’échange de données par tube nommé
Exemple:
$ more p1 $ more p2
#!/bin/sh #!/bin/sh
exec > tube exec < tube
while read var while read line
do do
echo $var echo ">$line"
done done
$ mknod tube p $ p2 &

$ p1
bonjour
174
> bonjour
87
23/02/2015
La programmation
du shell
en shell
Les verrous
Exemple:
#!/bin/sh
if mkdir ~/verrou 2> /dev/null
then
echo "== entre en section critique =="
sleep 10
echo " == sort de la section critique =="
rmdir ~/verrou
else
echo " erreur: impossible d’entrer \c"
echo " en section critique"
fi 175
La programmation
du shell
en shell
Les coprocessus:
En korn shell:
Connecter les E/S std d’un processus fils lancé
en arrière plan
Syntaxe:
cmd |&
read –p var…
print –p expression_chaine …
exec > &-
176
88
23/02/2015
La programmation
du shell
en shell
Les coprocessus:
En korn shell:
Exemple:
#!/bin/ksh
who |&
while read –p nom term le_reste
do
echo "nom: $nom, $term"
done
177
La programmation
du shell
en shell
La gestion des travaux en Korn shell:
Exemple:
$ sleep 200
Ctrl-z
[1] + Stopped sleep 200
$ sleep 300&
[2] 478
$ jobs # liste des travaux
[2] + Running sleep 300 &
[1] - Stopped sleep 200
$ kill %2 # met fin à une tâche
[2] + Terminated sleep 300 &
$ bg %1 # met une tâche en arrière plan
[1] sleep 200
$ fg %1 # met une tâche en avant plan
sleep 200 178
89
23/02/2015
La programmation
du shell
en shell
Exercices:
Écrire un script de nom scrute_util, qui vérifie pendant 10mn
(en arrière plan), si un utilisateur est connecté, et qui affiche
un message et se termine, si ce dernier est connecté.
Écrire un script qui redirige vers un fichier les sorties d’un
ensemble de commandes avec le caractère « > » (n’utilisez
pas « >> »), et qui ensuite affiche le contneu du fichier
Écrire un script qui lance les commandes date et ps en
arruère plan toutes les cinq secondes, et qui les tue au bout
de vingt secondes
Écrire un script qui affiche « bonjour » toutes les 10
secondes, et qui s’arrête et affiche « au revoir » quand on
frappe « ^C » 179
La programmation
du shell
en shell
Exercices:
Reprendre l’exercice précédent en le modifiant de facon à ce que l’on
ne puisse l’arrêter qu’en lui envoyant le signal 9. penser à l’exécuter
en arrière plan.
Créer un tube nommé « le_tube », en exécutant la commande
« mknod le_tube p », et écrire deux scripts, qui échangent des
données à travers le tube nommé « le_tube ». Le premier envoie un
message au deuxième, qui l’affiche à l’écran. L’exécution prend fin
quand le récepteur recoit le message « fin ».
Écrire un script qui utilise un verrou pour gérer les accès concurrents
à une ressource, ici l’écran, où le script affiche un message dans une
boucle de programme. On exécute en arrière plan deux instances du
script. Ils seront tués par l’envoi du signal 9. Il faut prévoir une
attente (sleep 10) immédiatement après l’affichage du message pour
vérifier visuellement la bonne synchronisation d’accès à l’écran. 180
90
23/02/2015
Les filtres
Plan
Définition
Filtre comm
Filtre diff
Filtre grep/egrep
Filtre sed
Filtre ed
Filtre cut
181
Les filtres
Définition
Commandes qui :
acceptent des données de l’entrée standard
effectuent transformations sur ces données
dirigent ces données vers la sortie standard
affichent leurs messages d’erreur vers la
sortie erreur standard
Entrée Sortie
standard standard
Filtre UNIX Données
Données
(commande) transformées
182
91
23/02/2015
Les filtres
Filtre « comm »
Définition:
Compare le contenu de 2 ensembles de données
L’un des 2 ensembles peut provenir de l’entrée std
Syntaxe:
comm [options] fichier1 fichier2
-1 N’affiche pas la 1ère colonne (lignes présentes uniquement dans le fichier1)
-2 N’affiche pas la 2ème colonne (lignes présentes uniquement dans fichier2)
-3 N’affiche pas la 3ème colonne (lignes présentes dans les deux fichiers)
Statut de sortie:
0 pour indiquer qu’il n’y a pas eu d’erreur;
>0 pour indiquer qu’une erreur est rencontrée.
183
Les filtres
Filtre « comm »
Remarque:
Si le nom de l’un des fichiers est le caractère - alors
son contenu est lu de l ’entrée standard.
Exemple:
Fichier 1 Fichier 2
Je suis venu vous voir Je suis venu vous voir

Nous sommes le Vendredi Nous sommes le Vendredi.
Quelle heure est-il? Quelle heure est-il?
Au revoir Au revoir et à bientôt
184
92
23/02/2015
Les filtres
Filtre « comm »
$ comm fichier1 fichier2
Je suis venu vous voir

Nous sommes le Vendredi.
Nous sommes le Vendredi
Quelle heure est-il?
Au revoir et à bientôt
Au revoir
Colonne 1 Colonne 2 Colonne 3
185
Les filtres
Filtre « diff »
Définition:
donne les différences entre 2 ensembles de données
accepte des noms de répertoire
Syntaxe:
diff [options] fichier1 fichier2
diff [options] fichier1 répertoire
diff [options] répertoire fichier1
diff [options] répertoire1 répertoire2
-b Ignorer les blancs (Espace et Tab) à la fin d’une ligne
-c[n] Afficher le contexte où les lignes différentes ont été trouvées
Statut de sortie:
0 Pas de différence rencontrée
1 Des différences ont été relevées
>1 Une erreur est rencontrée 186
93
23/02/2015
Les filtres
Filtre « grep »
Définition:
Trouve des caractères dans un ensemble de
données
Chaîne de caractères recherchée décrite par regex
Synopsis:
egrep [options] [-e expr] [expression] [-f fich] [fichiers …]
-b Afficher au début de chaque ligne trouvée, n° de bloc sur disque
-c Afficher uniquement le nombre de lignes contenant la chaîne
-h N’afficher pas les noms de fichier
-i Ne pas faire de distinction entre les majuscules et les minuscules
-s Aucune sortie sauf les messages d’erreur
-e Nécessaire pour les expressions régulières commençant par un tiret
-f fich Expression régulière est contenue dans le fichier fich 187
Les filtres
Filtre « grep »
Statut de sortie:
0 la chaîne est trouvée
1 la chaîne n’est pas trouvée
2 erreur(s) rencontrée(s)
Remarque:
Par défaut, les lignes trouvées sont envoyées
à la sortie standard.
188
94
23/02/2015
Les filtres
Filtre « grep »
Exemple:
centi 4> ypcat passwd | egrep ':Pierre.*'
parp2808:cRuT6m7jPRJWM:30502:112:
Pierre Parent:/export/home/exa/email/parp2808:/
Parent
bin/csh
doup2609:S3i0oM68.AuVQ:30251:112:
Pierre Doucet:/export/home/exa/email/doup2609:/
Doucet
bin/csh
robcad22:Z.VGpH9oanp3M:11423:114:Pierre St-Denis:/usr/people/exa/robcad/robcad22
:/bin/csh
gaup2806:8fZaJLAA4ybOY:30848:112:
Pierre-Luc Gauthier:/export/home/exa/email/gaup
2806:/bin/csh
dupp0911:LBXJgdV.Zl8lg:30267:112:Pierre Duplessis:/export/home/exa/email/dupp091
1:/bin/csh
gerp1209:JLiqJTddvRdJY:30307:112:Pierre Hugues Gervaud:/export/home/exa/email/ge
rp1209:/bin/csh
gefp0904:zHizZC2VwOjlQ:30304:112:Pierre Olivier Geffroy:/export/home/exa/email/g
efp0904:/bin/csh
boup0806:aX.t0b2BGmZcM:30804:112:
Pierre-Etienne Bouchard:/export/home/exa/email/
boup0806:/bin/csh
grop2001:jzWiOWxd.2iPQ:30966:112:Pierre Grondin:/export/home/exa/email/grop2001:
/bin/csh
duvp0101:4jttBQNX/rHcg:30271:112:
Pierre-Yves Duval:/export/home/exa/email/duvp01
01:/bin/csh
habp0410:ytzP1NEqscex2:30857:112:Pierre-Luc Habel:/export/home/exa/email/habp041
0:/bin/csh
: : :
189
Les filtres
Filtre « grep »
Exemple:
centi 5> ypcat passwd | egrep ':Pierre .*'
parp2808:cRuT6m7jPRJWM:30502:112:Pierre Parent:/export/home/exa/email/parp2808:/
bin/csh
doup2609:S3i0oM68.AuVQ:30251:112:Pierre Doucet:/export/home/exa/email/doup2609:/
bin/csh
robcad22:Z.VGpH9oanp3M:11423:114:Pierre St-Denis:/usr/people/exa/robcad/robcad22
:/bin/csh
dupp0911:LBXJgdV.Zl8lg:30267:112:Pierre Duplessis:/export/home/exa/email/dupp091
1:/bin/csh
gerp1209:JLiqJTddvRdJY:30307:112:Pierre Hugues Gervaud:/export/home/exa/email/ge

rp1209:/bin/csh
gefp0904:zHizZC2VwOjlQ:30304:112:Pierre Olivier Geffroy:/export/home/exa/email/g
efp0904:/bin/csh
grop2001:jzWiOWxd.2iPQ:30966:112:Pierre Grondin:/export/home/exa/email/grop2001:
/bin/csh
stdp2705:srllvkqzhiJho:30582:112:Pierre St-Denis:/export/home/exa/email/stdp2705
:/bin/csh
berp0604:mOT.Bp4f9rQ3I:30138:112:Pierre Berube:/export/home/exa/email/berp0604:/
bin/csh
pinp2309:lkVu0qUAYsMmg:30519:112:Pierre Pinard:/export/home/exa/email/pinp2309:/
bin/csh
daup2612:6qqRrxMOkIbkA:30220:112:Pierre Noel Dautrey:/export/home/exa/email/daup
2612:/bin/csh
: : : 190
95
23/02/2015
Les filtres
Filtre « grep »
Exemple:
$ egrep '[.,!]' *
comm1.dat :cher Monsieur Jean.
comm1.dat :Non, Pas le Dr. Watson de Windows!
comm2.dat :Non, Pas le Dr. Watson de Holms!
Trouver le caractère point ou le caractère virgule

ou le caractère point exclamation dans tous les
fichiers du répertoire courant.
Remarque:
Le filtre grep est très utile dans la recherche des
motifs dans un fichier ou un ensemble de fichiers.
La vitesse d’exécution de grep est très très grande!
191
Les filtres
programmables
Le filtre awk
Définition
Syntaxe
Principe de fonctionnement
Forme générale des programmes
Application
192
96
23/02/2015
Les filtres
programmables
Définition
Filtre programmable utilisant les instructions
légales selon le format ‘awk’
Ressources:
Le filtre/commande ‘awk’
Le programme/script
Le(s) fichier(s) objet(s) du filtrage
Concept de programmation « piloté par les
données » (Data Driven)
Utilisé pour:
Valider les concepts de programmation
Automatiser les tâches de gestion
Évaluer rapidement les algorithmes, etc… 193
Les filtres
programmables
Définition
La commande ‘awk’ permet de rechercher

dans chacun des fichiers référencés les
lignes satisfaisant 1 ou plusieurs motifs
parmi ceux énumérés dans le programme
awk
194
97
23/02/2015
Les filtres
programmables
Syntaxe
awk [-F<car>] [-f <refprog>] [‘<programme>’]
[<fichier> …]
Option –F : définit un séparateur de
champs dans les lignes différent du
séparateur usuel (espace ou tabulation).
Fichiers traités: entrée standard ou
paramètres selon l’ordre où ils déclarés.
195
Les filtres
programmables
Principe de fonctionnement
Données (fichier Programme composé

ASCII ou l'entrée d'une séquence
standard) << motif – action >>
1 2
motif action 3
motif action
motif action
awk motif action
motif action
: :
: :
awk lit l'entrée
ligne par ligne
L'action de chaque
motif sélectionné est
exécutée par awk
awk compare
chaque motif du
programme avec la ligne
lue
196
98
23/02/2015
Les filtres
programmables
Forme des programmes

Le programme awk est divisé en 3 sections :
Section initiale
syntaxe : BEGIN {actions avant}
Corps
syntaxe : motif {actions sur chaque ligne}
Section terminale
syntaxe : END {actions après}
197
Les filtres
programmables
Mécanisme d’exécution de awk :

Exécuter les actions de la section initiale
Tant que (fin du dernier fichier non atteinte) faire
Lire l’enregistrement suivant
Pour (chaque motif vérifié par l’enregistrement)
exécuter actions correspondant à ce motif
Fin pour
Fin tant que
Exécuter les actions de la section terminale
198
99
23/02/2015
Les filtres
programmables
Actions et motifs par défaut :

Action par défaut :
Impression de l’enregistrement
Motif par défaut :
Tout enregistrement contient le motif par
défaut
199
Les filtres
programmables
Forme des motifs :

motif =
expression rationnelle
||
expression relationnelle
200
100
23/02/2015
Les filtres
programmables

Forme des motifs (suite):
Expression rationnelle (pour la ligne):
/motif/
/: délimiteur d’expression
^: début de ligne
$: fin de ligne
-: dans un crochet, définit un intervalle
*: itérer un caractère
[] : définit un ensemble
201
Les filtres
programmables

Expression relationnelle :
<expression> ~ <expression rationnelle> :
expression de gauche contient motif satisfaisant
expression de droite
exemple:
$1 ~ /^toto/
le premier champ est une chaîne de caractères
qui commence par ‘toto’
202
101
23/02/2015
Les filtres
programmables

Expression relationnelle (suite):
<expression> !~ <expression rationnelle> :
expression de gauche ne contient pas de motif
satisfaisant expression de droite
exemple:
$1 !~ /^toto/
qui ne commence pas par ‘toto’
203
Les filtres
programmables

Expression relationnelle (suite):
<expression> <opérateur> <expression> :
avec <opérateur> : <, >, ≤, ≥, ==, !=
exemple:
$1 == ’’toto ’’
qui coïncide avec ‘toto’
204
102
23/02/2015
Les filtres
programmables
Les actions :
Variables utilisateurs :
i.e. langage C
Variables de champ :
$0, $1, ..., $i
205
Les filtres
programmables
Les actions (suite):

Variables prédéfinies :
• FS : séparateur de champ traité
• RS : séparateur d’enregistrement
• OFS :séparateur de champ en sortie
• ORS :séparateur d’enregistrement en sortie
• NF : nombre de chps dans l’enregistrement courant
• NR : nombre total d’enregistrements lus dans tous les
fichiers de données
• FNR : nombre d’enregistrements lus dans le fichier de
données courant, en comptant l’enregistrement courant
206
• FILENAME :nom du fichier en cours de traitement
103
23/02/2015
Les filtres
programmables

Opérateurs :
arithmétiques : ++, --, +, -, *, /
relationnels : <, >, ≤, ≥, ==, !=, ~, !~
booléens : &&, ||
affectation : =, +=, -=, *=, /=
Tableau : ligne[NR]=$0
207
Les filtres
programmables

Instructions :
• Impression :
print [<expression>, <expression>, …]
• Condition :
if (<expression>) <instruction1>; [else <instruction2>]
208
104
23/02/2015
Les filtres
programmables

Instructions (suite):
• Itération :
for (<expression>; <expression>;<expression>)
<instruction>
ou
for (<var> in <tableau>)
<instruction>
ou
while (<condition>)
<instruction>
ou
209
do <instruction> while (<expression>)
Les filtres
programmables

Les fonctions mathématiques prédéfinies
exp(x)
log(x)
sqrt(x)
int(x)
210
105
23/02/2015
Les filtres
programmables

Les fonctions prédéfinies
index(s,t) retourne la position dans la chaîne s
où la chaîne t apparaît pour la première fois
match(s,er) retourne la position dans la chaîne
s où l’expression régulière er apparait pour la
première fois
length(s) calcule le nombre de caractères de s
split(s,a,fs) divise la chaîne s en utilisant le
séparateur fs et range les éléments obtenus
dans le tableau a (dans a[1], a[2], etc)
211
Les filtres
programmables

substr(s,p[,n]) si n n’est pas spécifié, retourne
la sous-chaîne de s commençant par le p-ième
caractère; sinon retourne la sous-chaîne de s
commençant par le p-ième caractère et
contenant n caractères.
sub(r,s[,t]) substitue la chaîne s à la première
occurrence de l’expression régulière r dans t.
La valeur retournée par sub est le nombre de
substitutions qui ont été faites.
212
106
23/02/2015
Les filtres
programmables

gsub(r,s[,t]) comme sub, sauf que la
substitution est faite globalement (i-e. pour
toute occurrence de r dans t). La valeur
retournée par sub est le nombre de
substitutions qui ont été faites.
tolower(s) passage en minuscules, toupper(s)
passage en majuscules.
213
Les filtres
programmables

print produit un affichage, par défaut sur la
sortie standard, mais on peut utiliser les
redirections.
printf s’utilise de la même façon qu’en C.
system(cmd) exécute la commande UNIX cmd
dans un sous-shell.
getline [var] lit le prochain enregistrement sur
l’entrée standard dans la variable var (dans $0
si pas de paramètre)
214
107
23/02/2015
Les filtres
programmables
Exercices
1. Ecrire un script AWK qui affiche la liste des utilisateurs déclarés sur le
système.
2. Ecrire un script AWK qui affiche la liste des utilisateurs du système dont le
login commence par ‘a’.
3. Ecrire un script AWK qui compte le nombre d’utilisateurs du système dont le
login commence par ‘a’.
4. Ecrire un script AWK qui affiche la liste des utilisateurs du système dans un
ordre inversé.
5. Ecrire un script AWK qui complète un fichier contenant les articles, quantités
et prix unitaire, en ajoutant une colonne « prix de l’article », et en calculant le
prix total par article, et le prix total de l’ensemble des articles.
215
Les filtres
programmables
Exercices
6. Ecrire un script AWK qui affiche les lignes de plus de 80 caractères.

7. Ecrire un script AWK qui affiche les lignes qui contiennent exactement 2
champs
8. Ecrire un script AWK qui affiche les lignes qui vérifient que le fichier
/etc/passwd a une structure régulière
9. Ecrire un script AWK qui affiche le second champ de chaque ligne.
10. Ecrire un script AWK qui affiche la liste des champs de chaque ligne dans un
ordre inversé.
11. Ecrire un script AWK qui permet de compter le nombre de lignes qui
contiennent la chaîne "l2ti".
12. A l'aide des tableaux associatifs, écrire un script AWK qui affiche la
fréquence des mots d'un texte.
216
108

Unix PDF

Transféré par

Informations du document

Titre original

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

Unix PDF

Transféré par

Droits d'auteur :

Formats disponibles

23/02/2015

Université Mohammed V – Souissi

2013-2014 Pr. M.D. El Kettani 3

2013-2014 Pr. M.D. El Kettani 5

Shell = Interpréteur de commandes

2013-2014 Pr. M.D. El Kettani 7

Les différents shells

csh ("C-shell", Bill Joy, UCB)

ksh ("Korn shell", David Korn, AT&T)

bash ("Bourne again shell" de Brian Fox & C. Ramey)

zsh ("Zero shell")

rsh ("Bourne shell réduit", cd, <, > inopérants)

Fonctionnalités des shells

Comparaison des Shells

Fonctionnalités des shells

Comparaison des Shells

Fonctionnalités des shells

Fonctionnalités des shells

2013-2014 Pr. M.D. El Kettani 12

Caractères de contrôle au clavier

Caractères de contrôle au clavier

Format d'une commande:

2013-2014 Pr. M.D. El Kettani 15

2013-2014 Pr. M.D. El Kettani 18

2013-2014 Pr. M.D. El Kettani 20

Paramétrage du rappel de commandes:

2013-2014 Pr. M.D. El Kettani 25

2013-2014 Pr. M.D. El Kettani 26

2013-2014 Pr. M.D. El Kettani 29

2013-2014 Pr. M.D. El Kettani 30

2013-2014 Pr. M.D. El Kettani 31

2013-2014 Pr. M.D. El Kettani 32

2013-2014 Pr. M.D. El Kettani 33

À réaliser $ cat le_script

2013-2014 Pr. M.D. El Kettani 34

# Un commentaire se termine en fin de ligne

# @(#) Commentaire SCCS, affiché par la

date # Affiche la date et l’heure

: pseudo commentaire, toujours vrai

2013-2014 Pr. M.D. El Kettani 36

Exécution d’un script

Exécution d’un script grâce à sh (shell fils)

Exécution d’un script par le shell courant

Activation/Désactivation du mode trace dans le

2013-2014 Pr. M.D. El Kettani 38

Activation/Désactivation du mode trace dans le

Exécution d’un script, affiche la trace des

2013-2014 Pr. M.D. El Kettani 41

Gestion des options

2013-2014 Pr. M.D. El Kettani 42

• La commande print (ksh):

2013-2014 Pr. M.D. El Kettani 44

Avec une seule commande d’affichage, affichez sur deux lignes le

Dans votre répertoire de connexion, écrivez un script de nom script1, qui

2013-2014 Pr. M.D. El Kettani 46

Les types de variables :

2013-2014 Pr. M.D. El Kettani 50

2013-2014 Pr. M.D. El Kettani 51

2013-2014 Pr. M.D. El Kettani 53

Les variables d’environnement

Les variables d’environnement

2013-2014 Pr. M.D. El Kettani 55

Fichiers d'initialisation (Bash):