Commandes Unix

Lycée polyvalent DIDEROT Département IRIS
61, rue David d’Angers

75019 PARIS
http://www.diderot.org
COURS
Le langage de commandes d'UNIX : Le shell
Auteur Version - Date Nom du fichier

J.Ozbolt , G.Valet Version 1.1 - Sept 2007 cours-shell.docx
COURS Le langage de commandes d'UNIX : Le shell
A. Sommaire
A. SOMMAIRE.................................................................................................................................................................................. 2
B. PREAMBULE ................................................................................................................................................................................ 3
Bibliographie : ......................................................................................................................................................................... 3
C. INTRODUCTION ............................................................................................................................................................................ 4
C.1. Les différents Shells à l’heure actuelle ............................................................................................................................. 4
D. LA REDIRECTION DES ENTREES SORTIES .............................................................................................................................................. 4
D.1. Redirection de l'entrée standard ..................................................................................................................................... 5
D.2. Redirection temporaire de l'entrée standard .................................................................................................................. 5
D.3. Redirection de la sortie standard..................................................................................................................................... 5
D.4. Redirection de la sortie d’erreur ...................................................................................................................................... 6
D.5. Compléments sur les redirections .................................................................................................................................... 6
E. EXECUTION D'UNE COMMANDE OU D’UN SCRIPT ................................................................................................................................. 7
E.1. Commande simple............................................................................................................................................................ 7
E.2. La commande ps .............................................................................................................................................................. 8
E.3. L'enchaînement des commandes ..................................................................................................................................... 8
E.4. Connexion de processus, les tubes ou pipes ..................................................................................................................... 9
E.5. Exemple de « fichier de commandes » ou « fichier script » ........................................................................................... 10
E.6. Compléments sur les métacaractères ............................................................................................................................ 10
F. NOTION DE VARIABLE................................................................................................................................................................... 11
F.1. Déclaration ..................................................................................................................................................................... 11
F.2. Variables de substitution prédéfinies ............................................................................................................................. 12
F.3. Variables d'environnement prédéfinies.......................................................................................................................... 12
F.4. Transmission des paramètres ........................................................................................................................................ 14
F.5. La capture de la sortie standard du résultat d’une commande ..................................................................................... 14
G. LES STRUCTURES DE CONTROLE ..................................................................................................................................................... 15
G.1. La structure conditionnelle if then else fi ....................................................................................................................... 15
G.2. La bouche pour : for....................................................................................................................................................... 18
G.3. La boucle tant que : while.............................................................................................................................................. 19
G.4. La boucle jusqu’à : until ................................................................................................................................................. 19
G.5. Le branchement multiple ............................................................................................................................................... 20
G.6. L’exécution de commandes dans un sous-shell ............................................................................................................. 20
G.7. Exemple de synthèse ..................................................................................................................................................... 20
H. LES VARIABLES DE TYPE NUMERIQUE............................................................................................................................................... 21
I. LE TRAITEMENT DES EVENEMENTS ................................................................................................................................................... 22
J. LA NOTION DE FONCTION .............................................................................................................................................................. 23
K. QUELQUES COMMANDES UTILES .................................................................................................................................................... 24
K.1. echo - affichage ............................................................................................................................................................. 24
K.2. test - commande conditionnelle .................................................................................................................................... 25
K.3. file - commande de classification ................................................................................................................................... 26
K.4. read - commande de lecture .......................................................................................................................................... 26
K.5. cmd - commande de comparaison ................................................................................................................................. 26
K.6. grep - commande de recherche ..................................................................................................................................... 26
K.7. sed -le filtre éditeur ........................................................................................................................................................ 28
K.8. sort - tri et fusion de fichiers .......................................................................................................................................... 29
K.9. basename-dépouiller une chaîne ................................................................................................................................... 30
K.10. expr - évaluation des arguments en tant qu'expressions............................................................................................. 30
L. UN RESUME DE QUELQUES COMMANDES PAR ORDRE ALPHABETIQUE ..................................................................................................... 32
Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 2 / 36

B. Préambule
Ces éléments de cours sont constitués, en premier lieu, de matériaux extraits et adaptés de la
« littérature » informatique actuelle dont la bibliographie, certainement non exhaustive, est publiée ci-
dessous.
Cette bibliographie est une partie indivisible de ce document pour plusieurs raisons : d’un part par
respect pour les auteurs des ouvrages utilisés et, d’autre part, pour que les utilisateurs de ce document
puissent consulter ces ouvrages s’ils veulent approfondir leurs connaissances dans les domaines abordés.
Ces éléments de cours sont aussi construits à partir de réactions d’étudiants ou d’auditeurs qui, par leurs
remarques, souvent judicieuses, les ont fait évoluer sans cesse. C’est donc un document vivant qui est la
propriété de tout étudiant ou auditeur qui en a obtenu possession de façon légale, c’est-à-dire par
l’auteur ou toute personne le représentant.
Ce document peut donc être reproduit sous quelque forme que ce soit et être distribué gratuitement aussi
longtemps qu’il reste intact, ce paragraphe et le nom de l’auteur compris. Mais, en aucun cas, il ne peut
être distribué complètement ou partiellement, même gratuitement, par un organisme de formation, par
un formateur sans autorisation de l’auteur. Ces éléments de cours sont copyright © 2000 par Jean Ozbolt.
Bibliographie :
Steve Bourne Brian Kernighan et Rob Pike
Le système UNIX L’environnement de programmation UNIX
InterEditions PARIS, 1985 InterEditions PARIS, 1986.
Jean-Michel Moreno Jean-Marie Rifflet

UNIX Administration La programmation sous UNIX
EDISCIENCE International, PARIS 1995. EDISCIENCE International, PARIS 1994.
Bernard Coulange Alain-Bernard Fontaine et Philippe

Programmation système sous UNIX Hammes
Eyrolles, PARIS 1988. UNIX System V
Masson Paris 1989.
H Lucas, B. Martin G. de Sablet André Tanenbaum
UNIX Mécanismes de base, Langage de Les systèmes d’exploitation
commande, Utilisation InterEditions PARIS, 1989
Eyrolles, PARIS 1984.
Christian Pélissier Divers Auteurs souvent talentueux

UNIX Utilisation, Administration, Les HOWTO LINUX
Réseau Internet Serveurs ftp anonymes (par exemple
HERMES, PARIS 1998. celui de jussieu à Paris).

C. Introduction
Un « Shell » est un interpréteur de commandes du système UNIX. C’est aussi un langage de commande,
qui réalise l'interface entre l'utilisateur et le noyau d'UNIX.
Les commandes exécutées par un Shell peuvent provenir soit du terminal, soit d'un fichier appelé fichier
de commandes.
Le Shell est un véritable langage de programmation, c'est à dire, il possède :
- la notion de variable,
- des structures de contrôle (if, for while, ..)
C.1. Les différents Shells à l’heure actuelle
Le Bourne Shell (sh) est le premier Shell crée et il reste celui dont tout système Unix a besoin pour lancer
les outils de configuration au démarrage de la machine.
Les Shell ksh ("Korn Shell"), bash ("Bourne again Shell") et zsh ("Zero Shell") utilisent des syntaxes plus
riches mais restent compatibles avec sh.
Le csh ("C_Shell"), et le tcsh ("Toronto C-Shell") ont par contre des syntaxes beaucoup plus différentes
(de sh) et très proches de celle du langage C.
La seule chose dont on peut être sûr, c'est qu'au moins un Shell compatible sh existe sur toute machine
Unix. C'est pourquoi, ces notes de cours se limiteront à décrire les fonctions essentielles du Bourne Shell
(sh).
D. La redirection des entrées sorties
Lors de l'ouverture d'une session, l'utilisateur possède, par l'intermédiaire de son terminal :
 une entrée standard définie par l'identificateur stdin et correspondant à l'entier 0, par défaut
