Résumé sur l’utilisation du système unix

Université de Tunis El Manar

Faculté des Sciences de Tunis

Résumé sur l’utilisation du système UNIX

(Exploitation et Programmation Shell)

par Y. SLIMANI

------------------------------------------------------------------------------------------------------
Ce résumé est destiné à vous faciliter l’utilisation du système pour réaliser vos travaux pratiques du cours de Système
d’Exploitation. Il contient quelques éléments de base pour l’utilisation du système UNIX. Il ne constitue qu’un guide
d’utilisation et ne peut pas remplacer un cours complet sur UNIX. La dernière partie de ce résumé est consacrée à la
programmation Shell sous Unix.

Le meilleur moyen d’apprendre à utiliser Unix est la pratique intensive sur machine, malgré les erreurs que vous
pourriez faire au début. Plus vous ferez d’erreurs, plus vous apprendrez à les éviter et à les éviter. A terme, cette
accumulation d’erreurs constituera un capital certain pour la mise en œuvre d’un système Unix.

------------------------------------------------------------------------------------------------------

1- Principes de base UNIX
1.1 Caractéristiques

Unix est système d'exploitation créé en 1969 par K. Thompson et D. Ritchie. C'est un système multi-
utilisateurs, c'est à dire capable de gérer plusieurs sessions de travail (mise en contact d'un utilisateur avec
une machine) simultanément. Il est capable de traiter plusieurs applications en même temps : c'est un système
multitâches. Il gère de plus le temps partagé, c'est à dire le partage de l'unité centrale entre les différentes
taches et processus. C'est aussi le premier système d'exploitation orienté réseau : mail, ftp, web …

1.2 Les utilisateurs UNIX

Sur un système UNIX, on trouve deux types d’utilisateurs :

1. Les personnes qui veulent utiliser (exploiter) le système. Pour elles, le système UNIX est un moyen,
un outil pour réaliser leurs applications.

2. Les personnes (généralement une seule) chargée de l'installation, de la configuration et de la bonne
------------------------------------------- 1 ---------------------------------------
Introduction à l’utilisation du système Unix Yahya SLIMANI

utilisation du système UNIX, Ce sont les administrateurs systèmes UNIX.

L’accès au système n’est autorisé que pour les personnes ayant un compte utilisateur. Ce compte est défini
par un nom et un mot de passe. Aucun accès n’est possible à un utilisateur n’ayant pas de compte. Ceci
constitue l’aspect sécurité du système. Une fois qu’un utilisateur a réussi à accéder à un système UNIX, il a
des droits limités (voir paragraphe 5). Ceci veut dire que certaines commandes lui sont interdites, qu’il n’a
pas accès à certaines parties du système, et qu’il n’a pas accès à tous les fichiers existants sur le système.
Ceci constitue l’aspect protection du système. . Les administrateurs systèmes ont par contre tous les droits
sur le système. Généralement le nombre d'administrateurs sur un système UNIX est limité à une seule
personne pour des raisons de responsabilité. Cet administrateur a un compte dont le nom est root.

1.3 Le shell

Pour exploiter une machine fonctionnant sous UNIX, l'utilisateur dispose des logiciels ou d'un utilitaire qui
lui permet la saisie directe de commandes. On appelle cet utilitaire le shell (interpréteur de commandes). Son
rôle est d'interpréter les commandes de l'utilisateur avant de les transmettre au système UNIX.

Il existe plusieurs types de shell, ils se différencient par la syntaxe et la richesse des commandes. Le plus
commun est le Bourne-Shell (sh), on trouve aussi le C-Shell (csh) qui s'apparente au langage de
programmation C et le Korn Shell (ksh).

2 Ouverture et fermeture de session
2.1 Ouverture de session

Pour accéder à un système UNIX , il faut ouvrir ce que l’on appelle une Session UNIX. Lors de la connexion
à partir d’un poste (PC ou station) une fenêtre à deux “cases” apparaît sur l’écran. Ces deux cases
contiennent, respectivement, les mots Login et Password. Il faut alors taper votre nom de login (par
exemple IF3_1) suivi de la touche Entrée, puis de saisir votre mot de passe qui vous a été donné. Vous
pouvez vous rendre compte que votre mot de passe n'apparaît pas en clair à l'écran, il est remplacé pour des
raisons de sécurité évidente par des * ou bien par des caractères invisibles à l’écran. Si votre login et mot de
passe sont corrects, vous verrez apparaître sur votre écran, le bureau UNIX ou une fenêtre noir et blanc avec
un prompt (invite du système). Si vous n’êtes pas l’administrateur, le prompt est matérialisé par le symbole $
(dollar). Si vous êtes l’administrateur, alors votre prompt est matérialisé par le symbole # (dieze).

2.2 Changement de password

Vous pouvez changer votre mot de passe à tout moment. Pour cela, vous disposez de la commande passwd.
Certains UNIX font en sorte que vous ne puissiez pas saisir un mot de passe simple, il faudra mettre au
moins 6 caractères, avec au moins un, voir deux, caractère non alphabétique. N'utilisez pas comme mot de
passe un mot du dictionnaire (donc facile à retrouver).

$ passwd
passwd Old passwd :******
Setting password for user : licm284
New password :******
Reenter password :******
$
2.3 Fermeture de session

Quand vous avez fini d'utiliser le système, vous devez vous déconnecter ou fermer la session. Il suffit de
taper exit, ou logout ou taper simultanément les touches CTRL et D. Ne fermer jamais un système UNIX de
------------------------------------------- 2 ---------------------------------------

manière brutale comme sous Windows !!! Le système UNIX est plus stable que Windows. Il n’y a donc
aucune raison de l’arrêter brusquement.

3 La commande man

La commande man est une commande fondamentale lors de la phase d’apprentissage d’un système UNIX.
C’est une commande qui permet de fournir de l’aide en ligne (affichage de manuel d’utilisation sur l’écran).
Elle est très importante pour apprendre à utiliser les commandes UNIX de manière correcte et efficace.
Associée à une autre commande UNIX, elle affiche le manuel d’utilisation relatif à cette commande. Par
exemple, en tapant :

$ man passwd

le système va vous afficher le manuel d’utilisation de la commande passwd. Un manuel est composé de
pages écran qui sont affichées sur écran avec arrêt de défilement pour vous donner la possibilité de lire le
document page par page. Pour passer à la page suivante, vous taper la touche espace et pour quitter le manuel
et revenir au promptn, vous devez taper la touhe q.

4 Le système de fichiers
4.1 Les types de fichiers

Il existe plusieurs types de fichiers sous UNIX. Parmi les plus importants que vous utiliserez le plus souvent,
on trouve les fichiers ordinaires et les fichiers répertoire, catalogue ou dossier (en anglais directory ou
folder).

Un fichier ordinaire contient des données, ce fichier peut être lisible, c'est à dire contenir des informations
compréhensibles écrites en clair, ce fichier peut être aussi totalement illisible, comme pour le cas des fichiers
exécutables (fichiers binaires). Concrètement un fichier texte qui comme son nom l'indique contient du texte
est lisible, alors qu'un exécutable ne l'est pas, si vous cherchez à l'éditer vous ne verrez rien de
compréhensible, dans ce dernier cas, on dit aussi qu'on a affaire à un fichier binaire.

Un répertoire peut être considéré comme un classeur ou un dossier, dans lequel on met des fichiers, c'est un
élément d'organisation de l'espace du disque dur. Les fichiers ayant les mêmes “affinités” peuvent être rangés
sous un même répertoire. De même on peut trouver des sous répertoires dans un répertoire, qui eux mêmes
contiennent des fichiers et d'autres sous répertoires. Ce système hiérarchique fait penser à un arbre, d'où le
terme d'arborescence de fichiers.

/usr/bin
/usr
/usr/local
/ /bin
/users/I3 /users/IF3/IF3A/ali/prog.c
/users
/users/IF3/IF3A
/users/IF3
/users/IF3/IF3B

Il existe un “ancêtre” à tous les répertoires, c'est la racine ou le / (slash) sur le shéma. Tout répertoire, qui

------------------------------------------- 3 ---------------------------------------

n'est pas la racine elle même, possède un répertoire qui le contient (appelé répertoire père) et peut posséder
des sous-répertoires (répertoires fils) et des fichiers .

Quand on crée un répertoire, le système crée automatiquement deux “fichiers” sous le répertoire, le premier
est symbolisé par un point “.”, qui représente le répertoire lui-même, le deuxième est symbolisé par deux
points “..” qui représente le répertoire père.

4.2 Atteindre un fichier

Nommer un fichier
Tout fichier, qu'elle que soit son type, doit pouvoir être identifié. C’est pourquoi on leur donne un nom. Ce
nom comporte au maximum 255 caractères, sachant qu'il existe une distinction entre les lettres minuscules et
majuscules, et que certains caractères sont interdits, comme par exemple le /, les parenthèses (), l'espace ou le
symbole *.

Le chemin d'accès
Chaque fichier est rangé dans un répertoire du système de fichiers. On doit donc pouvoir y accéder (c'est-à-
dire l’atteindre), en suivant un chemin bien précis dans l'arborescence.

Pour indiquer le chemin du fichier (prog.c dans notre exemple), on part de la racine (/), on indique le premier
répertoire traversé, puis les autres, en séparant chacun des répertoires d'un /. Ainsi donc pour notre fichier le
chemin d'accès est :

/users/IF3/IF3A/ali/prog.c

En indiquant /users/IF3/IF3A/ali/prog.c, le fichier est parfaitement identifié sans aucune ambiguité.

