Les entités du système de fichier sont de deux types :

Le seul répertoire "sans père" du système de fichier est la racine du système de fichier (root en anglais) son nom est / Le nom long d'un fichier est le chemin (path) qui permet à partir de la racine d'arriver jusqu'à l'entité qui nous intéresse. Par exemple :

Un chemin relatif est un chemin ne partant pas de la racine mais de l'endroit ou se trouve celui qui pose la question. Par exemple :

Les fichiers sont eux-mêmes de différents types, mais quelque soit leur type ils s'utilisent de la même façon, c'est-à-dire comme un flux ou un tableau d'octets.

Les attributs principaux d'un processus sont :

La commande ps permet de lister les processus et kill permet de les tuer en leur envoyant un signal leur demandant de se terminer (on peut envoyer d'autres signaux).

Quand un processus en crée un autre (fils), le fils hérite de tous les attributs de son père. Sauf bien sûr le PID et la mémoire qui sera normalement une copie de celle de son père

init est le premier processus lancé par le système, c'est l'ancêtre de tous les processus, son PID est 1.

Quand un processus meurt, sa mémoire est libérée, les variables de l'environnement disparaissent, ses fichiers sont fermés et il retourne un valeur indiquant s'il s'est correctement exécuté à son père.

Les commandes suivantes nous permettront de faire les exemples suivants.

Voici ce que leur utilisation peut donner. Ce qui est en gras est ce que l'utilisateur a tapé.

$ pwd↵
/home/exco/Toto
$ echo ␣ un ␣ chat↵
un chat
$ echo ␣ un ␣  ␣  ␣  ␣ chat↵
un chat
$ echo ␣ 'un ␣  ␣  ␣  ␣ chat'↵
un    chat
$ echo ␣ 'un↵
> chat'↵
un
chat
$ ls↵
Makefile   ch01.html     ch02s02.html  index.html  unix.ps
Makefile~  ch01s02.html  ch02s03.html  pr01.html   unix.xml
TP         ch02.html     ch03.html     unix.html   unix.xml~
$ ls ␣ /↵
bin    cdrw  etc     lib         net     root  tmp     var
boot   dev   floppy  lost+found  proc    sbin  usbmem  vol
cdrom  dext  home    misc        projet  sys   usr
$ cat ␣ /etc/papersize↵
a4
$ cat ␣ /proc/version↵
Linux version 2.6.12 (root@lirispaj) (gcc version 3.3.5 (Debian 1:3.3.5-13)) #1 SMP Thu Jun 23 10:24:03 CEST 2005
$ cat ␣ /etc/papersize ␣ /proc/version↵
a4
Linux version 2.6.12 (root@lirispaj) (gcc version 3.3.5 (Debian 1:3.3.5-13)) #1 SMP Thu Jun 23 10:24:03 CEST 2005
$ passwd↵
Changing password for exco
(current) UNIX password: ↵ pour être certain que c'est vous
Enter new UNIX password: ↵; rien ne s'affiche, même pas des étoiles...
Retype new UNIX password: ↵ pour être certain de ne pas s'être trompé
passwd: password updated successfully

Certaines options sont les mêmes pour de nombreuses commandes. Voici les plus courantes :

Voyons quelques options de ls qui en possède de très nombreuses.

$ ls↵
Makefile  Makefile~  TP  unix.css  unix.css~  unix.html  unix.xml  unix.xsl
$ ls ␣ -l↵
total 101
-rw-r-----  1 exco liris   105 Aug 31 16:43 Makefile
-rw-r--r--  1 exco liris    86 Jul  5 23:02 Makefile~
drwxr-xr-x  5 exco liris  1000 Aug 31 15:53 TP
-rw-r--r--  1 exco liris   654 Sep  1 12:09 unix.css
-rw-r--r--  1 exco liris    65 Aug 31 16:44 unix.css~
-rw-r--r--  1 exco liris 41251 Sep  1 12:16 unix.html
-rw-r--r--  1 exco liris 36379 Sep  1 14:05 unix.xml
-rw-r--r--  1 exco liris   476 Aug 31 16:43 unix.xsl
$ ls ␣ -t↵
unix.xml  unix.html  unix.css  unix.css~  Makefile  unix.xsl  TP  Makefile~
$ ls ␣ -lt↵ ou -tl ou -t -l ou -l -t
total 101
-rw-r--r--  1 exco liris 36379 Sep  1 14:05 unix.xml
-rw-r--r--  1 exco liris 41251 Sep  1 12:16 unix.html
-rw-r--r--  1 exco liris   654 Sep  1 12:09 unix.css
-rw-r--r--  1 exco liris    65 Aug 31 16:44 unix.css~
-rw-r-----  1 exco liris   105 Aug 31 16:43 Makefile
-rw-r--r--  1 exco liris   476 Aug 31 16:43 unix.xsl
drwxr-xr-x  5 exco liris  1000 Aug 31 15:53 TP
-rw-r--r--  1 exco liris    86 Jul  5 23:02 Makefile~
$ ls ␣ -l ␣ /etc/passwd ␣ /bin/sh↵  
lrwxrwxrwx  1 root root    4 Jun 23 11:55 /bin/sh -> bash
-rw-r--r--  1 root root 1493 Jun 23 10:42 /etc/passwd

Dans le cas des liens symboliques, le fichier pointé est indiqué après le ->

Le contenu du manuel ne s'affiche pas complètement sur l'écran, il ne tiendrait pas. Il est donc affiché en utilisant la commande more. Cette commande affiche les textes page par page sur l'écran. Interactivement, l'utilisateur peut taper des commandes au clavier :

Le contenu d'une page de manuel contient presque toujours les mêmes sections dans le même ordre. Voici les plus importantes.

Pour trouver une commande par mot-clef, on peut utiliser l'option -k de la commande man. Cela permet de lister toutes les commandes qui ont le mot clef que vous recherchez dans leur description.

$ man ␣ -k ␣ remove↵
colrm (1)            - remove columns from a file
cut (1)              - remove sections from each line of files
lprm (1)             - remove jobs from the line printer spooling queue
modprobe (8)         - program to add and remove modules from the Linux Kernel
remove (3)           - delete a name and possibly the file it refers to
rm (1)               - remove files or directories
rmdir (1)            - remove empty directories
uniq (1)             - remove duplicate lines from a sorted file
XRemoveHost (3x)     - control host access and host control structure

Chaque page de manuel est stockée dans une section de la documentation UNIX. Voici une liste non exhaustive des sections :

Attention, un page de manuel peut porter le même nom dans plusieurs sections du manuel. Dans ce cas, on spécifie la section du manuel dans laquelle on veut la chercher. man ␣ 5 ␣ passwd permet d'avoir la documentation sur le format du fichier /etc/passwd.

Lorsque le shell trouve certains caractères spéciaux dans les arguments d'une commande il peut remplacer l'argument par un ou plusieurs noms de fichiers. Ces caractères spéciaux sont :

$ echo ␣ /etc/p*d↵
/etc/pam.d /etc/passwd
$ echo ␣ /*[!v]/p*d↵
/bin/pwd /etc/pam.d /etc/passwd
$ cd ␣ /↵
$ echo ␣ *↵
bin boot dev etc floppy home lib lost+found misc proc root sbin sys tmp usr var
$ echo ␣ "*" ␣ '*'↵
* *
$ echo ␣ *n↵
bin sbin

Dans beaucoup de logiciels sous UNIX la touche ⇥ (tabulation) demande au système de compléter la suite de la commande s'il n'y a pas ambiguïté. En cas d'ambiguïté, il y a un signal sonore et dans ce cas un deuxième appuis sur ⇥ provoque l'affichage de la liste des suites possibles.

	Avertissement
	Il faut impérativement utiliser la complétion afin de ne pas taper des noms de fichiers faux.

$ ca⇥<BEEP>⇥ Liste tous les programmes dont le nom commence par ca
cabextract          cancel              cardmgr
cal                 capitalize          case
calendar            captoinfo           cat
callgrind           card                catchsegv
callgrind_annotate  cardctl             catman
callgrind_control   cardinfo
$ cat⇥<BEEP>⇥ Liste tous les programmes dont le nom commence par cat
cat        catchsegv  catman
$ cat ␣ /etc/pas⇥swd↵ Pas de <BEEP> car il n'y a pas d'ambiguïté

Pour voir toute les variables actuellement définies il suffit d'utiliser la commande builtin set. De nombreuses variable ont été enlevée de l'exemple suivant.

$ set↵
DISPLAY=:0.0 Indique ou l'affichage graphique doit ce faire.
HOME=/home/exco Répertoire de connexion
LINES=24 Nombre de lignes du terminal texte
COLUMNS=80
PATH=/bin:/usr/bin:/usr/bin/X11:/usr/sbin:. Ou sont les programmes
PS1='$ ' prompt
PS2='> ' prompt indiquant que la commande n'est pas terminée
TZ=Europe/Paris Fuseau horaire
LC_ALL=POSIX Tous les affichages sont en ``anglais´´

Quand vous taper une commande vous pouvez indiquer qu'il faut utiliser le contenu d'une variable. On le fait en préfixant le nom de la variable par un '$'. C'est le shell qui fait la substitution, les programmes ne sont au courant de rien. Un nom de variable est composé de caractères alaphanumériques et du souligné.

$ echo ␣ $HOME ␣ '$HOME' ␣ "$HOME"↵
/home/exco $HOME /home/exco
$ ls ␣ -l ␣ $HOME/.profile↵
-rwxr-xr-x  1 exco liris 4242 May  9 13:08 /home/exco/.profile

La modification n'affecte que le processus en cours. Si la variable est exporté elle sera passée aux descendants du processus courant.

$ TOTO=678↵
$ echo ␣ $TOTO↵
678
$ TOTO='6 7 8'↵
$ echo ␣ $TOTO↵
6 7 8
$ date↵
Mon Sep  5 14:29:00 CEST 2005
$ LC_TIME=french↵
$ date↵
Mon Sep  5 14:29:00 CEST 2005 Toujours en anglais car la variable n'est pas été exportée
$ export ␣ LC_TIME↵
$ date↵
lun Sep  5 14:29:10 CEST 2005

La commande read prend une ligne de l'entrée standard et la stocke dans les noms de variables passées en paramètre.

$ read ␣ A↵
Je ␣ suis, ␣  ␣  ␣ ici
$ echo ␣ "$A"↵
Je suis,   ici
$ read ␣ A ␣ B↵
Je ␣ suis, ␣  ␣  ␣ ici
$ echo ␣ "($A)" ␣ "($B)"↵
(Je) (suis,   ici)
$ read ␣ A ␣ B ␣ C↵
Je ␣ suis, ␣  ␣  ␣ ici
$ echo ␣ "($A)" ␣ "($B)" ␣ "($C)"↵
(Je) (suis,) (ici)
$ read ␣ A ␣ </etc/papersize↵
$ echo ␣ "$A"↵
a4

$ cat ␣ /etc/papersize ␣ /bin/toto ␣ /proc/version↵
a4
cat: /bin/toto: No such file or directory
Linux version 2.6.12 (root@lirispaj) (gcc version 3.3.5 (Debian 1:3.3.5-13)) #1 SMP Thu Jun 23 10:24:03 CEST 2005
$ cat ␣ /etc/papersize ␣ /bin/toto ␣ /proc/version ␣ >LaConcatenation↵
cat: /bin/toto: No such file or directory
$ cat ␣ /etc/papersize ␣ /bin/toto ␣ /proc/version ␣ >LaConcatenation ␣ 2>&1↵
$ 

La commande grep est en fait un crible permettant de sélectionner des lignes dans les fichiers. Le critère de sélection est une chaine de caractère que l'on recherche dans chacune des lignes. Tous les exemples suivants recherchent les lignes contenant la chaine de caractère '4'.

$ grep ␣ 4 ␣ /etc/passwd↵
sync:x:4:65534:sync:/bin:/bin/sync
backup:x:34:34:backup:/var/backups:/bin/sh
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats/gnats-db:/bin/sh
nobody:x:65534:65534:nobody:/nonexistent:/bin/sh
identd:x:100:65534::/var/run/identd:/bin/false
sshd:x:104:65534::/var/run/sshd:/bin/false
$ grep ␣ 4 ␣ </etc/passwd↵
sync:x:4:65534:sync:/bin:/bin/sync
backup:x:34:34:backup:/var/backups:/bin/sh
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats/gnats-db:/bin/sh
nobody:x:65534:65534:nobody:/nonexistent:/bin/sh
identd:x:100:65534::/var/run/identd:/bin/false
sshd:x:104:65534::/var/run/sshd:/bin/false
$ grep ␣ 4 ␣ /etc/passwd ␣ /etc/papersize↵
/etc/passwd:sync:x:4:65534:sync:/bin:/bin/sync
/etc/passwd:backup:x:34:34:backup:/var/backups:/bin/sh
/etc/passwd:gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats/gnats-db:/bin/sh
/etc/passwd:nobody:x:65534:65534:nobody:/nonexistent:/bin/sh
/etc/passwd:identd:x:100:65534::/var/run/identd:/bin/false
/etc/passwd:sshd:x:104:65534::/var/run/sshd:/bin/false
/etc/papersize:a4
$ cat ␣ /etc/passwd ␣ /etc/papersize ␣ >xxx↵
$ grep ␣ 4 ␣ <xxx↵
sync:x:4:65534:sync:/bin:/bin/sync
backup:x:34:34:backup:/var/backups:/bin/sh
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats/gnats-db:/bin/sh
nobody:x:65534:65534:nobody:/nonexistent:/bin/sh
identd:x:100:65534::/var/run/identd:/bin/false
sshd:x:104:65534::/var/run/sshd:/bin/false
a4

Souvent une seule commande ne permet pas de faire ce que l'on veut. Dans ce cas, on peut appliquer une succession de transformations à un flot de données.

Le symbole pipe permet de faire un pipeline. La sortie standard de la commande de gauche est branchée sur l'entrée standard de la commande de droite. Les deux commandes sont exécutées en même temps. Le dernier exemple avec grep peut être écrit comme ceci :

$ cat ␣ /etc/passwd ␣ /etc/papersize ␣ | ␣ grep ␣ 4↵
sync:x:4:65534:sync:/bin:/bin/sync
backup:x:34:34:backup:/var/backups:/bin/sh
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats/gnats-db:/bin/sh
nobody:x:65534:65534:nobody:/nonexistent:/bin/sh
identd:x:100:65534::/var/run/identd:/bin/false
sshd:x:104:65534::/var/run/sshd:/bin/false
a4
$ set ␣ | ␣ more↵
Affichage paginé de la sortie de la commande set
$ set ␣ | ␣ grep ␣ X ␣ | ␣ sort↵
Affiche dans l'ordre alphabétiques les lignes affichées par set contenant un caractère X

Cette écriture à de nombreux avantages :

On peut faire des pipelines très long. L'exemple suivant cherche les lignes qui contiennent 'add', 'd' et 'x' dans tous les fichiers du répertoire /etc dont le nom commence par 'c'.

$ grep ␣ add ␣ /etc/c* ␣ | ␣ grep ␣ d ␣ | ␣ grep ␣ x↵
grep: /etc/chatscripts: Permission denied
/etc/complete.tcsh:                     proxy_rule redirect_address redirect_port \
/etc/complete.tcsh:                     prefix-addresses private-headers reloc section-headers \

Il est souvent utile de lancer une succession de commandes au clavier. Remonter dans l'historique des commandes tapées est fastidieux si l'on veut exécuter systématiquement plusieurs commandes. On peut séparer les différentes commandes par un ';'. Elles seront exécutée les unes après les autres.

$ echo ␣ a ␣ ; ␣ date ␣ ; ␣ echo ␣ b↵
a
Wed Sep  7 17:17:55 CEST 2005
b
$ echo ␣ a ␣ ; ␣ cat ␣ toto ␣ ; ␣ echo ␣ b↵
a
cat: toto: No such file or directory
b

Dans les exemples indiqués dans la suite on peut toujours remplacer les points virgules par des retours à la ligne.

Dans l'exemple précédent on voit que l'exécution continue même en cas d'erreur. Si l'on veut qu'elle s'arrête on utilise l'opérateur &&.

$ echo ␣ a ␣ && ␣ cat ␣ toto ␣ && ␣ echo ␣ b↵
a
cat: toto: No such file or directory

Parfois on veut mettre la sortie standard de plusieurs commandes dans un fichier. Plutôt que d'ouvrir plusieurs fois le fichier on peut regrouper les commandes en mettant des parenthèses et faire la redirection (ou le pipe) pour l'ensemble. Les trois ``suites´´ d'instructions suivantes font la même chose.

$ echo ␣ Contenu ␣ de ␣ toto ␣ >xxx ␣ ; ␣ cat ␣ toto ␣ >>xxx↵
$ (echo ␣ Contenu ␣ de ␣ toto ␣ ; ␣ cat ␣ toto) ␣ >xxx↵
$ (↵
> echo ␣ Contenu ␣ de ␣ toto↵
> cat ␣ toto↵
> ) ␣ >xxx↵

	Avertissement
	C'est un processus shell fils qui exécute ce qui est entre les parenthèses. Quand il se termine tout est perdu.

$ pwd↵
/etc
$ A=a↵
$ export ␣ B=b↵
$ export ␣ C=c↵
$ ( ␣ echo ␣ $A ␣ $B ␣ ; ␣ export ␣ C=cc ␣ ; ␣ cd ␣ / ␣ )↵
b
$ pwd↵
/etc
$ echo ␣ $C↵
c

Les redirections s'appliquent au shell fils, les commandes qu'il exécute ont les mêmes fichiers d'entrée sortie que leur père.

$ ( ␣ echo ␣ Il ␣ est ␣ ; ␣ date ␣ ) ␣ >xxx↵
$ cat ␣ xxx↵
Il est
Fri Sep 16 10:30:42 CEST 2005
$ X=$(date ␣ | ␣ ( ␣ read ␣ A ␣ B ␣ ; ␣ echo ␣ $A ␣ ) ␣ )↵
$ echo ␣ $X↵
Fri

Elle permet de faire prendre à une variable un ensemble de valeur parmi une liste donnée dans la ligne de commande. Pour chaque valeur, les commandes entre le do et le done sont exécutées.

$ for ␣ TOTO ␣ in ␣ toto ␣ tata ␣ tutu ␣ ; ␣ do ␣ echo ␣ "<$TOTO>" ␣ ; ␣ done↵
<toto>
<tata>
<tutu>
$ for ␣ TOTO ␣ in ␣ /b* ␣ "/b*" ␣ ; ␣ do ␣ echo ␣ "<$TOTO>" ␣ ; ␣ done↵
</bin>
</boot>
</b*>

On peut remplacer les points virgules par des retours à la ligne si l'on veut écrire la boucle sur plusieurs lignes.

for ␣ I ␣ in ␣ $(date)
 ␣  ␣ do
 ␣  ␣  ␣  ␣ echo ␣ "$I"
 ␣  ␣ done

Tant que la commande exécutée en paramètre du while se termine sans erreur (est vrai, et donc retourne 0 contrairement à tous les langages de programmation existant) les instructions entre le do et le done sont exécutées.

$ while ␣ read ␣ TOTO ␣ ; ␣ do ␣ echo ␣ "<$TOTO>" ␣ ; ␣ done ␣ </etc/aliases↵
<postmaster: root>
<abuse: postmaster>
$ I=0↵
$ while ␣ test ␣ $I ␣ != ␣ 3↵
> do ␣ echo ␣ "<$I>" ␣ ; ␣ I=$(expr ␣ $I ␣ + ␣ 1) ␣ ; ␣ done↵
<0>
<1>
<2>

Le case permet d'exécuter une suite différente de commandes en fonction du paramètre.

$ A=B
$ case ␣ "$A" ␣ in↵
>  ␣  ␣ v1|[A-Z]*) ␣ echo ␣ v1_ou_commence_par_une_majuscule ␣ ;;↵
>  ␣  ␣ *.gif) ␣ echo ␣ se_termine_par_gif ␣ ;;↵
>  ␣  ␣ *) ␣ echo ␣ n_importe_quoi ␣ ;;↵
> esac↵
v1_ou_commence_par_une_majuscule

Les tests sont faits du début à la fin. Si un test réussi, alors on ne regarde pas les suivants.

Le sélecteur qui est utilisé à la gauche de la parenthèse est le même que pour le globbing mais en plus il autorise le '|' pour faire les 'ou' logique.

Comme pour le while le test est fait par l'exécution d'un commande.

$ if ␣ cat ␣ toto ␣ ; ␣ then ␣ echo ␣ lisible ␣ ; ␣ else ␣ echo ␣ illisible ␣ ; ␣ fi↵

Les expressions régulières permettent d'identifier des morceaux de texte dans un texte afin de les afficher ou de les remplacer. Elles sont utilisées par de nombreuses commandes dont grep, vi, emacs, sed, awk mais aussi elles sont utilisables dans de nombreux langages de programmation (Perl, JavaScript, Python, C...). Quelques concepts généraux :

Le vocabulaire des expressions régulières.

Le expressions régulière étendues ont beaucoup plus de possibilités, les symboles les plus courants :

Exemples :

L'internationalisation (I18N) est ce qui permet aux logiciels de travailler dans n'importe quelle police de caractères existantes dans le monde (passé, présent et imaginaire). Chaque symbole possède un numéro dans la table Unicode standard. Ces numéros peuvent être codés de plusieurs façons, la plus courante est l'UTF8.

La localisation (L10N) défini la manière d'afficher certaines informations comme les nombre décimaux, les dates, les unités monétaires, ... Mais aussi les méthodes de changement de casse et de tri.

Adapter un logiciel à chaque culture est un problème énorme car le logiciel doit être testé dans toutes les langues. Les logiciels sont toujours plus stables et faciles à utiliser quand ils le sont dans la langue pour laquelle ils ont été développés initialement.

Les configurations des différents logiciels pour un utilisateur donné sont stockées dans le répertoire de connexion de l'utilisateur. Dans un fichier ou un répertoire dont le nom commence par '.'. Le format du contenu de ces fichiers est spécifique à chaque application.

Nom du/des répertoires à créer

Liste des informations sur les fichiers et répertoires.

Destruction de fichiers et répertoires. La commande rmdir ne permet que de détruire un répertoire vide.

Déplace des fichiers et répertoires. C'est un renommage plutôt qu'une copie. La sémantique est la même que pour la commande cp. Les options -i et -f ont le même sens que pour la commande rm.

L'option -R indique la récursion.

chmod ␣ 750 ␣ toto ␣ titi ␣ Met le mode rwxr-x--- aux deux fichiers
chmod ␣ u+wx ␣ toto ␣ titi ␣ Ajoute les droits w et x pour le propriétaire
chmod ␣ go-w ␣ toto ␣ titi ␣ Enlève le droit d'écriture au groupe propriétaire et aux autres (other)
chmod ␣ -R ␣ a+X ␣ . Ajout récursif du bit x s'il était déjà présent pour l'un des 3 (a ≡ ugo)

L'option -R indique la récursion.

chown ␣ exco ␣ toto ␣ titi ␣ Le propriétaire des deux fichiers devient exco
chgrp ␣ liris ␣ toto ␣ titi ␣ Le groupe propriétaire des deux fichiers devient liris

Le premier but de la commande ln est de permettre de donner plusieurs noms au même fichier (pas répertoire). Le fichier existe tant qu'il porte encore un nom. Les différents donnent accès au même contenu même s'il est modifié. Tous les noms du fichier sont au même niveau, il n'y en a pas un plus important qu'un autre. Ce liens est appelé lien hard, il est peu usité, il permet par exemple de partager l'accès de manière sécurisé à un fichier sans créer un groupe spécial.

$ echo ␣ Bonjour ␣ >xxx
$ ln ␣ xxx ␣ yyy
$ cat ␣ yyy
Bonjour
$ echo ␣ -n ␣ ... ␣ >>yyy
$ cat ␣ xxx
Bonjour...
$ echo ␣ -n ␣ toi ␣ >>xxx
$ cat ␣ yyy
Bonjour...toi
$ rm ␣ xxx
$ cat ␣ yyy
Bonjour...toi

Le liens symbolique :

$ ln ␣ -s ␣ /usr/include/stdio.h ␣ stdio.h Un raccourci vers stdio.h est créé dans le répertoire courant.
$ ln ␣ -s ␣ ../xxx ␣ /tmp/toto Le raccourci /tmp/toto pointe sur /xxx

Accroche ou décroche des systèmes de fichiers à la hiérarchie des fichiers. Les exemples suivants fonctionnent pour le super-utilisateur (root), Pour les media amovibles, le gestionnaire de fichier les monte normalement sans intervention de l'utilisateur.

mount ␣ /dev/sda1 ␣ /media/MaClefUSB
umount ␣ /media/MaClefUSB
mount ␣ UnServeurNFS:/UnRépertoire ␣ /homeDistant

	Avertissement
	Il faut toujours démonter avec umount (ou en utilisant la souris) avant d'enlever un media amovible. En effet, on effet, la copie des informations sur les supports physiques n'est certaine qu'un fois que le démontage est réussi.

df affiche la liste des systèmes de fichiers accrochés à la hiérarchie des fichiers. Pour chacun, on obtient le nom du périphérique, l'endroit où on accroche le système de fichier, la place totale, utilisée et libre en nombre de kilo-octets. L'option -h permet d'avoir un affichage plus lisible par un être humain (avec des Mega/Giga/Tera/Peta octets).

Cette commande souvent utilisée dans les if et while est aussi nommée crochet ouvrant : [. Elle évalue l'expression indiquée par ses paramètres et retourne vrai ou faux en conséquence. Attention, le vrai en shell c'est quand la commande retourne 0 indiquant qu'elle c'est bien passée. C'est le contraire du C

Quelques exemples d'utilisation les plus courants en utilisant le nom test ou crochet. Les espaces sont fondamentaux.

test ␣ "oui" ␣ = ␣ "$REPONSE" Vrai si égalité textuelle
test ␣ "5" ␣ -eq ␣ "$REPONSE" Vrai si égalité numérique ('5 ' = '5' est faux)
test ␣ "5" ␣ -lt ␣ "$REPONSE" Vrai si 5 < $REPONSE
[ ␣ -e ␣ "$F" ␣ ] Vrai si l'entité $F existe
[ ␣ -f ␣ "$F" ␣ ] Vrai si le fichier $F existe
[ ␣ -d ␣ "$F" ␣ ] Vrai si le répertoire $F existe

La commande find permet de trouver des fichiers dans une hiérarchie. La syntaxe est complexe, de manière simplifiée, on peut considérer que les paramètres sont dans l'ordre :

Exemples d'utilisations courants dans le répertoire courant :

Les exemples précédents s'exécutent lentement car la commande est exécutée pour chaque fichier trouvé. Souvent on peut exécuter la commande avec plusieurs noms de fichier à la fois. C'est le travail de la commande xargs qui va appeler un autre commande en lui mettant plusieurs arguments. Pour détruire tous les fichiers .bak:

find ␣ . ␣ -name ␣ '*.bak' ␣ -print0 | xargs ␣ -0 ␣ rm ␣ -f

On utilise les options -0 et -print0 pour que les noms de fichier soient séparés par un code \0. Ainsi on pourra traiter des noms de fichiers absolument quelconque, même contenant des retours à la ligne. Si les noms de fichiers sont normaux et que l'on ne veut pas forcer la destruction, on peut taper la commande plus courte suivante.

find ␣ . ␣ -name ␣ '*.bak' | xargs ␣ rm

La commande xargs est intelligente, si les noms à ajouter sur la ligne de commande sont trop nombreux, elle fera le travail en plusieurs fois. En effet, la longueur des commandes que l'on peut taper est limité.

	Avertissement
	La commande suivante ne fonctionne pas s'il y a beaucoup de fichiers (ou si les fichiers contiennent des espaces). rm ␣ $(find ␣ . ␣ -name ␣ '*.bak')

Fondamentale pour le développement, elle affiche les différences entre deux fichiers et vous permet donc de savoir ce qui a changé entre une version qui marche et une qui ne marche pas. L'option -u fait un affichage plus lisible.

C'est cette commande qui permet de générer des patchs (rustine en français) permettant de mettre des ensembles de fichiers à jour sans tout retransférer.

La commande patch permet d'appliquer des changements à un fichier même si le fichier ne correspond plus exactement au fichier de départ. Cela permet de fusionner (to merge en anglais) des modifications faites par différentes personnes sur le même fichier initial.

Les systèmes de développement collaboratif comme SVN, GIT, Mercurial rendent invisible cette notion de patch aux différents participants du projet.

Calcule la place disque occupée par un répertoire et tout ce qu'il contient.

Ces deux commandes permettent de transformer une hiérarchie de fichier en un seul fichier et inversement. Ceci à de nombreux avantages : cela prend moins de place, c'est plus facile à manipuler, cela peut mieux se comprimer, cela permet de stocker ce fichier sur n'importe quel type de système de fichier, par exemple une clef USB.

Utilisable comme un filtre ou pour comprimer un ou plusieurs fichiers ou les fichiers d'une hiérarchie.

gzip ␣ toto Remplace toto par sa version comprimée toto.gz
gunzip ␣ toto.gz   Remplace toto.gz par sa version décomprimée toto
gzip ␣ <toto ␣ >toto.gz   Création de toto.gz sans que toto disparaisse
gunzip ␣ <toto.gz | grep ␣ truc Décomprime toto.gz en affichant seulement les lignes contenant truc
tar ␣ -cvf ␣ - ␣ MonRépertoireVersion-1.2 | gzip ␣ >MonRépertoireVersion-1.2.tar.gz
gunzip ␣ <MonRépertoireVersion-1.2.tar.gz | tar ␣ -xvf ␣ -

L'option -0 permet de compresser rapidement (mais mal) et l'option -9 permet de comprimer efficacement (mais lentement).

La commande bzip2 est plus efficace mais par forcément installée par défaut sur toutes les machines (en 2008).

cut permet d'afficher une ou des colonnes de caractères ou de valeurs de fichiers. paste permet de les recoller ensemble. L'option -d permet de définir le séparateur de colonnes. L'option -f permet de définir le ou les colonnes à extraire.

cut ␣ -d ␣ : ␣ -f ␣ 1 ␣ /etc/passwd Extrait les noms d'utilisateur

Prend les dernières ou premières lignes d'un fichier. tail ␣ -f permet de voir la fin d'un fichier et elle reste bloquée en affichant au fur et à mesure ce qui est ajouté au fichier. C'est très utile pour surveiller un fichier de "log" qui grossi.

Permet d'afficher l'entrée standard ou le contenu des fichiers indiqués en triant les lignes. On peut choisir les colonnes qui seront les clefs du tri. En sortie, toutes les colonnes seront présentes et le contenu des lignes sera inchangés.

Ce programme est issu de 'ed' qui est le premier éditeur de texte sous UNIX. Quand on utilise 'ed' pour éditer de manière automatique un fichier chaque commande que l'on fait s'applique à l'ensemble du fichier ce qui est gênant quand le fichier est plus gros que la mémoire de l'ordinateur. sed lit le fichier ligne par ligne et applique successivement les commandes sur chacune des lignes. 99.9 des utilisations faites sont de la forme :

sed ␣ -e ␣ "s/regex/.../g" ␣ -e ␣ "s/regex/.../g" ␣ ...autres remplacements...

Pour les expressions régulières étendues, il faut ajouter l'option -r.

C'est un langage de programmation ressemblant au C qui comme 'sed' analyse les fichiers lignes par ligne. Il supporte les tableaux indexés par des chaînes de caractères au lieu de simples entiers. Exemples simples :

Affiche la ligne la plus longue de /etc/passwd
$ awk ␣ </etc/passwd ␣ '{ if (length($0) > MAX) { MAX=length($0) ; M=$0 ; } } END { print M; }'↵
cyphesis:x:107:65534:Cyphesis C++ Administrator,,,:/usr/share/cyphesis:/bin/bash
Affiche les lignes entre DEBUT et FIN
$ awk ␣ '↵
> /^DEBUT$/ { A=1 ; next ; }↵
> $0=="FIN" { A=0 ; }↵
>  A==1     { print $0 ; }'↵

Permet de se connecter sur une autre machine. Le shell que l'on obtient après avoir indiqué son nom et mot de passe s'exécute sur l'autre machine et la machine sur laquelle vous avez tapé la commande.

ssh ␣ nom-de-machine

On peut demander à exécuter un script shell sur une machine distance :

ssh ␣ nom-de-machine ␣ "pwd;ls;hostname"

L'exemple suivant permet de copier une hiérarchie de fichiers de la machine locale sur la machine distante tout en comprimant les données transmises pour utiliser le moins de débit sur le réseau.

tar ␣ -cf ␣ - ␣ MonRépertoire | gzip | ssh ␣ nom-de-machine ␣ "gunzip | tar ␣ -xvf ␣ -"

	Avertissement
	La commande telnet ne crypte pas les échanges. On peut donc vous volez votre mot de passe.

L'utilitaire standard pour échanger des fichiers entre machine. Les navigateurs web utilisent le même protocole quand l'URL commence par 'ftp:'

	Avertissement
	La commande ftp ne crypte pas les échanges. On peut donc vous volez votre mot de passe.

Permet de copier des fichiers entre machines différentes si vous avez un compte sur les deux machines. Les noms des fichiers sont préfixés par le nom de la machine ou ils se trouvent.

La syntaxe de scp est la même que celle de cp à la différence que le nom du fichier peut être préfixé par nom-de-machine:

scp ␣ toto ␣ machine-distante:titi
scp ␣ -rp ␣ machine-distante:/usr/include ␣ CopieDeInclude
scp ␣ machine-distante-1:toto ␣ machine-distante-2:.

	Avertissement
	La commande rcp ne crypte pas les échanges. On peut donc vous volez votre mot de passe.

Permet d'envoyer un mail par ligne de commande. Permet aussi de lire son mail local en ligne de commande.

L'envoi de mail par ligne de commande permet d'écrire des scripts envoyant des messages automatiquement pour prévenir de problèmes qui se sont produits durant une exécution de nuit ou bien pour faire de l'envoi de messages personnalisés à une liste de personnes.

echo ␣ "Je suis le texte du message" | mail ␣ -s ␣ "Je suis le sujet du message" toto@titi.com

Affiche sur la sortie standard le contenu de l'URL passé en paramètre. Ceci permet d'avoir des scripts récupérant régulièrement le contenu de pages web pour faire des mises à jours par exemple, ou bien détecter des changements.

GET ␣ http://lwn.net

Manipulation de processus.

Regarder des informations modifiées en temps réel. L'utilisation est simple, vous passez en paramètre le script shell que vous voulez exécuter régulièrement et la commande watch vous affiche le résultat sur l'écran.

watch ␣ "df;ls ␣ -l"

Manipulation de nom de fichier. 'expr' permet de faire des calcul mais aussi de faire des manipulations simple sur les chaînes de caractères.

$ dirname ␣ /usr/include/stdio.h↵
/usr/include
$ dirname ␣ usr/include/stdio.h↵
usr/include
$ dirname ␣ stdio.h↵
.
$ basename ␣ /usr/include/stdio.h↵
stdio.h
$ basename ␣ /usr/include/stdio.h ␣ .h↵
stdio

Ces commandes permettent de gérer les impressions et lister les imprimantes. Suivant la version d'UNIX ce sont les unes ou les autres qui seront utilisées.

Pour éviter toute surprise (et gaspillage), il est conseillé de convertir les fichiers en PostScript, et d'afficher le PostScript à l'écran avant d'imprimer.

lp ␣ output.ps

On détruit une impression en faisant :

lprm ␣ numéro-d-impression

Outils de développement.