c'est le clavier,
 une sortie standard définie par l'identificateur stdout et correspondant à l'entier 1, par défaut
c'est l'écran,
 une sortie d'erreur définie par l'identificateur stderr et correspondant à l'entier 2, par défaut
c'est l'écran.
Chaque commande ou programme utilisateur peut utiliser cette entrée ou ces sorties.
Par exemple, les commandes suivantes :

 who utilise stdout pour afficher la liste des utilisateurs logés,
 cc (le compilateur c) utilise stderr pour afficher les éventuels messages d'erreur.
Il est possible de rediriger ces entrées sorties.

D.1. Redirection de l'entrée standard

C'est l'opérateur < qui permet d'indiquer à l'interpréteur de commande la redirection de l'entrée.
a. Exemple
$ a.out < data
Dans cet exemple, le fichier data doit contenir les données nécessaires à l'exécution du programme a.out.
L'opérateur n'aura donc plus besoin d'entrer ces données au clavier.
b. Exemples d'exécution
Sans redirection de l'entrée :
$ a.out
Ce programme détermine le plus grand de 3 entiers.
Entrez 3 entiers : 3 22 126
Le plus grand est : 126
Avec redirection de l'entrée :
$ a.out < data
Ce programme détermine le pus grand de 3 entiers.
Entrez 3 entiers :
Le plus grand est : 126
Voici le contenu du fichier data obtenu avec la commande cat :
$ cat data
3 22 126
$
D.2. Redirection temporaire de l'entrée standard

a. Exemple
[nom_commande] << [séparateur]

ligne1
ligne2
...
[séparateur]
La commande reçoit en entrée le texte situé entre les deux occurrences du séparateur.
D.3. Redirection de la sortie standard

C'est l'opérateur > qui permet d'indiquer à l'interpréteur de commande la redirection de la sortie.
a. Exemple
$ ls -l > listage
$

Le contenu de la commande ls -l n'apparaît pas à l'écran, il se trouve maintenant dans le fichier de nom
"listage" et :
 si le fichier "listage" n'existait pas il est créé,
 si le fichier "listage" existait son ancien contenu est détruit et remplacé par le résultat de la
commande.
L'opérateur >> permet d'indiquer à l'interpréteur de commande la redirection de la sortie en ajout ou

rallongement.
b. Exemple
$ a.out >> res
$
 Si le fichier "res" n'existait pas il est créé ;

 Si le fichier "res" existait le résultat de la commande est ajouté à la fin de son ancien contenu.
D.4. Redirection de la sortie d’erreur
Par défaut, c'est à dire sans indication contraire l'opérateur > permet de rediriger la sortie standard 1,
pour rediriger la sortie erreur, il faut l'indiquer explicitement à l'aide de son identificateur 2.
a. Exemple
$ cc essai.c 2 > erreur
Dans cet exemple, s'il y a des erreurs lors de la compilation, elles seront dirigées vers le fichier "erreur",
s'il n'y en a pas, ce dernier sera créé, mais sera vide.
D.5. Compléments sur les redirections
Il est possible de rediriger un descripteur standard sur un autre grâce à la syntaxe suivante :
n>&m avec n et m descripteurs
a. Exemple
$ echo « message » 1>&2
Dans ce cas, le message, normalement dirigé sur stdin par la commande echo, est redirigé vers stderr.
Le descripteur 1 de stdin est ici facultatif, comme le montre l’exemple ci-dessous.
$ echo « Nombre de paramètres incorrect » >&2

E. Exécution d'une commande ou d’un script

E.1. Commande simple
Le format d'une commande sous UNIX suit le modèle suivant :

$ nom_de_la_commande -options arguments
En outre, dans une commande, il peut éventuellement y avoir des opérateurs de redirections. Le premier
mot désigne le nom de la commande à exécuter, les options et arguments forment ce que l'on appelle les
"paramètres" de la commande.
La valeur n retournée d'une commande est celle donnée en argument à la commande exit n. Les chemins
de recherche dans l’arborescence du nom d'une commande sont définis dans le PATH (voir plus loin).
Lors du lancement d'une commande, (un programme utilisateur ou une commande comme date)
l'interpréteur de commandes ou Shell va rendre résident en mémoire le programme exécutable associé
et lancer son exécution.
Nous dirons que le Shell a « créé un processus » ou une tâche. Le Shell qui a créé le processus attend qu'il
soit terminé pour redonner « la main » à l'utilisateur. Cependant, sous UNIX il est possible de lancer un
processus sans avoir à attendre la fin de son exécution, il suffit, pour cela, d'ajouter l'opérateur & (et
commercial) à la fin de la commande.
$ cc essai.c 2 > erreur &

1732
$
Le processus est exécuté en arrière plan. Le Shell affecte à ce processus un numéro (un entier positif ici
1732) qui est affiché à l'écran et redonne la main à l'utilisateur qui peut lancer une nouvelle commande.
Notons que l'utilisateur ne sera pas perturbé par l'affichage d'éventuels messages d'erreurs puisqu'il a
redirigé stderr.
Si nous avions eu la commande:

$ cc essai.c &
1778
$ vi essai.c
Toutes les erreurs de compilations auraient été affichées dans la fenêtre d'édition de vi ce qui n'est pas
très agréable.

E.2. La commande ps
La commande « ps » permet de connaître la liste des processus actifs.
a. Exemple
$ ps
PID TTY TIME CMD
927 05 0:22 -sh
1732 05 0:02 cc
1734 05 0:01 ps
$
Nous constatons que lors de l'exécution de la commande ps, trois processus étaient encore actifs pour
l'utilisateur relié au terminal tty05:
 Le Shell initial (pid 927) obtenu lors de l'ouverture de la session par la commande login,
 Le processus de compilation lancé en arrière plan,
 La commande ps qui s'exécutait .
L'utilisateur pourra consulter la liste des processus actifs pour connaître la fin d'un processus lancé en
arrière plan.
$ ps
PID TTY TIME CMD
927 05 0:22 -sh
1764 05 0:01 ps
$
Le processus 1732 est terminé.
Remarquons que la commande ps doit consulter la table des processus, pour cela, elle doit ouvrir le fichier
spécial /dev/kmem qui donne accès à l’espace mémoire du noyau UNIX. La commande ps doit donc avoir le
set GID actif.
E.3. L'enchaînement des commandes

Il est possible d'enchaîner l'exécution des commandes à l'aide de l'opérateur ; (point virgule).
a. Exemple
$ date;who;pwd;ls -l
Chaque commande sera exécutée séquentiellement.

E.4. Connexion de processus, les tubes ou pipes