A noter qu'on peut avoir des fichiers portant le même nom dans le système de fichiers dés lors qu'ils n'ont pas
le même chemin, et donc qu'ils ne se trouvent pas au même endroit.

On dit que le chemin du fichier est absolu parce qu'à la vue de son chemin d'accès, en partant de la racine,
on sait exactement où se trouve le fichier.

Un chemin est dit relatif, quand il n'est pas nécessaire, d'indiquer le chemin complet. A partir de l’endroit où
l’on se trouve dans l'arborescence (répertoire courant) il suffit de rajouter le chemin par rapport à ce
répertoire. Rappelons que le répertoire courant est symbolisé par un point “.”

En admettant qu'on se trouve sous /users/IF3/, si l'on veut accéder au fichier prog.c, le chemin relatif au
répertoire courant est ./IF3A/ali.

5 Les commandes usuelles
5.1 Déplacements

La commande pour se déplacer dans l'arborescence est cd. Si l'on est au niveau de la racine, pour aller à
notre répertoire /users/IF3/IF3A/ali on doit taper :

$ cd /users/IF3/IF3A/ali

On a tapé un chemin absolu. On se trouve maintenant sous /users/IF3/IF3A/ali qui devient le nouvezu
répertoire courant. En fait, un raccourci permet de se retrouver rapidement dans son répertoire personnel en
------------------------------------------- 4 ---------------------------------------

tapant simplement cd. Si l'on veut aller maintenant sous /users/IF3/IF3A, on doit taper :

$ cd ..

En effet .. représente le répertoire père, /users/IF3/IF3A étant le répertoire père de /users/IF3/IF3A/ali. Si on
veut connaître dans quel répertoire on trouve actuellement, on utilise la commande pwd, qui affiche sur
écran, le chemin absolu du répertoire courant.

5.2 Lister les fichiers

La commande ls permet de visualiser le contenu de répertoires.

La commande ls peut être utilisée avec des options. La plus importantes est l’option -l, qui donnent
l’ensemble des attributs sur un fichier. Par exemple :

-rw-r--r-- 1 ali users 76 May 12 10:45 prog.c

La signification des champs de la ligne ci-dessus est la suivante:
-rw-r--r-- type de fichier et ses caractéristiques de protection (voir chapitre 5)
1 le nombre de lien
ali le nom du propriétaire
users le groupe d'utilisateurs auquel appartient le propriétaire
76 la taille du fichier (en octets)
May 12 le jour de dernière modification
10:45 l'heure de dernière modification
prog.c le nom du fichier
Pour avoir ces informations sur un fichier, vous vous devez taper :

$ ls -l nom-du-fichier

Si vous tapez ls –la, vous verez de plus apparaître les deux fichiers “.” et “..” vus précédement. L’option “-
a” permet de lister les fichiers commençant par un point qu’on appelle les fichiers cachés (ils ne sont pas
affichés automatiquement sur l’écran).

Les métacaractères

Les métacaractères permettent de faire une sélection de fichiers suivant certains critères. Le métacaractère le
plus fréquemment utilisé est le symbole *. Il remplace une chaîne de longueur non définie. Avec le critère *,
vous sélectionnez tous les fichiers. Par exemple le critère a*, permet de sélectionnez tous les fichiers
commençant par a.

$ ls a*

Va lister que les fichiers commençant par a. De même *a opère une sélection des noms de fichiers se
terminant par a. Le critère *a* va faire une sélection sur les noms de fichiers qui ont le caractère a dans leur
nom, quelque soit sa place.

Le métacaractère ? remplace un caractère unique. Avec le critère a??, vous sélectionnez les fichiers dont le
nom commence par a, mais qui contiennent au total trois caractères, exactement.

Les métacaractères [ ] représente une série de caractères. Le critère [aA]* permet la sélection des fichiers
------------------------------------------- 5 ---------------------------------------

dont le nom commence par un a ou A (minuscule ou majuscule). Le critère [a-d]* fait la sélection des
fichiers dont le nom commence par a jusqu'à d. Le critère *[de] fait la sélection des fichiers dont le nom se
termine par d ou e.

Vous voyez donc que les caractères [],* et ? sont des caractères spéciaux, qu'on ne peut utiliser comme des
simples caractères, parce qu'ils sont interprétés par le shell, comme des métacaractères.

5.3 Commandes de gestion des répertoires

Pour gérer les répertoires, vous disposez des commandes suivantes :
mkdir nom-de-répertoire Création d'un répertoire
rmdir nom-de-répertoire Suppression d'un répertoire vide
mv répertoire répertoire-d'accueil déplacement d'un répertoire
mv répertoire nouveau-nom Changement de nom d'un répertoire

5.4 Commandes de gestion des fichiers

Pour gérer les fichiers vous disposez des commandes suivantes:
touch mon-fichier Création de fichier vide
more mon-fichier Visualisation page à page d'un fichier
rm mon-fichier Suppression d'un fichier
mv mon-fichier répertoire d'accueil Déplacement d'un fichier
mv mon-fichier nouveau-nom Changement de nom d'un fichier
cp nom-fichier répertoire-d'accueil/autre-nom Copie de fichier

file mon-fichier Savoir si on a affaire à une fichier binaire (exécutable)
ou un fichier texte. On obtient pour un fichier texte,
comme sortie mon-fichier : ascii text

5.5 Commandes diverses

man nomcommande Donne l'aide sur la commande nomcommande
man -k mot-clé Donne toutes les commandes qui contiennent le mot
clé dans leur aide
clear Efface l'écran
date Affiche la date et l'heure
du -k Donne la taille disque utilisée pas le répertoire
courant
gzip -9 nomfich Compresse un fichier
gzip -d nomfichi.gz Décompresse un fichier
tar cvf nomarchive nomfich1 nomfichi2 … Archive les fichiers nomfich 1 à n dans l'archive
nomfichn nomarchive

------------------------------------------- 6 ---------------------------------------

tar tvf nomarchive Liste les fichiers contenus dans l'archive
tar xvf nomarchive Extrait les fichiers de l'archive
tar uvf nomarchive nomfich1 nomfich2 … Ajoute les fichiers nomfich1, nomfich2 … à l'archie
nomarchive
who Indique toutes les personnes connectées
whoami Donne l'identité de l'utilisateur
grep -i chaine nomfichier Recherche la chaine chaine dans le fichier fichier
sans regarder la casse
ftp nommachine Transfert de fichiers

6 Les droits d'accès
6.1 Identification de l'utilisateur

Tout utilisateur, en plus de l’obligation d’avoir un compte, appartient à un groupe d’utilisateurs (dans le cas
d’une université, on peut avoir le groupe des enseignants, le groupe d’étudiants de IF3, de MI4, le groupe
administration, etc.)

Ainsi, chaque utilisateur est identifié par un numéro unique UID (User identification), de même chaque
groupe est identifié par un numéro unique GID (Group identification).

Vous pouvez voir votre UID et GID en éditant le fichier /etc/passwd (voir, respectivement , les champs de
rangs 3 et 4 qui se trouvent après le nom (le login), et le mot de passe crypté).

6.2 Définition des droits d'utilisateur

Cas d'un fichier ordinaire
Avec UNIX les fichiers bénéficient d'une protection en lecture, écriture et exécution. Ceci veut dire que l’on
peut choisir si nous voulons que nos fichiers soient lisibles et/ou modifiables par d'autres. Nous pouvons
également empêcher que d'autres utilisateurs lancent nos exécutables. C'est le principe des droits d'accès ou
des permissions.

En tapant la commande ls –l, le premier champ correspond au droit d'accès. Ainsi, nous pouvons avoir :

-rw-r--r-- 1 ali users 76 May 12 10:45 prog.c
Ce premier champ est lui même divisé en quatre groupes :
1. une lettre, qui peut prendre les valeurs : – (fichier ordinaire) ou d (fichier répertoire) ou d’autres
valeurs que vous décrouvirez par la suite.
2. les trois autres composés chacun de trois caractères. Le premier groupe de trois lettres définit les
droits d’accès du propriétaire du fichier, le deuxième définit les droits du groupe et le troisième
définit les droits des autres (différents du propriétaire et du groupe).