Chaque processus peut disposer de l'entrée stdin des sorties stdout et stderr, ainsi dans l'exemple
précédent, le processus de compilation avait sa sortie stderr redirigée.
Il est possible de relier la sortie standard d'un processus à l'entrée standard d'un autre processus.
Si par exemple nous voulons connaître à un instant donné le nombre d'utilisateurs logés sur le système,
nous pouvons exécuter les commandes who et wc de la façon suivante:
$ who > tempo

Le fichier tempo contient le résultat de la commande who.
$ wc -l < tempo
7
$
La commande wc avec l'option l compte et affiche le nombre de lignes du fichier "tempo". Le nombre
d'utilisateurs connectés est donc de 7. Le fichier "tempo" assure la connexion entre les deux processus.
Il existe un opérateur tube ou pipe qui réalise la même fonction et évite la création du fichier
intermédiaire:
C'est l'opérateur « | » qui relie la sortie standard d'un processus à l'entrée standard d'un autre processus
:
a. Exemples
C'est le Shell qui assure la connexion des deux processus :

$ who | wc -l
7
$
La commande ci-dessous permet de lister le répertoire page par page :

$ ls -l | more

E.5. Exemple de « fichier de commandes » ou « fichier script »
$ cat commande
echo "vous travaillez sur UNIX"
echo " nous sommes: \c"
date
echo "vous êtes :\c"; who I am
echo "vous travaillez avec" ; who
echo "votre répertoire actuel est: \c"
pwd
$
Le fichier commande est un fichier "texte" qui sera interprété par le Shell. Pour exécuter "commande" il
faut :
 Soit faire appel explicitement à la commande sh qui exécute les commandes:
$ sh commande
 Soit rendre le fichier exécutable et le lancer comme une commande:

$ chmod u+x commande
$ commande
E.6. Compléments sur les métacaractères

Certains caractères ont une signification particulière pour le Shell et sont appelés métacaractères (nous
étudierons la fonctionnalité de certains plus loin), ce sont :
*, ?, [...],$, #, &, ; ,> , >>, <, <<, |, ‘,",`, \, (), {}.
Rappelons que les métacaractères *, ?, [...] permettent de construire des chaînes de caractères
génériques, ainsi :
 * désigne une chaîne de caractères quelconque ;
 ? désigne un caractère quelconque ;
 [...] désigne les caractères entre crochets, définis par énumération ou par un intervalle.
D’autres permettent de modifier l'interprétation d'une commande :

 ; (le point virgule) sépare deux commandes sur une même ligne ;
 ' (l’apostrophe) délimite une chaîne de caractères contenant des espaces (à l'intérieur, tous les
métacaractères perdent leur signification) ;
 " (le guillemet) délimite une chaîne de caractères contenant des espaces (à l'intérieur, tous les
métacaractères perdent leur signification, à l'exception des métacaractères `, \et $) ;
 ` (l’accent grave) "capture" la sortie standard pour former un nouvel argument ou une nouvelle
commande (cette particularité est présentée plus loin) ;
 \ (l’anti-slash) annihile la signification du métacaractère qui suit ;

 { et } (les accolades) permettent de regrouper un ensemble de commandes et de les exécuter

dans le "Shell courant" ;
 ( et ) (les parenthèses) permettent de regrouper un ensemble de commandes et de les exécuter
dans un "Shell fils".
Pour qu'un métacaractère perde sa signification et soit interprété autrement par le Shell, il suffit de placer
le caractère \ devant. D’une façon générale, lorsqu’un ou plusieurs métacaractères figurent dans une
chaîne de caractères, il est parfois préférable d’utiliser le « quotage ». Le quotage est utilisé pour
supprimer les fonctionnalités de certains caractères spéciaux du Shell, dont les métacaractères.
Ainsi :
 Les simples quotes '...' (apostrophes) : les caractères inclus entre 2 simples quotes ne sont pas
évalués, ils conservent leur valeur littérale ;
 Les doubles quotes "..." (guillemets) : les caractères inclus entre 2 doubles quotes conservent
leur valeur littérale à l'exception de $ ` et \. Les substitutions des variables sont réalisées (rôle de
$) ainsi que l'évaluation des commandes.
F. Notion de variable
Une variable Shell est identifiée par un nom commençant nécessairement par une lettre et peut être
utilisée dans les commandes (au sens large). La référence au contenu d'une variable est obtenue en
faisant précéder son nom du caractère $.
F.1. Déclaration
variable=valeur
# Utilisation
variable2=$variable ou variable2=${variable}
Exemples
$ variable=rouge Remarquez l'absence d'espace entre le signe =
$ echo $variable
rouge
$
On utilise une variable, par exemple, pour mémoriser des noms fréquemment utilisés :
$ moi=/users/toto
$ cd /
$ pwd
/
$ cd $moi
$ pwd
/users/toto
$

F.2. Variables de substitution prédéfinies
Ces variables sont liées à l'exécution d'une commande, elles ne peuvent être modifiées. Elles sont
évaluées, c’est-à-dire qu’elles sont toujours évoquées précédées du caractère $.
 0 nom du script (pathname) ($0) ;

 1, ..., 9 arguments (du 1er au 9ème) ($1, ..., $9) ;
 # nombre d'arguments passés dans une commande ($#) ;
 * liste de tous les arguments passés dans une commande ($*) ;
 @ liste de tous les arguments ($@) ;
 ? code retourné par la dernière commande exécutée($?) ;
 $ numéro de processus de ce Shell ($$) ;
 ! numéro du dernier processus lancé en arrière plan ($!) ;
 - drapeaux fournis au Shell par set ($-).
Toutes les valeurs retournées sont exprimées en décimal.
F.3. Variables d'environnement prédéfinies
Ces variables sont dites d’environnement parce qu’elles sont transmises à tous les processus fils du Shell
et donc en particulier par le Shell de login à ses processus fils.
 HOME chemin d'accès au répertoire initial de l'utilisateur ; argument par défaut de la commande
cd(1) ;
 PATH définition de la liste des répertoires à parcourir lors de l'interprétation d'un nom de
commande ;
 PS1 invite principale ("prompt") du Shell en mode interpréteur qui est par défaut le "$" ;
 PS2 invite secondaire du Shell en mode programmation qui est par défaut le ">" ;
 IFS séparateurs de champ des arguments qui sont normalement l'espace, la tabulation et la fin de
ligne ;
 MAIL chemin d'accès à la boîte aux lettres utilisateur ;
 MAILCHECK intervalle en secondes 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 ;

a. Exemples
Il est possible de connaître les variables pré définies de son environnement grâce à la commande env :
$ env
HOME=/user1/fred
LOGNAME=fred
MAIL=/usr/mail/fred
PATH=:/bin:/usr/bin
TERM=q101 Remarquez la variable d'environnement TERM qui permet de définir
l'émulation du terminal utilisé.
......
$
Nous pouvons changer la définition du prompt :

$ echo $PS1
$
$ PS1='toto '
toto
Certaines de ces variables sont initialisées lors de la procédure du login. D'autres peuvent être modifiées
lors de l'ouverture d'une session lorsque l'interpréteur de commandes (le Shell) lit et exécute un fichier
".profile" qui doit se trouver sous le répertoire de login.
Nous pouvons, par exemple, dans ce fichier redéfinir les caractères « erase » et « kill » :
Exemple de fichier .profile

$ cat .profile
PATH=:/user/bernard/bin:/bin:/usr/bin
MAIL=/usr/spool/mail/bernard
stty kill'Û' erase 'DEL'
TERM=q101
export PATH MAIL TERM
$
Remarquons que la variable PATH est modifiable à tout moment, en effet, il est possible de la redéfinir
soit explicitement :
PATH=:/bin:/usr/bin:/$HOME/bin
Soit concaténer son ancienne valeur avec d’autres chemins, le séparateur étant le caractère : (deux
points) :
PATH=$PATH:$HOME/bin
Il est utile, après modification du fichier .profile, de faire prendre en compte son nouveau contenu sans
qu’il soit nécessaire de fermer et réouvrir une session. Pour cela une syntaxe particulière force l’exécution
de ce fichier par le shell courant et non par un shell fils — ce qui serait sans effet — Cette forme est la
suivante :
$ cd
$ . .profile

F.4. Transmission des paramètres

La communication entre le Shell et les procédures de commande est réalisée au moyen de paramètres
transmis par valeur.
Les paramètres sont repérés par leur position dans la liste d'appel :
 0 correspond au nom de la commande,
 1 au premier paramètre, 2 au deuxième paramètre,..., 9 au neuvième et dernier.
L'affectation d'une valeur à ces paramètres peut être faite dans la procédure appelée par la commande
interne set, qui affecte dans l'ordre les différents arguments aux paramètres positionnels.
Exemple
$ cat commande
echo "valeur des paramètres après appel"
echo $1;echo $2;echo $3
set dix onze douze
echo "valeur des paramètres après set"
echo $1;echo $2;echo $3
$
$ commande un deux trois
valeur des paramètres après appel
un
deux
trois
valeur des paramètres après set
dix
onze
douze
$
F.5. La capture de la sortie standard du résultat d’une commande

Le Shell permet l’affectation à une variable de la sortie standard du résultat d’une commande grâce au
caractère ` (accent grave à ne pas confondre avec la simple quote ‘).
Exemples
$ list=`ls *.c`
$ echo $list
es.c exemple.c devoir.c
$ a=10
$ a=èxpr $a + 1`
$ echo $a
11
$

G. Les structures de contrôle

L'analogie avec les langages algorithmiques se retrouve avec ces structures de contrôle dans lesquelles les
instructions sont des listes de commandes.
G.1. La structure conditionnelle if then else fi

a. 1ère forme de if
if liste_commandes
then liste_commandes_1
else liste_commandes_2
fi
La liste des commandes suivant if est exécutée, si la valeur de retour est 0, la liste des commandes
suivant then est exécutée (liste_commandes_1) sinon c'est la liste suivant else (liste_commandes_2) qui
est exécutée, si elle existe.
Remarques
 La branche else est facultative.
 Pour être reconnu de la commande, les mots if, then, else doivent être:
soit le 1er mot de la commande,
soit être précédés d'un ; (point virgule), comme ci-dessous :
if liste des commandes ;then liste des commandes ;else liste des commandes ;fi
Ce qui est beaucoup moins lisible.
 Ceci est vrai pour toutes les structures de contrôles de Shell.

 En Shell : la valeur 0 est associée au booléen "vrai" et toute autre valeur correspond au booléen
"faux" (convention inverse de celle du langage C).
Exemple 1
Ecrire une commande qui compare deux fichiers à l'aide de la commande cmp.
Voici un extrait de la commande cmp :
cmp [-l] [-s] fichier1 fichier2
-l imprime la position où commence la différence,
-s n'affiche rien.
Dans tous les cas, la commande retourne le code suivant:
0 les fichiers sont identiques,
1 les fichiers sont différents,
2 problème...
D'où le programme :
$ cat testif
if cmp -s $1 $2

then echo $1 et $2 sont identiques

else echo $1 et $2 sont différents
fi
$
Et son exécution :
$ sh testif truc machin
truc et machin sont différents
$
$ chmod u+x testif
$ testif truc truc
truc et truc sont identiques
$
Remarque importante : Ce programme fonctionnera correctement si les arguments fournis à la commande

sont bien au nombre de 2 et si ce sont bien des noms de fichiers. Il faudra donc ajouter à cet exemple
d’autres tests de validité (voir la commande test).
Il est possible d'utiliser les opérateurs ET et OU dans la liste des commandes. Ces opérateurs sont:
 -o pour le OU logique,
 -a pour le ET logique.
Exemple 2
if test -z $2 -o -z $3
then echo il faut 3 paramètres
else
......
fi.
La commande test avec l'option z retourne la valeur 0 si la longueur de la chaîne (ici $2 ou $3) est nulle.
Voir documentation UNIX.
La structure conditionnelle peut se généraliser grâce au « elif »:

if liste_commandes
then
liste_commandes_1
elif liste_commandes
then
liste_commandes_2
else
liste_commandes_3
fi
# et ainsi de suite …
b. 2ème forme de if
La 2ème forme de if permet de tester, grâce à des opérateurs, différentes valeurs sans passer par la
commande test. Pour cela, il faut utiliser la syntaxe suivante :

if [ expression ]
then
commandes...
fi
Voici une liste des opérateurs utilisables pour définir une expression :
Opérateur Description
Numériques
-eq « equals ». Test l’égalité numérique
-ne « non equals ». Test la non égalité numérique
-lt « less than ». Test la stricte infériorité numérique
-gt « greater than ». Test la stricte supériorité numérique
-ge « greater equals ». Test la supériorité ou l’égalité numérique
-le « less equals ». Test l’infériorité ou l’égalité numérique
Chaînes de caractères
-z Teste si la chaîne est vide
-n Teste si la chaîne est non vide
= Teste si la chaîne est égale à une autre
!= Teste si la chaîne est différente d’une autre
Fichiers
-L Lien symbolique
-d Teste si c’est un répertoire
-f Teste si c’est un fichier ordinaire
-s Teste si le fichier est vide
-r Teste si le fichier est lisible (Droits de lecture)
-w Teste si le fichier est modifiable
-x Teste si le fichier est exécutable
-nt Teste si le fichier est plus récent
-ot Teste si le fichier est plus vieux
Logique
! Exprime la négation
-a Opérateur « ET »
-o Opérateur « OU »
Quelques exemples :
# Teste si le paramètre $1 est egal à 2
if [ $1 -eq 2 ]
# Teste si le paramètre $1 est une chaine égale à « toto »

if [ $1 = toto ]
# Teste si le paramètre $1 est une chaine vide

if [ -z $1 ]
# Teste si le paramètre $1 est un répertoire

if [ -d $1 ]
# Teste si le paramètre $1 est plus récent que /etc/xorg.conf

if [ $1 -nt /etc/xorg.conf ]
# Teste le fichier est exécutable et modifiable

if [ -w toto.txt -a -x toto.txt ]
G.2. La bouche pour : for
for nom [ in mot1 mot2 ... moti ... ]