La signification des lettres rwx et la suivante :
r (read) on peut lire le fichier
w (write) on peut modifier le fichier
x (exécutable) on peut exécuter le fichier (c'est donc un exécutable)
- aucun droit autorisé
Le champ -rw-r--r-- regroupe les droits du propriétaire du fichier, du groupe auquel appartient le
propriétaire et les autres utilisateurs.

------------------------------------------- 7 ---------------------------------------

Par exemple pour notre fichier le propriétaire ali a des droits en écriture et lecture, le groupe a un droit en
lecture, mais aucun droit en écriture et en exécution, les autres utilisateurs ont uniquement le droit en lecture
du fichier.

Cas d'un répertoire
Pour un répertoire le x n'est pas un droit en exécution, mais un droit d'accès au répertoire. Sans ce droit, on
ne peut pas accéder au répertoire et voir ce qu'il y a dedans.

En tapant ls -l sur un répertoire, on peut obtenir la ligne suivante :

drwxr-x--- 1 ali users 13242 Dec 2 13 :14 mon-répertoire

d signifie qu'on a affaire à un répertoire ; rwx sont les droits du propriétaire ali qui est autorisé en lecture,
écriture et droit d'accès au répertoire ; r-x représentent les droits du groupe users : autorisé en lecture, droit
d'accès au répertoire, pas de droit en écriture ; --- représentent les droits des autres utilisateurs : aucun droit
actuellement.

6.3 Commandes associées

Changer les droits : chmod

La commande chmod permet de modifier les droits d'accès d'un fichier (ou répertoire). Pour pouvoir
l'utiliser sur un fichier ou un répertoire, il faut en être le propriétaire. On utilise chmod soit à l’aide des lettres
décrites précédement (r,w et x), soit à l’aide de chiffres. Dans le premier cas, on accéde au champ
propriétaire avec u (comme user), au champ groupe avec g (comme group) et au champ étranger avec o
(comme other). Il suffit de mettre un “+” ou un “-“ suivant que l’on désire rajouter un droit ou l’enlever
(voir exemples ci-dessous). Une dernière possibilité est a (comme all), ce qui permet de donner les droits à
tout le monde simultanément. L’utilisation des chiffres avec chmod est plus simple. On dispose d’un tableau
de correspondance fixant les poids de chaque type d’opération :

r 4

w 2

------------------------------------------- 8 ---------------------------------------

x 1

Pour positionner une autorisation, on fait la somme des chiffres par groupement. Si vous avez un fichier avec
les droits suivants -rw-rw-rw-, pour les droits utilisateurs vous avez (r=)4+(w=)2=6, de même pour le groupe
et les autres. Donc -rw-rw-rw- est équivalent à 666. En suivant la même règle rwxrw-r-- est équivalent à 754.

Pour mettre un fichier avec les droits-r--r--r-- vous devez taper :

$ chmod 444 nom-fichier

On appelle ce système de notation, la notation octale ou numérique.

On peut également utiliser une notation symbolique comme suit : donner un droit en écriture pour le groupe
du fichier nom-fichier

$ chmod g+w nom-fichier

Comme autre exemple, on peut vouloir supprimer le droit d'accès du répertoire rep1 aux autres utilisateurs
(autres que propriétaire et utilisateurs du groupe)

$ chmod o-x rep1

En tapant

$ chmod u+x,g-w nom-fichier

on réalise plusieurs changements de droits en même temps : rajouter le droit en exécution pour le
propriétaire et enlevez le droit en écriture pour le groupe du fichier.

Changer les droits par défaut : umask

Quand vous créer un fichier, par exemple avec la commande touch, ce fichier par défaut possède certains
droits. Ce sont 666 pour un fichier (-rw-rw-rw-) et 777 pour un répertoire (-rwxrwxrwx). Ils représentent les
les droits maximum (tous les droits). Vous pouvez faire en sorte de changer ces paramètres par défaut. La
commande umask est définie pour changer ces paramètres.

Pour un fichier :

Si vous tapez umask 022, vous partez des droits maximum 666 et vous retranchez 022, on obtient donc 644,
par défaut les fichiers auront comme droit 644 (-rw-r-r--).

par défaut les fichiers auront comme droit 422 (-rw--w--w-).

Pour un répertoire :

par défaut les fichiers auront comme droit 644 (-rwxr-xr-x).

------------------------------------------- 9 ---------------------------------------

par défaut les fichiers auront comme droit 422 (-rwx-wx-wx).

umask n'est utilisatable que si on est propriétaire du fichier.

7 Commandes UNIX et redirection
7.1 Syntaxe d'une commande

La syntaxe standard d'une commande UNIX est la suivante :

commande -options arg1 arg2 arg3

Les options varient en fonction de la commande, le nombre des arguments qui suivent dépend aussi de la
commande, par exemple la commande :

$ sort -r mon-fichier

sort (trier) permet de trier un fichier, l'option r (reverse), permet de trier en sens inverse le fichier. L'argument
unique de la commande est le nom du fichier. Avec

$ cp -R mon-repertoire nouveau-repertoire

La commande cp (copy) copie un répertoire (option R) vers un autre répertoire. Ici nous avons deux
arguments.

On peut coupler deux options comme par exemple : ps –ef ; avec cette commande on a l'option e et f.

7.2 Les entrées sorties

Il y a trois sortes d'entrées sorties ou flux de données : le premier est l'entrée standard, c'est à dire ce que vous
saisissez au clavier, le deuxième est la sortie standard, c'est à dire l'écran, plus précisément le shell, et le
troisième est la sortie standard des messages d'erreurs consécutifs à une commande, qui est généralement
l'écran.

Chacun de ces flux de données est identifié par un numéro descripteur : 0 pour l'entrée standard, 1 pour la
sortie standard et 2 pour la sortie standard des messages d'erreur.

7.3 Redirection des entrées sorties

Quand vous lancez une commande dans un shell, il peut y avoir du texte qui s'affiche suite à l'exécution de la
commande. Ce texte par défaut, s'affiche sur l’écran. On dit que l’écran est la sortie standard.

On peut changer ce comportement, en tapant :

ma-commande > mon-fichier

Tous les commentaires, les sorties, de la commande, ne vont pas apparaître sur l’écran mais seront écrits et
donc redirigés dans un fichier. En d'autres termes, la sortie standard est redirigée vers un fichier.

La redirection > a pour effet de créer le fichier mon-fichier. Si ce fichier existait déjà, il est tout simplement
écrasé (supprimé et recréé). Si on ne veut pas l’écraser et donc garder son ancien contenu, on utilise une
redirection avec les symboles >>. En tapant :
------------------------------------------- ---------------------------------------
10

ma-commande >> mon-fichier

Le fichier mon-fichier n'est pas écrasé, mais la sortie standard (les commentaires de la commande) sont
ajoutés en fin de fichier, à la suite du texte qui était déjà dans le fichier.

Les redirections marchent dans les deux sens, par exemple en tapant la commande suivante :

sort < mon-fichier

Vous envoyez le contenu du fichier mon-fichier vers la commande sort (trie). Celle-ci va donc trier le
contenu du fichier et afficher le résultat sur l’écran.

On peut également combiner les deux redirections (entrée et sortie). Avec :

sort < mon-fichier > fichier-trie

On a vu que sort < mon-fichier avait pour effet de trier le fichier mon-fichier, l'expression >fichier-trie a pour
effet d'envoyer le résultat (le fichier trié) dans un fichier fichier-trie. Le résultat n'apparaît plus à l'écran, mais
est sauvegardé dans un fichier.

7.4 Les pipes

Un pipe (en français tube de communication) permet de rediriger la sortie d'une commande vers une autre.
En d'autres termes, pour rediriger les résultats (la sortie) d'une commande, on peut taper :

commande1 > sortie1

On peut rediriger cette sortie vers une autre commande. Cette sortie devient donc une entrée pour cette
dernière commande.

Pour cela, on taperait la ligne de commande suivante :

commande2 < sortie1

Il existe un autre moyen de faire le même travail en utilisant la notion de pipe ou de tube.

Par exemple, en écrivant la ligne de commande suivante :

commande1 | commande2 (| étant le symbole de pipe)

on obtient un comportement totalement équivalent aux deux lignes de commandes précédentes.

Voici un exemple plus significatif

La commande ls permet la visualisation de fichiers. On peut obtenir alors le résultat suivant (ceci n’est qu’un
exemple) :

fichier1 fichier2 monfichier

La commande grep permet la recherche d'une chaîne de caractère dans une liste donnée. En tapant par
exemple :

grep mon * (* signifie tous les fichiers)

------------------------------------------- ---------------------------------------
11

la commande grep recherche la chaîne de caractère mon dans les noms de tous les fichiers. Ainsi, on aura
comme résultat :

monfichier

Ce même même résultat peut être obtenu en utilsant le symbole du pipe (|). Ainsi, en tapant :

$ ls | grep mon

on aura le comportement suivant : la première commande aura pour effet de lister le nom des fichiers se
trouvant à l'endroit où l'on a tapé la commande (répertoire courant). L& sortie standard (le résultat de la
commande) est donc une liste de noms. Cette liste, au lieu d’être affichée sur l’écran, est redirigée vers la
commande grep, qui va y chercher une chaîne de caractère contenant mon. Le résultat est donc :

monfichier

8 Gestion des processus
8.1 Caractéristiques d'un processus

Chaque exécution d’une commande génère d’un point de vue interne, ce que l’on appelle un processus. Ces
processus sont identifiés par le système par un numéro appelé PID (Process Identification). Chaque
processus dans le système dispose d’un PID unique.

Un processus peut lui même créer un autre processus. Il devient donc un processus parent ou père, et le
nouveau processus, un processus enfant. Ce dernier est identifié par son PID, et le processus père par son
numéro de processus appelé PPID (Parent Process Identification). On obtient ainsi une arborescence de
processus comme on dispose d’une arborescence de fichiers.

Tous les processus sont ainsi identifiés par leur PID, mais aussi par le PPID du processus qui la créé, car tous
les processus ont été créés par un autre processus. La racine de tous ces processus est définie par le premier
processus lancé sur le système : c’est le processus d’ouverture d’une session. Ce processus est appelé init. Il
n’a pas de père et son PID est égal à la valeur 1.

8.2 Afficher les attributs des processus

On peut visualiser les processus qui tournent sur une machine, à un instant donné, avec la commande : ps
(options), les options les plus intéressantes sont -e (affichage de tous les processus) et -f (affichage détaillée).

Pour voir les process d'un seul utilisateur, on utilise l’option –u suivie du nom de l’utilisateur :

$ ps -u ali

8.3 Commandes de gestion des processus

Parmi toutes le commandes de gestion des processus, il en existe une qui est très importante qui peut rendre
beaucoup de services dans certains cas (processus qui boucle indéfiniment). Cette commande est appelée
kill et sert à arrêter ou tuer un processus. Si on veut arrêter un processus, il faut d’abord connaître son PID.
Pour cela on utilisera la commande ps . Une fois que l’on connaît le PID d’un processus, nous pouvons taper
la commande :

$ kill -9 PID
------------------------------------------- ---------------------------------------
12

Un utilisateur ne peut arrêter que les processus qui lui appartiennent (qu'il a lancé). Seul l'administrateur
système a le droit d'arrêter un processus ne lui appartenant pas.

8.4 Lancer en processus en tâche de fond
Pour lancer une commande quelconque, on tape son nom sur la ligne de commande après le prompt (par
exemple $). Tant que la commande n'est pas terminée, on n’a pas la main au niveau du shell, et donc on ne
peut pas taper une autre commande. Si cette commande demande beaucoup de temps pour s’exécuter, on se
trouve en train d’atteindre sa fin, avant de faire autre chose. Pour éviter cela, on dispose d’un autre moyen
pour lancer une commande. On parle alors d’exécution en background. Ceci veut dire que l’on peut lancer
une commande, récupérer la main sans que cette soit terminée pour lancer une autre commande. Pour cela,
on rajoute le symbole & à la fin de commande. Celle-ci se lancera en " tâche de fond " ou en background, ce
qui permet de revenir directement au prompt du shell.

En tapant la commande :
$ ps ef &
[321]
$
le shell nousdonne immédiatement la main, et affiche le numéro du PID du processus lancé et qui correspond
à la commande que nous avons tapé.

L'éditeur vi (ATTENTION : écrire vi en minuscules !!!)
L'éditeur vi permet à l'utilisateur de créer de nouveaux fichiers ou d'éditer des fichiers existants. La
commande pour lancer l'éditeur est vi, suivie par le nom de fichier. Par exemple, pour éditer le fichier
nommé temporaire, vous devez tapez vi temporaire et ensuite retour. Vous pouvez lancer vi sans nom de
fichier, mais quand vous voudrez sauvez votre travail, vous devrez indiquer plus tard à vi sous quel nom il
devra le sauver.

Quand vous lancez vi pour la première fois, vous voyez un écran rempli de tildes (un tilde ressemble à ceci :
~) sur le côté gauche de l'écran. Les lignes vides au-delà de la fin du fichier sont montrées de cette manière.
En bas de votre écran, si vous avez spécifié un nom de fichier existant, le nom et la taille de ce fichier sont
affichés, comme ceci :
"nom_de_fichier" 21 lines, 385 characters

Si le fichier que vous avez spécifié n'existe pas, il vous est indiqué qu'il s'agit d'un nouveau fichier, comme
ceci :

"newfile" [New file]

Si vous lancez vi sans nom de fichier, la dernière ligne de l'écran restera vide. Si l'affichage ne correspond à
------------------------------------------- ---------------------------------------
13

ces indications, votre terminal est sans doute mal réglé. Tapez :q et "retour" pour sortir de vi et régler le
problème.
1. Sortir de vi
Maintenant que vous savez entrer dans vi, ce serait une bonne idée de savoir en sortir. L'éditeur vi a deux
modes (commande et insertion). Pour sortir de vi, vous devez être en mode commande. Appuyer sur la
touche appelée "Escape" ou "Esc" (Si votre terminal n'a pas une telle touche, essayez ^[, ou contrôle -[) pour
passer en mode commande. Si vous êtes déjà en mode commande quand vous tapez "Escape", cela peut
"biper" (signal sonore), ne vous inquiétez pas, vous êtes encore dans le mode commande.
La commande pour quitter vi est :q. Une fois en mode commande, tapez deux points, et 'q', suivi de retour.
Si votre fichier a été modifié d'une façon ou d'une autre, l'éditeur vous préviendra, et ne vous laissera pas
quitter. Pour éviter ce message, la commande est :q!. Cela vous laisse quitter vi sans sauvegarder les
changements.

Bien sûr, normalement dans un éditeur, vous devriez vouloir sauvegarder les changements que vous avez
faits. La commande pour enregistrer le contenu de l'éditeur est :w. Vous pouvez combiner cette commande
avec la commande pour quitter, soit :wq. Vous pouvez spécifier un nom de fichier différent pour sauver sous
ce nom après le :w. Par exemple, si vous voulez sauvegarder le fichier sur lequel vous travaillez sous le nom
nom_de_fichier_2, vous devez taper :w nom_de_fichier_2 et retour.

Une autre façon de sauver vos changements et quitter vi est la commande ZZ. Quand vous êtes en mode
commande, taper ZZ est équivalent à :wq. Si des changements ont été faits dans le fichier, ils seront sauvés.
C'est la façon la plus simple de quitter l'éditeur, avec seulement deux appuis de touches. La commande x est
aussi équivalente à :wq.

2. Les deux modes de vi
La première chose que beaucoup d'utilisateurs apprennent à propos de l'éditeur vi est qu'il a deux modes:
commande et insertion. Le mode commande permet l'entrée de commandes pour manipuler du texte. Ces
commandes sont en général longues d'un ou deux caractères, et peuvent être entrées en peu de frappe de
touche. Le mode insertion insère tout ce qui est tapé sur le clavier dans le fichier courant.

vi démarre en mode commande. Plusieurs commandes mettent l'éditeur vi en mode insertion. Les
commandes les plus couramment utilisées sont a et i. Ces deux commandes sont décrites plus bas. Une fois
en mode insertion, vous en sortez en tapant la touche escape. Si votre terminal n'a pas de touche escape, ^[
devrait convenir (contrôle-[). Taper escape pendant que vous êtes déjà en mode commande ne fait pas
sortir l'éditeur du mode commande. Un bip peut vous indiquer que vous êtes déjà dans ce mode.
3. Comment taper des commandes en mode commande
Les commandes du mode commande sont généralement au format suivant : (Les arguments optionnels sont
donnés entre crochet.
[quantité] commande [lieu]

La plupart des commandes font un caractère de long, en particulier celles qui utilisent le caractère de
contrôle. Les commandes décrites dans cette section sont celles que l'on utilise le plus avec l'éditeur vi.
La quantité est définie par n'importe quel caractère de 1 à 9. Par exemple, la commande x efface un
caractère sous le curseur. Si vous tapez 23x en mode commande, cela va effacer 23 caractères.

Certaines commandes utilisent un paramètre optionnel lieu, où vous pouvez spécifier le nombre de lignes ou
la partie du document concernée par la commande. Le paramètre lieu peut aussi être n'importe quelle
commande qui déplace le curseur.
------------------------------------------- ---------------------------------------
14

4. Quelques commandes vi simples
Ceci est un simple groupe de commande pour permettre à un utilisateur débutant avec vi de commencer.
D'autres commandes utiles, seront présentées ultérieurement.
a
fait entrer en mode insertion, les caractères tapés ensuite seront insérés après le curseur. Si
vous spécifiez un nombre, tout le texte qui a été inséré sera répété ce nombre de fois
h
déplace le curseur sur le caractère précédent.
i
entre en mode insertion, Le caractère tapé ensuite sera inséré avant la position actuelle du
curseur. Si vous spécifiez un nombre, tout le texte qui a été inséré sera répété ce nombre de
fois
j
déplace le curseur d'une ligne vers le bas.
k
déplace le curseur d'une ligne vers le haut.
l
déplace le curseur d'un caractère vers la droite.
r
remplace le caractère sous le curseur. Un nombre spécifie le nombre de caractères à
remplacer.
u
annule le dernier changement dans le fichier. Taper de nouveau u rétablit le changement.
x
efface le caractère sous le curseur. Nombre spécifie combien de caractères il faut effacer.
Les caractères seront effacés après le curseur.

5. Les "buffers" texte de vi
L'éditeur vi a 36 "buffers" pour conserver des morceaux de texte, ainsi qu'un "buffer" principal. Chaque fois,
qu'un bout de texte est effacé ou copié depuis le fichier, il est placé dans le "buffer" principal. Beaucoup
d'utilisateurs de vi utilisent rarement les autres buffers, et se débrouillent sans eux. Le bloc de texte peut
aussi être placé dans un autre buffer demandé en utilisant la commande ". Après avoir tapé ", une lettre ou un
chiffre identifiant le buffer doit être entré. Par exemple, la commande : "mdd remplit le buffer m et efface la
ligne courante. De même, du texte peut être collé avec les commandes p ou P. "mp colle le contenu du buffer
m après la position actuelle du curseur. Pour toutes les commandes utilisées dans les deux sections suivantes,
ces buffers peuvent être spécifiés pour un stockage temporaire de mots ou de paragraphes.

6. Couper et Copier
La commande la plus couramment utilisée pour couper est d. Cette commande efface du texte dans le fichier.
La commande est précédée par un nombre optionnel et suivie par une indication de déplacement. Si vous
doublez la commande en tapant dd, la ligne courante est effacée. Voici quelques combinaisons :
d^
efface de la position actuelle du curseur jusqu'au début de la ligne.
d$
efface de la position actuelle du curseur jusqu'à la fin de la ligne.
------------------------------------------- ---------------------------------------
15

dw
efface de la position actuelle du curseur jusqu'à la fin du mot
3dd
efface 3 lignes à partir de la position actuelle du curseur vers le bas.
La commande y (commande de copie) opère comme la commande d en prenant du texte du fichier sans
effacer le texte.

7. Coller
Les commandes pour coller sont p et P. Elles diffèrent seulement par la position où elles collent le texte par
rapport au curseur. p colle le contenu du buffer spécifié ou du buffer général après le curseur, tandis que P le
colle avant le curseur. nombre avant la commande, colle le texte le nombre de fois demandé.

8. Recherche de mots ou de caractères
L'éditeur vi peut faire deux types de recherche : chaînes de caractères ou caractères. Pour une recherche de
chaîne, les commandes / et ? sont utilisées. Quand vous lancez ces commandes, la commande que vous
venez de taper sera affichée sur la ligne du bas, où vous taperez la chaîne que vous cherchez. Ces deux
commandes diffèrent uniquement par la direction dans laquelle la recherche est entreprise. La commande /
cherche vers la fin du fichier, tandis que la commande ? cherche vers le début du fichier (de bas en haut).
Les commandes n et N répètent la précédente recherche respectivement dans le même sens et dans le sens
opposé. Certains caractères ont une signification particulière pour vi, et doivent donc être précédés d'un
antislash () pour faire partie de l'expression recherchée.

Caractères spéciaux :
^
Début de ligne. (Au début de l'expression recherchée.)
.
Correspond à un caractère simple.
*
Correspond à zéro ou plusieurs fois le caractère précédent.
$
Fin de ligne (A la fin de l'expression recherchée.)
[
Correspond au début d'un groupe d'expressions correspondantes ou non. Par exemple /f[iae]t
correspond à chacun de ces mots : fit fat fet. Dans ce cas, il correspond uniquement à ceux-
là. /a[^bcd] ne correspond à aucun d'eux mais à tout ce qui contient "a" et une lettre autre
que "b","c","d".
<
Peut être inséré dans une expression précédée d'un antislash pour rechercher le début ou la
fin d'un mot. Par exemple /<le> va chercher seulement le mot "le" mais pas les mots
comme "leur" ou "fleur".
>
Voir la description du caractère '<' au dessus.
La recherche de caractères cherche une ligne à l'intérieur de laquelle se trouve le caractère entré après la
commande. Les commandes f et F cherchent un caractère uniquement sur la ligne courante. f cherche vers
l'avant et F cherche vers l'arrière et le curseur se déplace sur la position du caractère trouvé.

Les commandes t et T cherchent un caractère seulement sur la ligne courante, mais avec t, le curseur se
déplace sur la position avant le caractère, et T cherche depuis la fin de la ligne vers la position après le
caractère .
------------------------------------------- ---------------------------------------
16

Ces deux commandes peuvent être répétées en utilisant les commandes ; ou , (; répète la dernière
recherche de caractère dans la même direction, alors que , la répète en sens inverse.)

Si l'option "ic" (ou ignorecase) est activée (tapez :set ic) la recherche est insensible à la casse.

9. Personnalisation de vi (et EX)
Vous pouvez personnaliser la façon dont vi se comporte. Les options d'édition sont activées en utilisant la
commande :set, les options des éditeurs vi et EX disponibles sur Wiliki sont les suivantes : (Vous pouvez
obtenir cette liste en tapant :set all puis retour en mode commande)
noautoindent magic noshowmatch
autoprint mesg noshowmode
noautowrite nomodelines noslowopen
nobeautify nonumber tabstop=8
directory=/tmp nonovice taglength=0
nodoubleescape nooptimize tags=tags /usr/lib/tags
noedcompatible paragraphs=IPLPPPQPP LIpplpipnpbp term=xterm
noerrorbells prompt noterse
noexrc noreadonly timeout
flash redraw timeoutlen=500
hardtabs=8 remap ttytype=xterm
noignorecase report=5 warn
keyboardedit scroll=11 window=23
keyboardedit! sections=NHSHH HUuhsh+c wrapscan
nolisp shell=/bin/csh wrapmargin=0
nolist shiftwidth=8 nowriteany
Certaines de ces options ont des valeurs définies par le signe égal '=' , tandis que d'autres sont activées ou
non. (Ces options de type "oui ou non" sont appelées Booléennes, et sont préfixées par "no" pour indiquer
qu'elles ne sont pas sélectionnées.) Les options montrées ici sont les options qui sont définies sans
personalisation. La description de certaines est donnée plus bas, avec une abréviation. Par exemple la
commande set autoindent, vous pouvez taper :set autoindent ou :set ai. Pour la désélectionner, vous
pouvez taper :set noautoindent ou :set noai.
autoindent (ai)
Cette option règle l'éditeur pour que les lignes suivantes soient indentées comme la ligne
précédente. Si vous voulez retirer cette indentation, vous pouvez taper ^D comme premier
caractère. Ce ^D fonctionne en mode insertion, et pas en mode commande. De plus la
longueur de l'indentation peut être réglée par shiftwidth, expliqué plus bas.
exrc
Le fichier .exrc dans le répertoire courant est lu pendant le démarrage. Ceci doit être défini
soit dans la variable d'environnement EXINIT soit dans le fichier .exrc dans votre répertoire
home.
mesg
Désactive les messages si cette option est désélectionnée avec :set nomesg, ainsi rien ne
peut vous déranger pendant que vous utilisez l'éditeur.
number (nu)
Affiche les lignes avec leur numéro sur le coté gauche.
shiftwidth (sw)
Cette option prend une valeur, et détermine la largeur de la tabulation logicielle. (La
tabulation logicielle est utilisée pour les commandes << et >>.) Par exemple, vous pouvez
régler un décalage d'une largeur de 4 avec cette commande : :set sw=4.
showmode (smd)
Cette option est utilisée pour afficher le mode dans lequel vous êtes actuellement. Si vous
------------------------------------------- ---------------------------------------
17

êtes en mode insertion, la ligne du bas va indiquer INPUT MODE.
warn
Cette option vous prévient si vous avez modifié le fichier mais ne l'avez pas encore
sauvegardé.
window (wi)
Cette option définit le nombre de lignes de la fenêtre utilisé par vi. Par exemple, pour régler
l'éditeur vi de façon à ce qu'il utilise seulement 12 lignes de votre écran (parce que votre
modem est lent) vous pouvez utiliser : :set wi=12.
wrapscan (ws)
Cette option affecte la conduite de la recherche de mots. Quand wrapscan est sélectionné, si
le mot n'est pas trouvé vers le bas du texte, la recherche reprendra au début.
wrapmargin (wm)
Si cette option a une valeur plus grande que zéro, l'éditeur va automatiquement faire passer
le mot à la ligne suivante. C'est à dire que si vous avez plus que ce nombre d'espace par
rapport à la marge de gauche, le mot va aller à la ligne, sans que vous ayiez à taper retour.
Par exemple, pour régler la marge droite à deux caractères, vous pouvez taper : :set wm=2.

10. Abréviations et traductions de touches
Une commande de l'editeur EX qui est utile sur l'éditeur vi est la commande abbreviate. Elle vous permet
de définir des abréviations pour des chaînes de caractères spécifiques. La commande ressemble à ceci : :ab
chaînes chaîne à substituer. Si vous avez à taper le nom,"Humuhumunukunukuapua`a" mais
que vous n'ayez pas envie de taper le nom complet, vous pouvez utiliser une abréviation. Pour cet exemple,
la commande à entrer est :
:ab 9u Humuhumunukunukuapua`a

Maintenant quel que soit l'endroit où vous tapez 9u comme un mot séparé, vi va taper le ou les mots entiers
indiqués. Si vous tapez 9université, il ne va pas substituer le mot.

Pour retirer une abréviation définie précédemment, la commande est anabbreviate. Pour retirer l'exemple
précédent, la commande serait ":unab 9u". Pour obtenir la liste de vos abréviations, tapez :ab.

Une autre commande de l'éditeur EX utile pour la personnalisation est la commande de traduction de touche
(mappage). Il y a deux types de commandes de traduction. Une pour le mode commande et une pour le mode
insertion. Ces deux commandes sont respectivement :map et :map!. Le "mappage" fonctionne de façon
similaire à abréviation, vous lui donnez une séquence de touches et une autre à mettre à la place.(La
séquence de touches de remplacement est généralement constituée de commandes vi.)

11. La variable d'environnement EXINIT et le fichier .exrc
Il y a deux façons de personnaliser l'éditeur vi. Si vous créez un fichier nommé .exrc dans votre répertoire
home , toutes les commandes qu'il contient seront executées quand vi démarrera. L'autre méthode est de
definir une variable d'environnement nommé EXINIT. L'option sera sélectionnée dans le fichier de
configuration de votre shell. Si vous utilisez /bin/csh (C-Shell), la commande est la suivante, et mise dans le
fichier: .cshrc
setenv EXINIT '...'
Si vous utilisez /bin/sh ou /bin/ksh, la commande est la suivante, et mise dans le fichier .profile :
export EXINIT
EXINIT='...'
Nécrivez pas ... comme dans l'exemple. Dans cet espace mettez la commande que vous voulez définir. Par

------------------------------------------- ---------------------------------------
18

exemple, si vous voulez avoir l'auto-indentation, la numérotation des lignes, et la marge droite (passage à la
ligne - wrap margin) à 3 caractères, alors la commande setenv (pour C shell) serait :
setenv EXINIT 'set ai nu wm=3'
Si vous voulez mettre plus d'une commande dans la variable EXINIT, séparez les commandes avec une
barre verticale (|). Par exemple, pour "mapper" la commande 'g' au caractère 'G' en mode commande, la
commande est :map g G et combiné avec la commande précédente, vous aurez :
setenv EXINIT 'set ai nu wm=3|map g G'
Si vous voulez créer le fichier nommé .exrc, vous pouvez y mettre ce qui est entre guillemets après le
EXINIT.

12. Récupérer votre travail quand quelque chose va mal avec votre terminal
L'editeur vi édite une copie temporaire de votre fichier, et quand la session est terminée ou quand vous lui
demandez de sauver, il place le contenu du fichier temporaire dans le fichier original. Si quelque chose se
passe mal pendant que vous éditez votre fichier, l'éditeur vi va essayer de sauver quand même le travail en
cours et de le stocker pour une récupération ultérieure. Note : Si vi meurt (vi est un processus) pendant que
vous travaillez sur un fichier, il vous envoie un courrier sur la façon de récupérer ce travail. L'option -r est là
pour la récupération. Si vous éditez le fichier infovitale, et si vous êtes déconnecté, alors l'option -r de
l'éditeur vi devrait vous aider. La commande doit ressembler à quelque chose comme :

vi -r infovitale.

Après avoir utilisé l'option -r vous DEVEZ tout de même sauvegarder ce que vous avez récupéré dans le
fichier initial. L'option -r ne fonctionne qu'une fois par session vi défaillante.

13. Résumé des commandes vi
Cette liste est un résumé des commande vi, classées par fonction. Il peut y avoir d'autres commandes
disponibles, que vous pourriez trouver dans le manuel de vi.

Couper et coller/effacer du texte
"
Spécifie le buffer à utiliser avec les commandes se servant d'un buffer. Faites suivre le " par
la lettre ou le nombre, qui correspond au buffer.
D
Efface (Delete) de la position actuelle du curseur à la fin de la ligne.
P
Colle (Paste) le buffer indiqué avant la position actuelle du curseur. Si aucun buffer n'est
indiqué (avec la commande ") alors 'P' utilise le buffer général.
X
Efface le caractère avant le curseur.
Y
Copie (Yank) la ligne courante dans le buffer indiqué. Si aucun buffer n'est indiqué, le
buffer général est utilisé.
d
Efface (Delete) jusqu'à lieu. "dd" efface la ligne courante. Un nombre efface ce nombre de
lignes. Tout ce qui est effacé est placé dans le buffer spécifié avec la commande ". Si aucun
buffer n'est spécifié, le buffer général est utilisé.
------------------------------------------- ---------------------------------------
19

p
Colle (Paste) le buffer spécifié après la position actuelle du curseur ou la ligne. Si aucun
buffer n'est spécifié (avec la commande ") 'p' utilise le buffer général.
x
Efface le caractère sous le curseur. Un nombre indique combien de caractères doivent être
effacés. Les caractères seront effacés après le curseur.
y
Copie (Yank) jusqu'à lieu, en mettant le résultat dans un buffer. "yy" copie la ligne courante.
Un nombre copie ce nombre de lignes. Le buffer peut être spécifié avec la commande ".Si
aucun buffer n'est spécifié, le buffer général est utilisé.
Insérer du texte
A
Joint (Append) à la fin de la ligne courante.
I
Insère à partir du début de la ligne.
O
(la lettre)Entre en mode insertion sur une nouvelle ligne au-dessus de la position courante
du curseur.
a
Entre en mode insertion, les caractères tapés seront ajoutés après la position courante du
curseur. Un nombre insère tout le texte ce nombre de fois.
i
Entre en mode insertion, les caractères tapés seront insérés avant la position courante du
curseur. Un nombre insère tout le texte ce nombre de fois.

o
Entre en mode insertion sur une nouvelle ligne en dessous de la position courante du
curseur.
Déplacer le curseur dans le fichier
^B
Monte d'une page. Un nombre fait monter de ce nombre de pages.
^D
Descend d'une demi fenêtre. Un nombre fait descendre de ce nombre de lignes.
^F
Descend d'une page. Un nombre fait descendre de ce nombre de pages.
^H
Déplace le curseur d'un espace vers la gauche. Un nombre fait déplacer de ce nombre
d'espaces.
^J
Descend le curseur d'une ligne dans le même colonne. Un nombre fait descendre de ce
nombre de lignes.
^M
Déplace vers le premier caractère de la ligne suivante.
^N
Descend le curseur d'une ligne dans le même colonne. Un nombre fait descendre de ce
nombre de lignes.
^P
Monte le curseur d'une ligne dans le même colonne. Un nombre fait monter de ce nombre de
------------------------------------------- ---------------------------------------
20

lignes.
^U
Monte d'une demi fenêtre. Un nombre fait monter de ce nombre de lignes.
$
Déplace le curseur à la fin de la ligne courante. Un nombre le fait se déplacer à la fin des
lignes suivantes.
%
Déplace le curseur sur la parenthèse ou accolade correspondante.
^
Déplace le curseur sur le premier caractère non-blanc.
(
Déplace le curseur au début de la phrase.
)
Déplace le curseur au début de la phrase suivante.
{
Déplace le curseur au paragraphe précédent.
}
Déplace le curseur au paragraphe suivant.
|
Déplace le curseur à la colonne indiquée par le nombre.
+
Déplace le curseur sur le prochain caractère non-blanc de la ligne suivante.
-
Déplace le curseur sur le prochain caractère non-blanc de la ligne courante.

0
(Zéro) Déplace le curseur sur la première lettre de la ligne courante.
B
Déplace le curseur d'un mot en arrière, en sautant la ponctuation.
E
Avance à la fin du mot, en sautant la ponctuation.
G
Aller (Go) à la ligne indiqué par le nombre. Si aucun nombre n'est donné, il va à la fin du
fichier.
H
Déplace le curseur sur le premier caractère non-blanc en haut de l'écran.
L
Déplace le curseur sur le premier caractère non-blanc en bas de l'écran.
M
Déplace le curseur sur le premier caractère non-blanc au milieu de l'écran.
W
Avance au début d'un mot,en sautant la ponctuation.
b
Recule le curseur d'un mot. Si le curseur est au milieu d'un mot, place le curseur sur le
premier caractère du mot.
e
Avance le curseur d'un mot. Si le curseur est au milieu d'un mot, place le curseur sur le
dernier caractère du mot.
h
------------------------------------------- ---------------------------------------
21

Déplace le curseur sur le caractère de gauche.
j
Descend le curseur d'une ligne.
k
Monte le curseur d'une ligne.
l
Déplace le curseur sur le caractère de droite.
w
Déplace le curseur sur le mot suivant. Si le curseur est au milieu d'un mot, place le curseur
sur le premier caractère du mot suivant.
Déplacer le curseur dans l'écran
^E
Déplace l'écran d'une ligne vers le haut. Un nombre fait monter de ce nombre de lignes.
^Y
Déplace l'écran d'une ligne vers le bas. Un nombre fait descendre de ce nombre de lignes.
z
Redessine l'écran avec les options suivantes. "z" place la ligne courante en haut de l'écran;
"z." place la ligne courante au centre de l'écran; et "z-" place la ligne courante en bas de
l'écran. Si vous spécifiez un nombre avant la commande 'z', il agit sur la ligne spécifiée. Par
exemple, "14z." place la ligne 14 au centre de l'écran.
Remplacer du texte
C
Change de la position du curseur jusqu'à la fin de la ligne.
R
Remplace les caractères de l'écran par les caractères entrés, s'arrête en tapant la touche
Escape.
S
Change une ligne entière.
c
Change jusqu'à <where>. "cc" change la ligne courante. Un nombre fait changer ce nombre
de lignes.
r
Remplace un caractère sous le curseur. Indiquer un nombre fait remplacer ce nombre de
caractères.
s
Substitue un caractère sous le curseur et passe en mode insertion. Spécifier un nombre pour
substituer ce nombre de caractères. Un signe dollar($) sera ajouté au dernier caractère
substitué.
Rechercher du texte ou des caractères
,
Répète la dernière commande f, F, t ou T dans la direction opposée.
/
Recherche vers le bas dans le fichier la chaîne spécifiée après le /.
;
Répète la dernière commande f, F, t ou T.
?
Recherche vers le haut dans le fichier la chaîne spécifiée.
------------------------------------------- ---------------------------------------
22

F
Recherche vers l'avant dans la ligne courante le caractère spécifié après la commande 'F'. S'il
l'a trouvé, déplace le curseur sur sa position.
N
Répète la dernière recherche faite par '/' ou '?', mais dans la direction opposée.
T
Recherche vers l'arrière dans la ligne courante le caractère spécifié après la commande 'T', et
se place sur la colonne suivante s'il l'a trouvé.
f
Recherche dans la ligne courante le caractère spécifié après la commande 'f'. S'il l'a trouvé,
déplace le curseur sur sa position.
n
Répète la dernière recherche faite par '/' ou '?'.

t
Cherche dans la ligne courante le caractère spécifié après la commande 't' et se place sur la
colonne précédent le caractère ,s'il l'a trouvé.
Manipulation des caractères/Formatage de ligne
~
Inverse la casse du caractère sous le curseur.
<
Décale jusqu'à lieu d'une tabulation vers la gauche. "<<" décale la ligne courante et peut être
répété avec un nombre.
>
Décale jusqu'à lieu d'une tabulation vers la droite. ">>" décale la ligne courante et peut être
répété avec un nombre.
J
Joint la ligne courante à la suivante. Un nombre fait joindre ce nombre de lignes.

Sauvegarder et quitter
^
Sort du mode "VI" et passe en mode "EX". L'éditeur EX est l'éditeur en ligne de commande
sur lequel VI est construit. La commande EX pour retourner dans VI est ":vi".
Q
Sort du mode "VI" et passe en mode "EX". L'éditeur EX est l'éditeur en ligne de commande
sur lequel VI est construit. La commande EX pour retourner dans VI est ":vi".
ZZ ou x
Quitte l'éditeur, en sauvant tout les changements effectués.
Divers
^G
Affiche le nom du fichier courant et son statut.
^L
Vide et redessine l'écran.
^R
Redessine l'écran en retirant les mauvaises lignes.
^[

------------------------------------------- ---------------------------------------
23

Touche d'échappement. Annule les commandes partiellement tapées.
^^
Retourne au dernier fichier édité.
!
Exécute un shell. Si un lieu est spécifié, le programme qui est exécuté avec ! utilise les
ligne(s) spécifiée(s) comme entrée standard, et va les remplacer par la sortie standard du
programme exécuté. "!!" exécute un programme utilisant la ligne courante comme entrée.
Par exemple "!4jsort" va prendre 5 lignes à partir de la position courante du curseur et
exécuter sort. Après avoir tapé la commande, il y aura un point d'exclamation où vous
pourrez taper la commande.
&
Répète la précédente commande ":s".
.
Répète la dernière commande qui a modifié le fichier.
:
Commence une commande de l'éditeur EX. La commande est exécutée une fois que
l'utilisateur a tapé retour. (voir section ci-dessous.)
@
Tape la commande stockée dans le buffer spécifié.
U
Restaure la ligne courante dans l'état où elle se trouvait avant que le curseur aille à la ligne.
m
Marque la position courante du curseur avec le caractère spécifié après la commande 'm'.

u
Annule (Undo) le dernier changement dans le fichier. Retaper 'u' va refaire le
changement.(NDT : avec Vim,'u' annule le changement précédent et '.' le rétablit.).
Les commandes EX
L'éditeur vi est basé sur un autre éditeur, nommé EX. L'éditeur EX édite seulement par ligne. Depuis l'éditeur
vi, vous utilisez la commande : pour entrer une commande EX. La liste donnée ici n'est pas complète, mais
les commandes proposées sont les plus utilisées. Si plus d'une ligne doit être modifiée par certaines
commandes (comme ":s" et ":w"), un intervalle doit être spécifié avant la commande. Par exemple, pour
substituer de la ligne 3 à la ligne 15, la commande est ":3,15s/from/this/g".
:ab chaîne chaînes
Abréviation. Si un mot correspondant à chaîne est tapé dans vi, l'éditeur insère
automatiquement les mots correspondants. Par exemple, abréviation ":ab TN Tunisia" va
insérer le mot, "Tunisia" partout où le mot "TN" est tapé.
:map touches new_seq
Mapping. Ceci vous permet de remplacer une touche ou une séquence de touches par une
autre touche ou séquence de touches.
:q
Quitte vi. Si des changements ont été faits, l'éditeur va afficher un message d'avertissement.
:q!
Quitte vi sans sauvegarder les changements.
:s/pattern/to_pattern/options
Substitution. Ceci substitue le modèle spécifié par la chaîne dans to_pattern. Sans option, il
substitue seulement la première occurrence du modèle. Si un 'g' est spécifié, toutes les
occurrences seront substituées. Par exemple, la commande ":1,$s/Dwayne/Dwight/g"
------------------------------------------- ---------------------------------------
24

remplace toutes les occurrences de "Dwayne" par "Dwight".
:set [all]
Définit les options de VI et EX. La commande ":set all" affiche les options possibles. (Voir
la section sur la personnalisation de VI pour quelques options.)
:una string
Retire l'abréviation définie précédemment par ":ab".
:unm keys
Retire le mapping défini par ":map".
:vi
Commence l'édition d'un nouveau fichier. Si les changements n'ont pas étés sauvegardés,
l'éditeur vous le signale.
:w
Sauvegarde (Write out) le fichier courant.
:w nom_de_fichier
Ecrit (Write) le buffer dans le fichier spécifié.
:w >> filename
Ajoute le contenu du buffer au fichier.
:wq
Enregistre le buffer et quitte.

Commandes Unix par ordre alphabétique
Nom Description Options Paramètres
alias Renomme ou définit une variable=commande
commande
awk, gawk extraction d'informations d'un -F : '...' : redéfinition du nom de fichier
fichier séparateur de champ
'commande' : traitement à
faire sur les chaînes
extraites
cal affiche le calendrier de l'année mois année
spécifiée en paramètre
cat imprime le contenu du fichier nom de fichier
mentionné
cd se positionne sur le répertoire chemin d'accès à un
désigné répertoire
chmod change les permissions en -R change les droits mode - nom de fichier
lecture, écriture, exécution récursivement à partir du ou de répertoire
noeud
(mode = ugo)
compress compresse un fichier (voir gzip) -c : résultat sans fichier
------------------------------------------- ---------------------------------------
25

modification 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 source - destination
destination confirmation
-p : conservation de date
et droits
-r : recopie récursive
d'un répertoire
date retourne la date courante
diff compare deux fichiers et affiche -c : affiche 3 lignes avant fichier1 fichier2
les différences et 3 lignes après
echo envoi en écho des paramètres -n : supprime le retour
spécifiés à la suite ($PATH, chariot en fin de
"bye") commande
elm courier électronique -s : chaîne de caractères destinataire
qui 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
68020)
find recherche récursive d'un fichier à -name fichier : fichier à
"répertoire"
partir du répertoire chercher
-print : affiche le chemin
trouvé
grep affiche les lignes du fichier -v : seulement les lignes chaîne de caractères -
contenant la chaîne de caractères ne contenant pas la fichier
chaîne
-i : majuscules et
minuscules identiques
-n : avec numéros de
lignes
-c : nombre de
comparaisons positives
gunzip décompresse un fichier -c : le résultat est produit nom de fichier
sans modification du
fichier d'origine
gzip compresse un fichier (voir -c : résultat sans nom de fichier
compress) modification du fichier

------------------------------------------- ---------------------------------------
26

par défaut, la destination est la source
sortie standard qu'on redirige -f : écrasement d'un
vers un fichier si on veut obtenir fichier compressé
un fichier compressé préexistant
-d : force une
décompression
-9 : niveau maximum de
compression
head liste les n premières lignes du -n : nombre de lignes source > destination
fichier affichées (par défaut 10)
id retourne le nom de login, l'UID,
le groupe et le GID
kill envoi d'un signal à un processus -l : liste des signaux numéro du process
disponibles
-n : numéro du signal à
envoyer
2 : INT (ctrl-c : )
3 : QUIT (ctrl-)
9 : KILL
ln création d'une nouvelle référence -s : création d'un lien source - destination
pour un fichier préexistant symbolique
logname retourne le nom de login de
l'utilisateur
ls liste le contenu d'un répertoire -a : prise en compte des nom de répertoire
fichiers cachés
-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 courier électronique -s : chaîne de caractères destinataire - <fichier
qui sera le sujet du
message
-f : nom de la boîte à

------------------------------------------- ---------------------------------------
27

lettres
-v : trace du mail jusqu'à
sa délivrance
man retourne le mode d'emploi de la nom de commande
commande s'il existe
mkdir création d'un répertoire nom de répertoire
more liste le contenu d'un fichier page nom de fichier
par page
mv déplace fichiers et répertoires -i : demande source - destination
confirmation
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
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 nom de machine
-l : nom de login
machine distante (sortie :exit)
rm supprime la référence du fichier -f : force la commande nom de fichier ou de
dans le répertoire sans s'occuper des droits répertoire
-i : demande
confirmation
-r : destruction récursive
rmdir suppression d'un répertoire vide nom de répertoire
sleep ne fait rien pendant n secondes temps en secondes
sort tri des lignes du fichier suivant -r : tri inverse fichier
l'ordre ASCII -u : élimine les
lignesidentiques

------------------------------------------- ---------------------------------------
28

tail liste les n dernières lignes du -n : nombre de lignes nom de fichier
fichier affichées (par défaut 10)
talk, ytalk permet de converser avec une
destination
machine distante
tar archivage/désarchivage de c : création de l'archive archive -répertoire ou
fichiers x : restauration de fichiers
l'archive
t : listage du contenu de
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 une nom de machine
machine distante(sortie : exit)
touch modifie les caractéristiques d'un -a : dernier accès fichier
fichier (option -a : m par défaut) seulement
crée un fichier vide s'il n'existe -m : dernière
pas déjà modification seulement
tty donne le nom du terminal
unalias supprime un alias variable
uname donne le nom du système -a : informations
d'exploitation complètes
-n : nom de la machine
-r : release du système
d'exploitation
-s : nom du système
d'exploitation
uniq recopie de source dans source destination
-u : seules les lignes
destination après suppression des
uniques sont recopiées
lignes identiques
uudecode restitue un fichier binaire à partir fichier
du fichier éditable (ASCII) créé
avec uuencode
uuencode encode un fichier binaire en fichier - indication
fichier éditable (ASCII) >fichier encodé
w aperçu de l'activité de la machine -h : supprime l'entête nom d'utilisateur
-s : affichage restreint
whereis retourne le chemin complet nom de la commande
d'accès à tous les répertoires
contenant la commande
which retourne le chemin complet nom de la commande

------------------------------------------- ---------------------------------------
29

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

Exemples de commandes
Exemple Description
alias dir=ls -l
Il suffira de taper "dir" pour consulter la liste des fichiers avec
leurs droits
unalias dir Supprime l'alias de nom "dir"
cal 09 1996 Affiche le calendrier du mois de Septembre 1996
cat exemple.c Liste le contenu du fichier de nom "exemple.c"
cd programmes Se déplace dans le répertoire de nom "programmes"

chmod 744 exemple.c
Donne tous les droits au propriétaire du fichier, et une simple
lecture au groupe et à l'univers

compress -f exemple.c
Compresse le fichier de nom "exemple.c", en écrasant un
fichier préexistant s'il existe
uncompress exemple.c Décompresse le fichie r"exemple.c"
cp exemple.c toto.c Crée le fichier de nom "toto.c" identique au fichier
"exemple.c"
date Affiche la date courante

diff -c fichier1 fichier2
Compare "fichier1" et "fichier2" en affichant 3 lignes
avant et 3 lignes après chaque différence
echo $PATH Affiche le contenu de la variable "PATH"
elm martin@inf Envoie un message à martin
mail martin <exemple.c Envoie le fichier "exemple.c" à martin
file exemple.c Retourne quel est le type du fichier "exemple.c"
find "." -name exemple.c - Recherche récursivement et affiche le chemin menant au fichier
print "exemple.c" à partir du répertoire courant

grep -n -i "void" exemple.c
Affiche, avec leurs numéros, les lignes du fichier "exemple.c"
qui contiennent la chaîne "void"
Compresse le fichier "exemple.c" en conservant le fichier
gzip -c exemple.c >
exemple.c.gz d'origine.
Le fichier compressé est "exemple.c.gz".
Décompresse le fichier "exemple.c.gz" sans perdre le fichier
gunzip -c > exemple.c
exemple.c.gz compressé.
Le résultat se trouve dans le fichier "exemple.c"
head exemple.c Affiche les 10 premières lignes du fichier "exemple.c"
tail -5 exemple.c Affiche les 5 dernières lignes du fichier "exemple.c"
id Retourne le login, l'UID, le groupe et le GID courants
kill -9 8756 tue le processus de numéro 8756

------------------------------------------- ---------------------------------------
30

ln -s exemple.c toto.c crée un lien symbolique sur le fichier "exemple.c", de nom
"toto.c"
logname Retourne le nom de login de l'utilisateur

ls -l programmes
Donne le contenu du répertoire "programmes" en donnant des
informations sur les fichiers (taille, dates, ...)
man chmod Affiche le manuel d'utilisation de la commande "chmod"
mkdir sources Crée le répertoire "sources"
more exemple.c Affiche, page par page, le contenu du fichier "exemple.c"
mv exemple.c TP1.c Renomme le fichier "exemple.c" sous le nom "TP1.c"
ps -aux Sous système V, donne la liste de tous les processus actifs
pwd Retourne la référence absolue du répertoire courant
rlogin -l martin champagne
Établit une connexion sur la machine champagne, sous le login
de martin
telnet champagne Établit une connexion sur la machine champagne
rm exemple.c Supprime le fichier "exemple.c"
rmdir sources Supprime le répertoire "sources"
sleep 10 Attend 10 secondes

sort -r TP1.c
Affiche le fichier "TP1.c", les lignes étant triées en ordre
inverse
talk champagne@cal.enst.fr Lance une conversation sur la machine
"champagne@cal.enst.fr"

tar cf sources.tar sources
Crée une archive, de nom "sources.tar", du contenu du
répertoire "sources"
Extrait le contenu d'une archive, de nom "sources.tar", dans
tar xvf sources.tar sources
le répertoire"sources". L'écran affiche les noms des fichiers au
fur et à mesure de leur désarchivage.
L'archive est conservée.
touch exemple.c
Modifie la date de dernier accès au fichier "exemple.c" à la
date courante
tty Donne le nom du terminal
uname
Affiche, dans l'ordre, le nom du système d'exploitation, le nom
et la release du système de la machine

uniq exemple.c uniques.c
Recopie le fichier "exemple.c" dans "uniques.c" en
supprimant les lignes identiques
uudecode fichier
uuencode fichier -
indication >fichier encodé

w martin
Donne une idée de l'utilisation de la machine faite par
l'utilisateur msrtin
whereis gcc
Retourne le chemin complet d'accès à tous les répertoires
contenant la commande gcc

------------------------------------------- ---------------------------------------
31

which gcc Retourne le chemin complet d'accès à la commande gcc
who (am i)
Retourne le nom des utilisateurs qui ont ouvert une session sur
cette machine
LA PROGRAMMATION SHELL SOUS UNIX

1. Notions sur la programmation Shell

Un shell, quel qu'il soit, peut exécuter des commandes contenues dans un fichier texte (fichier
ordinaire). Un fichier contenant des commandes pour le shell est appelé un script. C'est en fait un
programme écrit dans le langage du shell. Ce langage comprend non seulement les commandes que
nous avons déjà vues (commandes Unix), mais aussi des structures de contrôle (instructions
conditionnelles, boucles et d’autres instructions spécifiques).
Pour la programmation du shell, nous allons utiliser le shell sh, qui est le plus répandu et standard

2. Créer un script

Un script shell est un fichier en mode texte. C'est-à-dire que ce n'est pas un fichier binaire,
exécutable directement par la machine, mais il doit être interprété.

3. L'interprétation d'un script
L'interprétation signifie que chaque commande contenue dans un script doit être lue par un
programme, appelé interpréteur ; l'interpréteur analyse chaque commande du script et l’exécute.

4. L'édition d'un script
Un script étant un fichier en mode texte, il doit être créé avec un éditeur de texte, comme par
exemple vi.

5. Rendre un script exécutable
Pour que le shell sache comment l'interpréter, un script shell doit commencer par la ligne:
# !/bin/sh
Il doit aussi être exécutable (droit x). Le #!/bin/sh sur la première ligne indique que ce script doit
être exécuté par le shell sh dont on indique le chemin d'accès. Pour rendre un fichier exécutable,
tapez :
chmod u+x nom-fichier-script

6. Spécifier le chemin d'une commande
Pour que le shell comprenne où chercher votre commande, il faut donc spécifier l'emplacement de
la commande en donnant son chemin, qu'il soit absolu :
/home/student/nom-fichier-script
ou relatif :
./nom-fichier-script

------------------------------------------- ---------------------------------------
32

ou encore sous la forme :
sh nom-fichier-script

7. Principes généraux des scripts shell
Un script shell est avant tout une succession de commandes, comme celles que nous écrivons
dans une fenêtre de type Terminal ; sauf que ces commandes nous les rassemblons dans un fichier
pour les exécuter dans l’ordre où elles sont écrites dans le script.

8. Commentaires
Presque tous les langages informatiques autorisent d'insérer des commentaires ; le shell n'échappe
pas à la règle. Pour cela, il suffit de faire précéder chaque ligne de commentaire du caractère « # ».
Exemple :

#!/bin/sh

# Tout ce que j'écris ici ne sera pas lu.

echo "Ce que je tape ici sera lu."

9. Un script qui parle : la commande echo
Maintenant que vous savez comment on peut exécuter un script, il s'agit de le remplir...
Commençons par ce qu'il y a de plus simple : afficher du texte, comme par exemple « Ceci est un
exemple de fichier script ! »
Ecrivez ce fichier script et appelez le script1

#!/bin/sh

# Fichier "Exemple"

echo " exemple de fichier script !"
Exécutez ensuite ce script, en tapant :

$ ./script1

exemple de fichier script !
Autre exemple de fichier script (écrivez-le et exécutez-le).

#!/bin/sh

# Fichier "bonjour"

echo "Bonjour... "

------------------------------------------- ---------------------------------------
33

echo "Comment allez-vous ?"

10. Annuler le retour chariot
Si vous voulez annuler le retour chariot qui a lieu par défaut à la fin de toute commande echo, il
faut utiliser l'option -n. Le programme sera alors :

#!/bin/sh

echo -n "Bonjour..."

echo "Comment allez-vous ?"
Vous aurez comme résultat :

Bonjour... Comment allez-vous ?

11. Lecture de valeurs de variables à partir du clavier : commande read

La commande Unix read permet de lire des valeurs à partir du clavier. La commande read doit être
suivie d’un nom de variable, non précédé du signe dollar. Cette variable contiendra la valeur
introduite à partir du clavier

12. Lire plusieurs variables
La commande read permet également de lire plusieurs variables. Il suffit pour cela d'indiquer à la
suite les noms des différentes variables. Exemple :

#!/bin/sh

# Fichier "administration"

echo "Écrivez votre nom puis votre prénom :"

read nom prenom

echo "Nom : $nom"

echo "Prénom : $prenom"

Vous obtiendrez comme résultat :

Écrivez votre nom puis votre prénom :

Nom : Tounsi

------------------------------------------- ---------------------------------------
34

Prénom : Redha

13. Paramètres de position

Les paramètres de position sont des variables spéciales utilisées lors d'un passage de paramètres à
un script.

Variable Contenu

$0 Nom de la commande (du script)

$1-9 $1,$2,$3... Les neuf premiers paramètres passés au script

$# Nombre total de paramètres passés au script

$* Liste de tous les paramètres au format "$1 $2 $3 ..."

$@ Liste des paramètres sous forme d'éléments distincts "$1" "$2" "$3" ...

14. Sortie de script
La commande exit permet de mettre fin à un script. Par défaut la valeur retournée est 0 (pas
d'erreur)

15. Tests de conditions

La commande test permet d'effectuer des tests de conditions. Le résultat est récupérable par la
variable $? (code retour). Si ce résultat est 0 alors la condition est réalisée.

tests sur chaîne
• test -z "variable" : zero, retour OK si la variable est vide (ex test -z "$a")

• test -n "variable" : non zero, retour OK si la variable n'est pas vide (texte quelconque)

• test "variable" = chaîne : OK si les deux chaînes sont identiques

• test "variable" != chaîne : OK si les deux chaînes sont différentes

tests sur valeurs numériques
test valeur1 option valeur2

Option Rôle

-eq Equal : Egal

-ne Not Equal : Différent

------------------------------------------- ---------------------------------------
35

Résumé sur l’utilisation du système unix

Résumé sur l’utilisation du système unix

Recommandé

Recommandé

Contenu connexe

En vedette

En vedette (20)

Similaire à Résumé sur l’utilisation du système unix

Similaire à Résumé sur l’utilisation du système unix (20)

Plus de Mohamed Ferchichi

Plus de Mohamed Ferchichi (13)

Résumé sur l’utilisation du système unix