do
liste de commandes
done
« nom » est une variable Shell qui prend successivement les valeurs mot ( mot 1, mot 2, mot 3...moti...)
pour chaque exécution de la liste de commandes comprise entre do et done.
Exemple 1
$ cat for_1
for i in un deux trois
do
echo $i
done
$
$ chmod u+x for_1
$ for_1
un
deux
trois
Lorsque la liste des mots est omise ([ in mot1 mot 2 ... moti ... ]), la variable prend comme valeurs
successives, les valeurs des paramètres de position.
Exemple 2
$ cat for_2
for i
do
echo $i\c
done
$
$ chmod u+x for_2

$ for_2 un deux trois
un deux trois
$
Exemple 3
$ cat testfichier
# cet exercice est plus difficile à comprendre pour l’instant

# il faut maîtriser la commande shift et la commande test

# passer cet exemple dans une première lecture
for i
do
f=$1
shift
if test -f $f
then
echo $f est un fichier
else
echo $f n\’est pas un fichier
done
G.3. La boucle tant que : while
while liste de commandes

do liste de commandes
done
La liste de commandes comprise entre do et done est répétée tant que la liste de commandes suivant
while retourne un résultat vrai.
Exemple 1
$ cat testwhile
# cette commande affiche les entiers 1 à 10 !
i=1
l=10
while [ $i -le $l ]
do
echo $i
i=èxpr $i + 1`
done
G.4. La boucle jusqu’à : until
until liste de commandes

do liste de commandes
done
La liste de commandes comprise entre do et done est répétée jussqu’à ce que la liste de commandes
suivant until retourne un résultat vrai.
Exemple
$ cat testuntil
# cette commande affiche les entiers 1 à 10 !
i=1
l=10
until [ $i –gt $l ]
do
echo $i

i=èxpr $i + 1`
done
G.5. Le branchement multiple
case mot in
suite de caractères ) liste de commandes ;;
suite de caractères) liste de commandes ;;
..........
esac
La seule liste de commandes exécutée est la première qui correspond à la suite de caractères. Les autres
ne seront pas exécutées.
Exemple
$ cat forcase
for i
do
case $i in
A) echo $i : vous avez tapé A ;;
B | C) echo $i : vous avez tapé B ou C ;;
?)echo $i : vous avez tapé un autre caractère que A, B, ou C;;
*) echo $i : vous avez tapé une chaîne de caractères ;;
esac
done
Remarques :
 B | C se lit B ou C
 ? se lit: n'importe quel caractère
 * se lit: n'importe quelle chaîne de caractères et correspond de ce fait à l'option par défaut.
G.6. L’exécution de commandes dans un sous-shell

Les commandes placées entre parenthèses sont exécutées dans un sous-shell. L’exemple ci-dessous
illsustre cette particularité. Nous remarquons que le changement de répertoire ayant lieu dans le sous-
shell n’affecte pas le répertoire du shell courant (père) :
$ pwd
/users/ozbolt
$ (cd /tmp ; rm essai* ; )
$ pwd
/users/ozbolt
G.7. Exemple de synthèse

Cette commande est une alternative à la commande rm : elle permet de ne pas détruire immédiatement
les fichiers mais de les conserver pendant un certain temps.

Les fichiers sont déplacés dans le répertoires $HOME/.del. Chaque fichier est suffixé par un numéro de
version précédé du signe = pour éviter les homonymies.
# !/bin/sh
# la ligne ci-dessus indique que cette commande doit être exécutée
# par /bin/sh
# usage de la commande : del fichier1 fichier2 fichier3 ...
if [ $# -lt 1 ]
then
echo "usage : del fichier2 fichier3 ..."
exit 1
fi
if [ ! -d $HOME/.del ]
then
mkdir $HOME/.del
fi
for i
do
v=1
if [ -f $i]
then
while [ -f $HOME/.del/$i=$v ]
do v=èxpr $v + 1` done
mv $i $HOME/.del/$i=$v
else
echo "$i : ce fichier n’existe pas."
fi
done
Il faut de temps en temps nettoyer le répertoire $HOME/.del, par exemple toutes les semaines grâce à
une procédure de nettoyage lancée automatiquement (voir le chapitre sur les sauvegardes).
H. Les variables de type numérique

En Bourne-Shell, il n'y a pas à proprement parlé de variables numériques. Les opérations arithmétiques
sont réalisées grâce à la commande « expr » qui interprète certains de ses paramètres de position qui
doivent être des chaînes de caractères données en arguments en appel de la commande. Les arguments
incorrects provoquent une erreur de la commande « expr » et un code d'erreur de valeur 2 est alors
retourné (voir documentation de la commande).
Exemple
Ecrire une commande admettant un argument n dont on s'assurera qu'il est numérique et qui affiche la
suite des n premiers entiers.
Analyse
Nous allons, en premier lieu écrire une commande qui vérifiera que son argument est bien numérique.
Pour tester qu'un argument est bien numérique, il suffit de l'impliquer dans une expression arithmétique
fournie en argument à la commande expr. Dans le cas où l'argument est non numérique, la commande
expr retournera un code d'erreur égal à 2, dans le cas où l'argument est numérique cette valeur sera 0. La
commande numérique ci-dessous aura comme code d'erreur 0 si l'argument fourni est numérique et 1
sinon.

Traduction en SHELL
$ cat numeric
# commande testant si une chaine est numerique ou non :
# elle renvoie 0 si elle l'est 1 si elle ne l'est pas
expr $1 + 1 >/dev/null 2>/dev/null
if [ $? -eq 2 ] ; then exit 1 ; else exit 0; fi
$ numeric tyty
$ echo $?
1
$ numeric 123
$ echo $?
0
On remarquera :
 Que les éventuels messages d'erreurs ont été redirigés vers le fichier spécial /dev/null afin qu'ils
n'apparaissent pas à l'écran;
 Que nous avons utilisé une nouvelle syntaxe pour la commande test qui utilise les [ ];
 Que nous retournons une valeur au Shell appelant en utilisant la commande exit
On utilisera maintenant cette commande pour écrire la commande finale demandée. (à faire en exercice).
I. Le traitement des événements
Un certain nombre d'événements entraînent l'émission d'un signal correspondant au type de

l'événement. Par exemple, la frappe de certains caractères provoquent l'émission d'un signal à
destination du processus en avant plan sur le terminal. Ainsi, les caractères intr (CTRL+C) ou quit (CTRL+D)
provoquent la terminaison des processus le recevant.
Voici quelques signaux :

N° NOM Action
1 SIGHUP terminaison du processus leader de session
2 SIGINT frappe du caractère intr au clavier
3 SIGQUIT frappe du caractère quit au clavier
9 SIGKILL signal de terminaison
La commande interne « trap » permet de définir une séquence de commandes à exécuter lors de la prise
en compte de l’événement par la procédure :
trap [argument] num_signal
Les différentes formes de l'argument sont :

 La chaîne vide "" le signal reçu est ignoré ;
 Une commande qui sera alors exécutée à la réception du signal ;
 Aucun, dans ce cas, les comportements par défaut des signaux énumérés seront réinstallés.
Exemple

$ trap 'rm temporaire;exit' 2
Dans cet exemple, en cas d'arrivée de l'événement 2 (SIGINT), le fichier "temporaire" est détruit avant de
provoquer la sortie. Nous dirons que nous avons mis en place un piège pour intercepter l'événement 2.
Inversement, pour qu'une procédure ne tienne pas compte de l'arrivée de certains événements, il suffit
de transmettre la chaîne vide comme argument de trap :
$ trap '' 2 3
Les événements 2 et 3 sont masqués.
Il est possible de réinstaller ces événements par la commande :
$ trap 2 3
J. La notion de fonction
La définition d'une fonction de nom « nom_de fonction » est réalisée par la séquence :
nom_de_fonction() { liste des commandes }
Un appel de fonction est réalisé de la même manière qu'un appel de commandes.
Premier exemple
$ cat fonction
#!/bin/sh
#
# Exemple de script avec fonctions
usage()
{
echo "usage: $1 $2"
}
main()
{
if [ $# = 0 ]; then
usage `basename $0` "fichier";
exit 1
fi
}
main $*
Exemple
Ecrire une fonction qui affecte une valeur, appartenant à un intervalle, à une variable.
exemple d'appel : J=`choisi Jour 1-31`, ce qui signifie : affecter à la variable J une valeur comprise entre 1
et 31. Le nom de la fonction est "choisi", Jour étant une chaîne de caractères indiquant à l'utilisateur qu'il
s'agit d'un jour compris entre les valeurs 1 et 31.
Analyse
La seule difficulté est la validité des données dans l'intervalle donné. En outre, il faut entrer des
caractères numériques. Plus précisément, il faut entrer un ou deux caractères numériques.

Une première structure itérative lira un ou deux caractères numériques et une deuxième structure
itérative vérifiera la validité de l'intervalle.
Dans le programme ci-dessous, on saisit la date en imposant un intervalle à chaque élément.

La commande « while : » est une boucle infinie. La sortie se fera grâce à un « break ». On sort de la
structure la plus interne après avoir entré correctement un ou deux chiffres. On sort de la structure
externe si la donnée est bien dans l'intervalle passé en paramètre à la fonction choisi et repéré par les
paramètres de position 1 et 2 ($1, $2).
# la fonction choisi
choisi()
{
while :
do
while :
do
echo "$1 ($2 - $3)" >&2
read A
case $A in
[0-9]) break ;;
[0-9][0-9]) break ;;
esac
done
if [ $A -le $3 -a $A -ge $2 ]
then
break
fi
done
case $A in
?)A="0$A";;
esac
echo $A
}
# programme principal
echo "mise à jour de la date et de l'heure"
J=`choisi Jour 1 31`
M=`choisi Mois 1 12`
A=`choisi An 55 99`
H=`choisi Heure 0 23`
MN=`choisi Minute 0 59`
date $M$J$H$MN$A
exit 0
K. Quelques commandes utiles

K.1. echo - affichage
echo argument ...

La commande « echo » affiche sur la sortie standard (stdin) la liste de ses arguments séparés par des
espaces et terminé par un caractère fin de ligne. La commande reconnaît (selon les versions d’UNIX) un
certain nombre de caractères :
\b backspace
\c pas de caractère fin de ligne
\t tabulation
etc.
K.2. test - commande conditionnelle
test arg
La commande « test » évalue l'expression indiquée. Si la valeur de cette expression est vraie, la
commande prend pour code de retour la valeur zéro et une valeur différente de zéro si la valeur de
l'expression est fausse. La commande test prend pour code de retour une valeur différente de zéro s'il n'y
a aucun argument.
Les arguments suivants doivent être utilisés pour construire une expression. Tous les opérateurs et toutes
les options constituent des arguments séparés.
 -r fich Le fichier existe et est accessible en lecture.

 -w fich Le fichier existe et est accessible en écriture.
 -f fich Le fichier existe et n'est pas un catalogue.
 - d fich Le fichier existe et est un répertoire.
 - s fich Le fichier existe et est d'une dimension supérieure à zéro.
 - z s1 La longueur de la chaîne s1 est zéro.
 - n s1 La longueur de la chaîne s1 est différente de zéro.
 s1 = s2 Les chaînes s1 et s2 sont identiques.
 s1 != s2 Les chaînes s1 et s2 sont différentes.
 n1 -eq n2 Les entiers n1 et n2 sont algébriquement équivalents. Il est possible d'utiliser
n'importe quel comparateur suivant : -ne, -gt, -ge, -lt, -le.
Ces opérateurs peuvent être associés avec les opérateurs suivants dans lesquels, l'opérateur -a
possède une priorité supérieure à -o.
! Négation.
-a ET.
-o OU.
( expr ) Regroupement.

K.3. file - commande de classification
file [-f] arg
La commande file essaie de classifier le fichier arg (ASCII, binaire, répertoire, source C, source Shell, etc.).
L'option f indique que le premier argument contient la liste des fichiers dont on veut déterminer le type.
K.4. read - commande de lecture
read var
La commande read permet d'initialiser la variable var par lecture de l'entrée standard stdin.
K.5. cmd - commande de comparaison
cmp [-l] [-s] fichier1 fichier2
Les contenus des deux fichiers en référence sont comparés. Selon l'option, les résultats sont :
 -l imprime la position où commence la différence,
 -s n'affiche rien.
Dans tous les cas, la commande retourne le code suivant:

0 les fichiers sont identiques,
1 les fichiers sont différents,
2 problème, fichier inexistant par exemple.
K.6. grep - commande de recherche
grep [option] expression régulière [fichier ...]
Les commandes de la famille grep (voir aussi egrep, fgrep) recherchent dans les fichiers en entrée (stdin
par défaut) les lignes qui contiennent une chaîne de caractères indiquée par l'expression régulière. Sauf
option contraire, chaque ligne ayant cette propriété est écrite sur la sortie standard.
Les principales options de la commande sont :

 -c afficher uniquement le nombre de lignes contenant la chaîne.
 -i pas de distinction entre minuscules et majuscules.
 -n chaque ligne est précédée de son numéro d'ordre dans le fichier.
 -v afficher toutes les lignes sauf celles contenant la chaîne.

Dans tous les cas, la commande retourne le code suivant :

0 au moins une ligne satisfaisante
1 aucune ligne satisfaisante
2 erreur de syntaxe ou fichier(s) inaccessible(s).
Il faut faire attention quand on utilise certains caractères spéciaux dans l'expression régulière car ils ont
une signification particulière pour le Shell. Dans ce cas, il est préférable de mettre l'expression régulière
entre guillemets.

K.7. sed -le filtre éditeur
La commande sed est un éditeur non conversationnel utilisé en temps que filtre. Chaque ligne de l'entrée
est lue et la requête correspondante est exécutée. Les requêtes de sed sont les mêmes que celles de ed.
La répétition des requêtes globales de substitutions est plus efficace avec sed qu'avec ed.
La commande sed est appelée par :

sed -e texte-des-requêtes
ou par
sed -f fichier-des-requêtes
Les requêtes sont appliqués à l'entrée standard. Le texte des requêtes peut être mis entre apostrophes,
pour éviter l'interprétation de certains caractères par le Shell. La forme générale d'une requête est:
adresse1, adresse2 requête argument.
Si les adresses ne sont pas indiquées, la requête s'applique à toutes les lignes. Si les deux adresses sont
identiques, une seule adresse est suffisante. D'une manière générale, les adresses déterminent le
morceau du fichier qui est concerné par la requête. Les adresses peuvent être décrites par un nombre
décimal ou par une expression régulière (semblable à celle de ed) placées entre /. Les opérateurs + et - ne
sont pas autorisés pour adresser une ligne. De la même manière que pour ed, la requête s'applique à la
ligne dont l'adresse correspond à l'expression.
Les requêtes de sed sont les suivantes:

 s/.../.../ Remplacer une chaîne.
d Détruire une ligne.
 a\ Ajouter le texte après la ligne courante.
 i\ Insérer du texte avant la ligne courante.
 c\ Modifier la ligne courante.
Chaque ligne contenant une requête a, i ou c se termine par le caractère \ à l'exception de la dernière
ligne. Il existe également des requêtes pour lire un fichier (r), pour écrire un fichier (w) et pour afficher
(p).
La commande chemin de la figure ci-dessous est une illustration typique de la commande sed. La bouche
externe affecte chaque élément du catalogue à la variable j, la bouche interne affecte la variable i avec
chaque mot (différent du blanc) produit par la commande:
echo $PATH | sed -e 's/:/ /g'

Elle produit la liste de tous les catalogues de la variable Shell $PATH.
for j do
for i in ècho $PATH | sed -e 's/:/ /g'`

do if test -f $i/$j
then echo $i/$j
fi
done
done
K.8. sort - tri et fusion de fichiers
sort fichier1 fichier2 ...
Lorsqu'on exécute la commande : sort fichier1 fichier2 ..., toutes les lignes de tous les fichiers sont triées
et envoyées sur la sortie standard. Si aucun nom de fichier n'est précisé, c'est l'entrée standard qui est
triée, cela permet d'utiliser sort en tant que filtre. Le tri se fait, par défaut, sur la ligne entière en utilisant
l'ordre lexicographique de chaque octet (en général c'est le code ASCII qui est employé). On peut
demander un tri numérique à l'aide d'une option.
La forme
+pos1 -posl
restreint la zone qui est utilisée pour le tri au champ qui commence avec la position pos1 et qui se
termine juste avant pos.2.
Par exemple, la commande suivante trie sur le premier et le quatrième champ :

sort +0 -1 +3 -4
Une position de départ peut être suivie de la lettre n pour indiquer un tri numérique sur la zone. Par
exemple :
sort +0n...
indique que l'on trie numériquement sur le premier champ.
Le caractère de séparation de champ est par défaut le blanc, on peut modifier cette valeur par l'option -t.
Ainsi,
sort -t: ...

trie sur des champs qui sont séparés par des deux points.
Les autres options possibles sont les suivantes:

 -n Trier en utilisant la valeur numérique du champ.
 -r Trier par ordre décroissant.
 -u Supprimer toutes les lignes identiques (sauf une).

K.9. basename-dépouiller une chaîne
basename chaîne [suffixe]
La commande basename supprime dans la chaîne tout préfixe qui se termine par / ou par le suffixe
indiqué.
Le résultat est affiché sur la sortie standard.
K.10. expr - évaluation des arguments en tant qu'expressions
expr arg ...
Les arguments sont considérés comme des expressions. Après l'évaluation, le résultat est envoyé sur la
sortie standard. Chaque élément de l'expression est un des arguments.
La liste des opérateurs est donnée ci-dessous. Cette liste est donnée dans l'ordre croissant des priorités.
Les opérateurs qui ont une même priorité ont été regroupés :
 expr1 | expr2 Prend la valeur de la première expression si elle est non nulle, sinon
prend la valeur de la deuxième expression.
 expr1 & expr2 Prend la valeur de la première expression si les deux expressions sont
différentes de zéro, sinon prend la valeur de la deuxième expression.
 expr1 op expr2 Prend la valeur 1 si le résultat de la comparaison est vrai, prend la valeur 0
sinon. L'opérateur op est l'un des suivants : <, <=, =, !=, >, => . La comparaison est numérique si
les deux expressions sont des entiers, elle est lexicographique dans tous les autres cas.
 expr1 + expr2
 expr1 - expr2 Addition ou soustraction des arguments.
 expr1 * expr2
 expr1 / expr2 Multiplication, division ou reste après division des arguments
 expr1 % expr2
 expr1 : expr2 On compare la chaîne de caractères (première expression) avec l'expression
générique (deuxième expression). La syntaxe de l'expression générique est la même que dans
l’éditeur ed(1). On peut utiliser les séquences \ (et \ ) pour extraire une sous-chaîne du premier
argument. Cette comparaison donne comme résultat le nombre de caractères identiques (0 si
aucun).
 ( expr ) Utilisation des parenthèses pour regrouper des expressions.
Il est souvent nécessaire de neutraliser les caractères spéciaux à l'aide du caractère \.

Par exemple, on écrira : expr \* expr pour que le caractère * perde sa signification de caractère spécial du
Shell.

Les codes de retour possibles d'un processus exécutant la commande ont la signification suivante :
 0 : l'expression n'est ni vide ni nulle

 1 : l'expression est soit vide soit nulle
 2 : l'expression est incorrecte.
 >2 : erreur en cours de l'évaluation de l'expression.

L. Un résumé de quelques commandes par ordre alphabétique
Nom Description Options Paramètres

cal affiche le calendrier de mois année
l'année spécifiée en
paramètre
cat affiche sur la sortie standard nom(s) de
le contenu du fichier fichier(s)
mentionné
cd se positionne sur le sans paramètre, se positionne
chemin d'accès à
répertoire désigné sur le répertoire de loginun répertoire
chmod change les permissions en -R change les droits
(mode = ugo)
lecture, écriture, exécution récursivement à partir du mode- nom de
nœud fichier ou de
répertoire
compres compresse un fichier (voir -c : résultat sans modification fichier
s
gzip) du fichier d'origine
-f : écrasement d'un fichier
compressé préexistant
-v : taux de compression
cp copie du fichier source vers la -i : demande confirmation source-
destination -p : conservation de date et destination
droits
-r : recopie récursive d'un
répertoire
date retourne la date courante
diff compare deux fichiers et -c : affiche 3 lignes avant et 3 fichier1 fichier2
affiche les différences lignes après
echo envoi en écho des -n : supprime le retour chariot
paramètres spécifiés à la en fin de commande
suite ($PATH, "bille")
elm courrier électronique -s : chaîne de caractères qui destinataire
sera le sujet du message
-f : nom de la boîte à lettres
file retourne le type de fichier nom de fichier
spécifié (ascii, ps, exé.sparc
ou 68040)
find recherche récursive d'un -name fichier : fichier à
réperto
ire
fichier à partir du répertoire chercher
-print : affiche le chemin
trouvé
grep affiche les lignes du fichier -v : seulement les lignes ne chaîne de

contenant la chaîne de contenant pas la chaîne caractères -
caractères -i : majuscules et minuscules fichier

identiques
-n : avec numéros de lignes
-c : nombre de comparaisons
positives
gunzip décompresse un fichier -c : le résultat est produit sans nom de fichier
modification du fichier
d'origine
-v : taux de compression
gzip compresse un fichier (voir -c : résultat sans modification nom de fichier
compress) par défaut, la du fichier source
destination est la sortie -f : écrasement d'un fichier
standard qu'on redirige vers compressé préexistant
un fichier si on veut obtenir -v : taux de compression
un fichier compressé -d : force une décompression
-9 : niveau maximum de
compression
head liste les n premières lignes du -n : nombre de lignes affichées source >
fichier (par défaut 10) destination
id retourne le nom de login,
l'UID, le groupe et le GID
kill envoi d'un signal à un -l : liste des signaux disponibles numéro du
processus -n : numéro du signal à processus
envoyer
2 : INT (ctrl-c : )
3 : QUIT (ctrl-\)
9 : KILL
ln création d'une nouvelle -s : création d'un lien source -
référence pour un fichier symbolique destination
préexistant
logname retourne le nom de login de
l'utilisateur
ls liste le contenu d'un -a : prise en compte des nom de
répertoire fichiers cachés répertoire
-F : renseigne sur le type de
fichier (*, /, @)
-i : précision du numéro
d'inode des fichiers
-R : liste récursivement le
contenu du répertoire
-l : informations détaillées
-g : ajout du nom du groupe
-d : renseigne sur le répertoire
lui-même
-t : liste par date de
modification
-u : liste par date d'accès

-r : ordre inverse
mail courrier électronique -s : chaîne de caractères qui destinataire -
sera le sujet du message <fichier>
-f : nom de la boîte à lettres
-v : trace du mail jusqu'à sa
délivrance
man retourne le mode d'emploi nom de

de la commande s'il existe commande
mkdir création d'un répertoire nom de
répertoire
more liste le contenu d'un fichier nom de fichier
page par page
mv déplace fichiers et -i : demande confirmation source –
répertoires destination
ps liste des processus BSD -a : processus détenus par les
autres utilisateurs
-u : nom du propriétaire du
processus
-x : processus sans terminal
associé
-l : description complète
-t : terminal particulier
ps liste des processus Système V -f : ou l : description plus ou
moins longue
-e : liste tous les processus
-p : processus dont le numéro
suit l'option p
-t : processus attachés au
terminal spécifié
-u : processus appartenant au
propriétaire dont le nom ou
l'UID est donné
pwd retourne la référence
absolue du répertoire
courant
rlogin ouvrir une session vers une -l : nom de login nom de machine
machine distante (sortie
:exit)
rm supprime la référence du -f : force la commande sans nom de fichier ou
fichier dans le répertoire s'occuper des droits de répertoire
-i : demande confirmation
-r : destruction récursive
rmdir suppression d'un répertoire nom de
vide répertoire
sleep ne fait rien pendant n temps en

secondes secondes
sort tri des lignes du fichier -r : tri inverse fichier
suivant l'ordre ASCII -u : élimine les lignes
identiques
tail liste les n dernières lignes du -n : nombre de lignes affichées nom de fichier
fichier (par défaut 10)
talk, permet de converser avec destination
ytalk
une machine distante
tar archivage/désarchivage de c : création de l'archive archive -
fichiers x : restauration de l'archive répertoire ou
t : listage du contenu de fichiers
l'archive
v : mode verbeux
p : préserve dates et droits à la
restauration
f : le nom du fichier spécifié
sera celui de l'archive
telnet établir une connexion avec nom de machine
une machine distante (sortie
: exit)
touch modifie les caractéristiques -a : dernier accès seulement fichier
d'un fichier (option -a : par -m : dernière modification
défaut) seulement
crée un fichier vide s'il
n'existe pas déjà
tty donne le nom du terminal
uname donne le nom du système -a : informations complètes
d'exploitation -n : nom de la machine
-r : release du système
d'exploitation
-s : nom du système
d'exploitation
uniq recopie de source dans -u : seules les lignes uniques source
destination après sont recopiées destination
suppression des lignes
identiques
uudecod restitue un fichier binaire à fichier
e
partir du fichier ASCII créé
avec uuencode
uuencod encode un fichier binaire en fichier - indication
e
fichier ASCII >fichier encodé
w aperçu de l'activité de la -h : supprime l'entête nom d'utilisateur
machine -s : affichage restreint
whereis retourne le chemin complet nom de la
d'accès à tous les répertoires commande
contenant la commande

which retourne le chemin complet nom de la

d'accès à une commande commande
who retourne le nom des
(am i)
utilisateurs qui ont ouvert
une session

Commandes Unix

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

Commandes Unix

Transféré par

Droits d'auteur :

Formats disponibles

Lycée polyvalent DIDEROT Département IRIS

61, rue David d’Angers

Auteur Version - Date Nom du fichier

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 2 / 36

Jean-Michel Moreno Jean-Marie Rifflet

Bernard Coulange Alain-Bernard Fontaine et Philippe

Christian Pélissier Divers Auteurs souvent talentueux

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 3 / 36

C.1. Les différents Shells à l’heure actuelle

D. La redirection des entrées sorties

Par exemple, les commandes suivantes :

Il est possible de rediriger ces entrées sorties.

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 4 / 36

D.1. Redirection de l'entrée standard

D.2. Redirection temporaire de l'entrée standard

[nom_commande] << [séparateur]

D.3. Redirection de la sortie standard

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 5 / 36

L'opérateur >> permet d'indiquer à l'interpréteur de commande la redirection de la sortie en ajout ou

 Si le fichier "res" n'existait pas il est créé ;

D.4. Redirection de la sortie d’erreur

D.5. Compléments sur les redirections

n>&m avec n et m descripteurs

$ echo « Nombre de paramètres incorrect » >&2

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 6 / 36

E. Exécution d'une commande ou d’un script

Le format d'une commande sous UNIX suit le modèle suivant :

$ cc essai.c 2 > erreur &

Si nous avions eu la commande:

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 7 / 36

Le processus 1732 est terminé.

E.3. L'enchaînement des commandes

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 8 / 36

E.4. Connexion de processus, les tubes ou pipes

$ who > tempo

C'est le Shell qui assure la connexion des deux processus :

La commande ci-dessous permet de lister le répertoire page par page :

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 9 / 36

E.5. Exemple de « fichier de commandes » ou « fichier script »

 Soit rendre le fichier exécutable et le lancer comme une commande:

E.6. Compléments sur les métacaractères

D’autres permettent de modifier l'interprétation d'une commande :

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 10 / 36

 { et } (les accolades) permettent de regrouper un ensemble de commandes et de les exécuter

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 11 / 36

F.2. Variables de substitution prédéfinies

 0 nom du script (pathname) ($0) ;

Toutes les valeurs retournées sont exprimées en décimal.

F.3. Variables d'environnement prédéfinies

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 12 / 36

Nous pouvons changer la définition du prompt :

Exemple de fichier .profile

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 13 / 36

F.4. Transmission des paramètres

F.5. La capture de la sortie standard du résultat d’une commande

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 14 / 36

G. Les structures de contrôle

G.1. La structure conditionnelle if then else fi

Ce qui est beaucoup moins lisible.

 Ceci est vrai pour toutes les structures de contrôles de Shell.

Le langage de commandes d'UNIX : Le shell - J.Ozbolt , G.Valet – Reproduction interdite 15 / 36

then echo $1 et $2 sont identiques

Remarque importante : Ce programme fonctionnera correctement si les arguments fournis à la commande