lycée polyvalent diderot département...

Lycée polyvalent DIDEROT Département IRIS 61, rue David d’Angers 75019 PARIS http://www.diderot.org

COURS

Le langage de commandes d'UNIX : Le shell

Auteur Version - Date Nom du fichier

J.Ozbolt , G.Valet Version 1.1 - Sept 2007 cours-shell.docx

COURS Le langage de commandes d'UNIX : Le shell

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

A. Sommaire

A. SOMMAIRE .................................................................................................................................................................................. 2 B. PREAMBULE ................................................................................................................................................................................ 3

Bibliographie : ......................................................................................................................................................................... 3 C. INTRODUCTION ............................................................................................................................................................................ 4

C.1. Les différents Shells à l’heure actuelle ............................................................................................................................. 4 D. LA REDIRECTION DES ENTREES SORTIES .............................................................................................................................................. 4

D.1. Redirection de l'entrée standard ..................................................................................................................................... 5 D.2. Redirection temporaire de l'entrée standard .................................................................................................................. 5 D.3. Redirection de la sortie standard..................................................................................................................................... 5 D.4. Redirection de la sortie d’erreur ...................................................................................................................................... 6 D.5. Compléments sur les redirections .................................................................................................................................... 6

E. EXECUTION D'UNE COMMANDE OU D’UN SCRIPT ................................................................................................................................. 7 E.1. Commande simple............................................................................................................................................................ 7 E.2. La commande ps .............................................................................................................................................................. 8 E.3. L'enchaînement des commandes ..................................................................................................................................... 8 E.4. Connexion de processus, les tubes ou pipes ..................................................................................................................... 9 E.5. Exemple de « fichier de commandes » ou « fichier script » ........................................................................................... 10 E.6. Compléments sur les métacaractères ............................................................................................................................ 10

F. NOTION DE VARIABLE ................................................................................................................................................................... 11 F.1. Déclaration ..................................................................................................................................................................... 11 F.2. Variables de substitution prédéfinies ............................................................................................................................. 12 F.3. Variables d'environnement prédéfinies.......................................................................................................................... 12 F.4. Transmission des paramètres ........................................................................................................................................ 14 F.5. La capture de la sortie standard du résultat d’une commande ..................................................................................... 14

G. LES STRUCTURES DE CONTROLE ..................................................................................................................................................... 15 G.1. La structure conditionnelle if then else fi ....................................................................................................................... 15 G.2. La bouche pour : for....................................................................................................................................................... 18 G.3. La boucle tant que : while.............................................................................................................................................. 19 G.4. La boucle jusqu’à : until ................................................................................................................................................. 19 G.5. Le branchement multiple ............................................................................................................................................... 20 G.6. L’exécution de commandes dans un sous-shell ............................................................................................................. 20 G.7. Exemple de synthèse ..................................................................................................................................................... 20

H. LES VARIABLES DE TYPE NUMERIQUE ............................................................................................................................................... 21 I. LE TRAITEMENT DES EVENEMENTS ................................................................................................................................................... 22 J. LA NOTION DE FONCTION .............................................................................................................................................................. 23 K. QUELQUES COMMANDES UTILES .................................................................................................................................................... 24

K.1. echo - affichage ............................................................................................................................................................. 24 K.2. test - commande conditionnelle .................................................................................................................................... 25 K.3. file - commande de classification ................................................................................................................................... 26 K.4. read - commande de lecture .......................................................................................................................................... 26 K.5. cmd - commande de comparaison ................................................................................................................................. 26 K.6. grep - commande de recherche ..................................................................................................................................... 26 K.7. sed -le filtre éditeur ........................................................................................................................................................ 28 K.8. sort - tri et fusion de fichiers .......................................................................................................................................... 29 K.9. basename-dépouiller une chaîne ................................................................................................................................... 30 K.10. expr - évaluation des arguments en tant qu'expressions............................................................................................. 30

L. UN RESUME DE QUELQUES COMMANDES PAR ORDRE ALPHABETIQUE ..................................................................................................... 32



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

Bibliographie :

Steve Bourne Le système UNIX

InterEditions PARIS, 1985

Jean-Michel Moreno UNIX Administration EDISCIENCE International, PARIS 1995.

Brian Kernighan et Rob Pike L’environnement de programmation UNIX InterEditions PARIS, 1986. Jean-Marie Rifflet La programmation sous UNIX EDISCIENCE International, PARIS 1994.

Bernard Coulange Programmation système sous UNIX Eyrolles, PARIS 1988.

Alain-Bernard Fontaine et Philippe Hammes UNIX System V Masson Paris 1989.

H Lucas, B. Martin G. de Sablet UNIX Mécanismes de base, Langage de commande, Utilisation Eyrolles, PARIS 1984.

André Tanenbaum Les systèmes d’exploitation InterEditions PARIS, 1989

Christian Pélissier UNIX Utilisation, Administration, Réseau Internet HERMES, PARIS 1998.

Divers Auteurs souvent talentueux Les HOWTO LINUX Serveurs ftp anonymes (par exemple celui de jussieu à Paris).



C. Introduction Un « Shell » est un interpréteur de commandes du système UNIX. C’est aussi un langage de commande, qui réalise l'interface entre l'utilisateur et le noyau d'UNIX. Les commandes exécutées par un Shell peuvent provenir soit du terminal, soit d'un fichier appelé fichier de commandes. Le Shell est un véritable langage de programmation, c'est à dire, il possède :

- la notion de variable, - des structures de contrôle (if, for while, ..)

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

Le Bourne Shell (sh) est le premier Shell crée et il reste celui dont tout système Unix a besoin pour lancer les outils de configuration au démarrage de la machine. Les Shell ksh ("Korn Shell"), bash ("Bourne again Shell") et zsh ("Zero Shell") utilisent des syntaxes plus riches mais restent compatibles avec sh. Le csh ("C_Shell"), et le tcsh ("Toronto C-Shell") ont par contre des syntaxes beaucoup plus différentes (de sh) et très proches de celle du langage C.

D. La redirection des entrées sorties Lors de l'ouverture d'une session, l'utilisateur possède, par l'intermédiaire de son terminal :

une entrée standard définie par l'identificateur stdin et correspondant à l'entier 0, par défaut c'est le clavier,

une sortie standard définie par l'identificateur stdout et correspondant à l'entier 1, par défaut c'est l'écran,

une sortie d'erreur définie par l'identificateur stderr et correspondant à l'entier 2, par défaut c'est l'écran.

Chaque commande ou programme utilisateur peut utiliser cette entrée ou ces sorties.

Par exemple, les commandes suivantes :

who utilise stdout pour afficher la liste des utilisateurs logés,

cc (le compilateur c) utilise stderr pour afficher les éventuels messages d'erreur. Il est possible de rediriger ces entrées sorties.

La seule chose dont on peut être sûr, c'est qu'au moins un Shell compatible sh existe sur toute machine

Unix. C'est pourquoi, ces notes de cours se limiteront à décrire les fonctions essentielles du Bourne Shell

(sh).



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

C'est l'opérateur < qui permet d'indiquer à l'interpréteur de commande la redirection de l'entrée.

a. Exemple

$ a.out < data

Dans cet exemple, le fichier data doit contenir les données nécessaires à l'exécution du programme a.out. L'opérateur n'aura donc plus besoin d'entrer ces données au clavier.

b. Exemples d'exécution

Sans redirection de l'entrée : $ a.out

Ce programme détermine le plus grand de 3 entiers.

Entrez 3 entiers : 3 22 126

Le plus grand est : 126

Avec redirection de l'entrée : $ a.out < data

Ce programme détermine le pus grand de 3 entiers.

Entrez 3 entiers :

Le plus grand est : 126

Voici le contenu du fichier data obtenu avec la commande cat : $ cat data

3 22 126

$

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

a. Exemple

[nom_commande] << [séparateur]

ligne1

ligne2

...

[séparateur]

La commande reçoit en entrée le texte situé entre les deux occurrences du séparateur.

D.3. Redirection de la sortie standard

C'est l'opérateur > qui permet d'indiquer à l'interpréteur de commande la redirection de la sortie.

a. Exemple

$ ls -l > listage

$



Le contenu de la commande ls -l n'apparaît pas à l'écran, il se trouve maintenant dans le fichier de nom "listage" et :

si le fichier "listage" n'existait pas il est créé,

si le fichier "listage" existait son ancien contenu est détruit et remplacé par le résultat de la commande.

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

b. Exemple

$ a.out >> res

$

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

Si le fichier "res" existait le résultat de la commande est ajouté à la fin de son ancien contenu.

D.4. Redirection de la sortie d’erreur

Par défaut, c'est à dire sans indication contraire l'opérateur > permet de rediriger la sortie standard 1, pour rediriger la sortie erreur, il faut l'indiquer explicitement à l'aide de son identificateur 2.

a. Exemple

$ cc essai.c 2 > erreur

Dans cet exemple, s'il y a des erreurs lors de la compilation, elles seront dirigées vers le fichier "erreur", s'il n'y en a pas, ce dernier sera créé, mais sera vide.

D.5. Compléments sur les redirections

Il est possible de rediriger un descripteur standard sur un autre grâce à la syntaxe suivante : n>&m avec n et m descripteurs

a. Exemple

$ echo « message » 1>&2

Dans ce cas, le message, normalement dirigé sur stdin par la commande echo, est redirigé vers stderr. Le descripteur 1 de stdin est ici facultatif, comme le montre l’exemple ci-dessous. $ echo « Nombre de paramètres incorrect » >&2



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

E.1. Commande simple

Le format d'une commande sous UNIX suit le modèle suivant : $ nom_de_la_commande -options arguments

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

1732

$

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

1778

$ vi essai.c

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



E.2. La commande ps

La commande « ps » permet de connaître la liste des processus actifs.

a. Exemple

$ ps

PID TTY TIME CMD

927 05 0:22 -sh

1732 05 0:02 cc

1734 05 0:01 ps

$

Nous constatons que lors de l'exécution de la commande ps, trois processus étaient encore actifs pour l'utilisateur relié au terminal tty05:

Le Shell initial (pid 927) obtenu lors de l'ouverture de la session par la commande login,

Le processus de compilation lancé en arrière plan,

La commande ps qui s'exécutait . L'utilisateur pourra consulter la liste des processus actifs pour connaître la fin d'un processus lancé en arrière plan. $ ps

PID TTY TIME CMD

927 05 0:22 -sh

1764 05 0:01 ps

$

Le processus 1732 est terminé.

E.3. L'enchaînement des commandes

Il est possible d'enchaîner l'exécution des commandes à l'aide de l'opérateur ; (point virgule).

a. Exemple

$ date;who;pwd;ls -l

Chaque commande sera exécutée séquentiellement.

Remarquons que la commande ps doit consulter la table des processus, pour cela, elle doit ouvrir le fichier

spécial /dev/kmem qui donne accès à l’espace mémoire du noyau UNIX. La commande ps doit donc avoir le

set GID actif.



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

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

Le fichier tempo contient le résultat de la commande who. $ wc -l < tempo

7

$

La commande wc avec l'option l compte et affiche le nombre de lignes du fichier "tempo". Le nombre d'utilisateurs connectés est donc de 7. Le fichier "tempo" assure la connexion entre les deux processus. Il existe un opérateur tube ou pipe qui réalise la même fonction et évite la création du fichier intermédiaire:

C'est l'opérateur « | » qui relie la sortie standard d'un processus à l'entrée standard d'un autre processus :

a. Exemples

C'est le Shell qui assure la connexion des deux processus : $ who | wc -l

7

$

La commande ci-dessous permet de lister le répertoire page par page : $ ls -l | more



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

$ cat commande

echo "vous travaillez sur UNIX"

echo " nous sommes: \c"

date

echo "vous êtes :\c"; who I am

echo "vous travaillez avec" ; who

echo "votre répertoire actuel est: \c"

pwd

$

Le fichier commande est un fichier "texte" qui sera interprété par le Shell. Pour exécuter "commande" il faut :

Soit faire appel explicitement à la commande sh qui exécute les commandes: $ sh commande

Soit rendre le fichier exécutable et le lancer comme une commande: $ chmod u+x commande

$ commande

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

Certains caractères ont une signification particulière pour le Shell et sont appelés métacaractères (nous étudierons la fonctionnalité de certains plus loin), ce sont : *, ?, [...],$, #, &, ; ,> , >>, <, <<, |, ‘,",`, \, (), {}.

Rappelons que les métacaractères *, ?, [...] permettent de construire des chaînes de caractères génériques, ainsi :

* désigne une chaîne de caractères quelconque ;

? désigne un caractère quelconque ;

[...] désigne les caractères entre crochets, définis par énumération ou par un intervalle. D’autres permettent de modifier l'interprétation d'une commande :

; (le point virgule) sépare deux commandes sur une même ligne ;

' (l’apostrophe) délimite une chaîne de caractères contenant des espaces (à l'intérieur, tous les métacaractères perdent leur signification) ;

" (le guillemet) délimite une chaîne de caractères contenant des espaces (à l'intérieur, tous les métacaractères perdent leur signification, à l'exception des métacaractères `, \et $) ;

` (l’accent grave) "capture" la sortie standard pour former un nouvel argument ou une nouvelle commande (cette particularité est présentée plus loin) ;

\ (l’anti-slash) annihile la signification du métacaractère qui suit ;



{ et } (les accolades) permettent de regrouper un ensemble de commandes et de les exécuter dans le "Shell courant" ;

( et ) (les parenthèses) permettent de regrouper un ensemble de commandes et de les exécuter dans un "Shell fils".

Ainsi :

Les simples quotes '...' (apostrophes) : les caractères inclus entre 2 simples quotes ne sont pas évalués, ils conservent leur valeur littérale ;

Les doubles quotes "..." (guillemets) : les caractères inclus entre 2 doubles quotes conservent leur valeur littérale à l'exception de $ ` et \. Les substitutions des variables sont réalisées (rôle de $) ainsi que l'évaluation des commandes.

F. Notion de variable Une variable Shell est identifiée par un nom commençant nécessairement par une lettre et peut être utilisée dans les commandes (au sens large). La référence au contenu d'une variable est obtenue en faisant précéder son nom du caractère $.

F.1. Déclaration

variable=valeur

# Utilisation

variable2=$variable ou variable2=${variable}

Exemples $ variable=rouge Remarquez l'absence d'espace entre le signe =

$ echo $variable

rouge

$

On utilise une variable, par exemple, pour mémoriser des noms fréquemment utilisés : $ moi=/users/toto

$ cd /

$ pwd

/

$ cd $moi

$ pwd

/users/toto

$

Pour qu'un métacaractère perde sa signification et soit interprété autrement par le Shell, il suffit de placer

le caractère \ devant. D’une façon générale, lorsqu’un ou plusieurs métacaractères figurent dans une

chaîne de caractères, il est parfois préférable d’utiliser le « quotage ». Le quotage est utilisé pour

supprimer les fonctionnalités de certains caractères spéciaux du Shell, dont les métacaractères.



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

Ces variables sont liées à l'exécution d'une commande, elles ne peuvent être modifiées. Elles sont évaluées, c’est-à-dire qu’elles sont toujours évoquées précédées du caractère $.

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

1, ..., 9 arguments (du 1er au 9ème) ($1, ..., $9) ;

# nombre d'arguments passés dans une commande ($#) ;

* liste de tous les arguments passés dans une commande ($*) ;

@ liste de tous les arguments ($@) ;

? code retourné par la dernière commande exécutée($?) ;

$ numéro de processus de ce Shell ($$) ;

! numéro du dernier processus lancé en arrière plan ($!) ;

- drapeaux fournis au Shell par set ($-). Toutes les valeurs retournées sont exprimées en décimal.

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

Ces variables sont dites d’environnement parce qu’elles sont transmises à tous les processus fils du Shell et donc en particulier par le Shell de login à ses processus fils.

HOME chemin d'accès au répertoire initial de l'utilisateur ; argument par défaut de la commande cd(1) ;

PATH définition de la liste des répertoires à parcourir lors de l'interprétation d'un nom de commande ;

PS1 invite principale ("prompt") du Shell en mode interpréteur qui est par défaut le "$" ;

PS2 invite secondaire du Shell en mode programmation qui est par défaut le ">" ;

IFS séparateurs de champ des arguments qui sont normalement l'espace, la tabulation et la fin de ligne ;

MAIL chemin d'accès à la boîte aux lettres utilisateur ;

MAILCHECK intervalle en secondes au bout duquel le mail est contrôlé ;

CDPATH liste de chemins d'accès pour la commande cd ;

ENV nom du fichier des variables d'environnement ;

TERM nom du type de terminal ;



a. Exemples

Il est possible de connaître les variables pré définies de son environnement grâce à la commande env : $ env

HOME=/user1/fred

LOGNAME=fred

MAIL=/usr/mail/fred

PATH=:/bin:/usr/bin

TERM=q101 Remarquez la variable d'environnement TERM qui permet de définir

l'émulation du terminal utilisé.

......

$

Nous pouvons changer la définition du prompt : $ echo $PS1

$

$ PS1='toto '

toto

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

PATH=:/user/bernard/bin:/bin:/usr/bin

MAIL=/usr/spool/mail/bernard

stty kill'^U' erase 'DEL'

TERM=q101

export PATH MAIL TERM

$

Remarquons que la variable PATH est modifiable à tout moment, en effet, il est possible de la redéfinir soit explicitement : PATH=:/bin:/usr/bin:/$HOME/bin

Soit concaténer son ancienne valeur avec d’autres chemins, le séparateur étant le caractère : (deux points) : PATH=$PATH:$HOME/bin

Il est utile, après modification du fichier .profile, de faire prendre en compte son nouveau contenu sans qu’il soit nécessaire de fermer et réouvrir une session. Pour cela une syntaxe particulière force l’exécution de ce fichier par le shell courant et non par un shell fils — ce qui serait sans effet — Cette forme est la suivante : $ cd

$ . .profile



F.4. Transmission des paramètres

La communication entre le Shell et les procédures de commande est réalisée au moyen de paramètres transmis par valeur. Les paramètres sont repérés par leur position dans la liste d'appel :

0 correspond au nom de la commande,

1 au premier paramètre, 2 au deuxième paramètre,..., 9 au neuvième et dernier. L'affectation d'une valeur à ces paramètres peut être faite dans la procédure appelée par la commande interne set, qui affecte dans l'ordre les différents arguments aux paramètres positionnels. Exemple $ cat commande

echo "valeur des paramètres après appel"

echo $1;echo $2;echo $3

set dix onze douze

echo "valeur des paramètres après set"

echo $1;echo $2;echo $3

$

$ commande un deux trois

valeur des paramètres après appel

un

deux

trois

valeur des paramètres après set

dix

onze

douze

$

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

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

$ echo $list

es.c exemple.c devoir.c

$ a=10

$ a=`expr $a + 1`

$ echo $a

11

$



G. Les structures de contrôle L'analogie avec les langages algorithmiques se retrouve avec ces structures de contrôle dans lesquelles les instructions sont des listes de commandes.

G.1. La structure conditionnelle if then else fi

a. 1ère forme de if

if liste_commandes

then liste_commandes_1

else liste_commandes_2

fi

La liste des commandes suivant if est exécutée, si la valeur de retour est 0, la liste des commandes suivant then est exécutée (liste_commandes_1) sinon c'est la liste suivant else (liste_commandes_2) qui est exécutée, si elle existe. Remarques

La branche else est facultative.

Pour être reconnu de la commande, les mots if, then, else doivent être:

soit le 1er mot de la commande,

soit être précédés d'un ; (point virgule), comme ci-dessous : if liste des commandes ;then liste des commandes ;else liste des commandes ;fi

Ce qui est beaucoup moins lisible.

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

En Shell : la valeur 0 est associée au booléen "vrai" et toute autre valeur correspond au booléen "faux" (convention inverse de celle du langage C).

Exemple 1 Ecrire une commande qui compare deux fichiers à l'aide de la commande cmp. Voici un extrait de la commande cmp : cmp [-l] [-s] fichier1 fichier2

-l imprime la position où commence la différence,

-s n'affiche rien.

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

0 les fichiers sont identiques,

1 les fichiers sont différents,

2 problème...

D'où le programme : $ cat testif

if cmp -s $1 $2



then echo $1 et $2 sont identiques

else echo $1 et $2 sont différents

fi

$

Et son exécution : $ sh testif truc machin

truc et machin sont différents

$

$ chmod u+x testif

$ testif truc truc

truc et truc sont identiques

$

Il est possible d'utiliser les opérateurs ET et OU dans la liste des commandes. Ces opérateurs sont:

-o pour le OU logique,

-a pour le ET logique. Exemple 2 if test -z $2 -o -z $3

then echo il faut 3 paramètres

else

......

fi.

La commande test avec l'option z retourne la valeur 0 si la longueur de la chaîne (ici $2 ou $3) est nulle. Voir documentation UNIX. La structure conditionnelle peut se généraliser grâce au « elif »: if liste_commandes

then

liste_commandes_1

elif liste_commandes

then

liste_commandes_2

else

liste_commandes_3

fi

# et ainsi de suite …

b. 2ème forme de if

La 2ème forme de if permet de tester, grâce à des opérateurs, différentes valeurs sans passer par la commande test. Pour cela, il faut utiliser la syntaxe suivante :

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

sont bien au nombre de 2 et si ce sont bien des noms de fichiers. Il faudra donc ajouter à cet exemple

d’autres tests de validité (voir la commande test).



if [ expression ]

then

commandes...

fi

Voici une liste des opérateurs utilisables pour définir une expression :

Opérateur Description

Numériques

-eq « equals ». Test l’égalité numérique

-ne « non equals ». Test la non égalité numérique

-lt « less than ». Test la stricte infériorité numérique

-gt « greater than ». Test la stricte supériorité numérique

-ge « greater equals ». Test la supériorité ou l’égalité numérique

-le « less equals ». Test l’infériorité ou l’égalité numérique

Chaînes de caractères

-z Teste si la chaîne est vide

-n Teste si la chaîne est non vide

= Teste si la chaîne est égale à une autre

!= Teste si la chaîne est différente d’une autre

Fichiers

-L Lien symbolique

-d Teste si c’est un répertoire

-f Teste si c’est un fichier ordinaire

-s Teste si le fichier est vide

-r Teste si le fichier est lisible (Droits de lecture)

-w Teste si le fichier est modifiable

-x Teste si le fichier est exécutable

-nt Teste si le fichier est plus récent

-ot Teste si le fichier est plus vieux

Logique

! Exprime la négation

-a Opérateur « ET »

-o Opérateur « OU »

Quelques exemples : # Teste si le paramètre $1 est egal à 2

if [ $1 -eq 2 ]

# Teste si le paramètre $1 est une chaine égale à « toto »

if [ $1 = toto ]

# Teste si le paramètre $1 est une chaine vide

if [ -z $1 ]

# Teste si le paramètre $1 est un répertoire



if [ -d $1 ]

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

if [ $1 -nt /etc/xorg.conf ]

# Teste le fichier est exécutable et modifiable

if [ -w toto.txt -a -x toto.txt ]

G.2. La bouche pour : for

for nom [ in mot1 mot2 ... moti ... ]

do

liste de commandes

done

« nom » est une variable Shell qui prend successivement les valeurs mot ( mot 1, mot 2, mot 3...moti...) pour chaque exécution de la liste de commandes comprise entre do et done. Exemple 1 $ cat for_1

for i in un deux trois

do

echo $i

done

$

$ chmod u+x for_1

$ for_1

un

deux

trois

Lorsque la liste des mots est omise ([ in mot1 mot 2 ... moti ... ]), la variable prend comme valeurs successives, les valeurs des paramètres de position. Exemple 2 $ cat for_2

for i

do

echo $i\c

done

$

$ chmod u+x for_2

$ for_2 un deux trois

un deux trois

$

Exemple 3 $ cat testfichier

# cet exercice est plus difficile à comprendre pour l’instant



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

# passer cet exemple dans une première lecture

for i

do

f=$1

shift

if test -f $f

then

echo $f est un fichier

else

echo $f n\’est pas un fichier

done

G.3. La boucle tant que : while

while liste de commandes

do liste de commandes

done

La liste de commandes comprise entre do et done est répétée tant que la liste de commandes suivant while retourne un résultat vrai. Exemple 1 $ cat testwhile

# cette commande affiche les entiers 1 à 10 !

i=1

l=10

while [ $i -le $l ]

do

echo $i

i=`expr $i + 1`

done

G.4. La boucle jusqu’à : until

until liste de commandes

do liste de commandes

done

La liste de commandes comprise entre do et done est répétée jussqu’à ce que la liste de commandes suivant until retourne un résultat vrai. Exemple $ cat testuntil

# cette commande affiche les entiers 1 à 10 !

i=1

l=10

until [ $i –gt $l ]

do

echo $i



i=`expr $i + 1`

done

G.5. Le branchement multiple

case mot in

suite de caractères ) liste de commandes ;;

suite de caractères) liste de commandes ;;

..........

esac

La seule liste de commandes exécutée est la première qui correspond à la suite de caractères. Les autres ne seront pas exécutées. Exemple $ cat forcase

for i

do

case $i in

A) echo $i : vous avez tapé A ;;

B | C) echo $i : vous avez tapé B ou C ;;

?)echo $i : vous avez tapé un autre caractère que A, B, ou C;;

*) echo $i : vous avez tapé une chaîne de caractères ;;

esac

done

Remarques :

B | C se lit B ou C

? se lit: n'importe quel caractère

* se lit: n'importe quelle chaîne de caractères et correspond de ce fait à l'option par défaut.

G.6. L’exécution de commandes dans un sous-shell

Les commandes placées entre parenthèses sont exécutées dans un sous-shell. L’exemple ci-dessous illsustre cette particularité. Nous remarquons que le changement de répertoire ayant lieu dans le sous-shell n’affecte pas le répertoire du shell courant (père) : $ pwd

/users/ozbolt

$ (cd /tmp ; rm essai* ; )

$ pwd

/users/ozbolt

G.7. Exemple de synthèse

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



Les fichiers sont déplacés dans le répertoires $HOME/.del. Chaque fichier est suffixé par un numéro de version précédé du signe = pour éviter les homonymies. # !/bin/sh

# la ligne ci-dessus indique que cette commande doit être exécutée

# par /bin/sh

# usage de la commande : del fichier1 fichier2 fichier3 ...

if [ $# -lt 1 ]

then

echo "usage : del fichier2 fichier3 ..."

exit 1

fi

if [ ! -d $HOME/.del ]

then

mkdir $HOME/.del

fi

for i

do

v=1

if [ -f $i]

then

while [ -f $HOME/.del/$i=$v ]

do v=`expr $v + 1` done

mv $i $HOME/.del/$i=$v

else

echo "$i : ce fichier n’existe pas."

fi

done

Il faut de temps en temps nettoyer le répertoire $HOME/.del, par exemple toutes les semaines grâce à une procédure de nettoyage lancée automatiquement (voir le chapitre sur les sauvegardes).

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



Traduction en SHELL $ cat numeric

# commande testant si une chaine est numerique ou non :

# elle renvoie 0 si elle l'est 1 si elle ne l'est pas

expr $1 + 1 >/dev/null 2>/dev/null

if [ $? -eq 2 ] ; then exit 1 ; else exit 0; fi

$ numeric tyty

$ echo $?

1

$ numeric 123

$ echo $?

0

On remarquera :

Que les éventuels messages d'erreurs ont été redirigés vers le fichier spécial /dev/null afin qu'ils n'apparaissent pas à l'écran;

Que nous avons utilisé une nouvelle syntaxe pour la commande test qui utilise les [ ];

Que nous retournons une valeur au Shell appelant en utilisant la commande exit On utilisera maintenant cette commande pour écrire la commande finale demandée. (à faire en exercice).

I. Le traitement des événements Un certain nombre d'événements entraînent l'émission d'un signal correspondant au type de l'événement. Par exemple, la frappe de certains caractères provoquent l'émission d'un signal à destination du processus en avant plan sur le terminal. Ainsi, les caractères intr (CTRL+C) ou quit (CTRL+D) provoquent la terminaison des processus le recevant. Voici quelques signaux : N° NOM Action 1 SIGHUP terminaison du processus leader de session 2 SIGINT frappe du caractère intr au clavier 3 SIGQUIT frappe du caractère quit au clavier 9 SIGKILL signal de terminaison La commande interne « trap » permet de définir une séquence de commandes à exécuter lors de la prise en compte de l’événement par la procédure : trap [argument] num_signal

Les différentes formes de l'argument sont :

La chaîne vide "" le signal reçu est ignoré ;

Une commande qui sera alors exécutée à la réception du signal ;

Aucun, dans ce cas, les comportements par défaut des signaux énumérés seront réinstallés. Exemple



$ trap 'rm temporaire;exit' 2

Dans cet exemple, en cas d'arrivée de l'événement 2 (SIGINT), le fichier "temporaire" est détruit avant de provoquer la sortie. Nous dirons que nous avons mis en place un piège pour intercepter l'événement 2. Inversement, pour qu'une procédure ne tienne pas compte de l'arrivée de certains événements, il suffit de transmettre la chaîne vide comme argument de trap : $ trap '' 2 3

Les événements 2 et 3 sont masqués. Il est possible de réinstaller ces événements par la commande : $ trap 2 3

J. La notion de fonction La définition d'une fonction de nom « nom_de fonction » est réalisée par la séquence : nom_de_fonction() { liste des commandes }

Un appel de fonction est réalisé de la même manière qu'un appel de commandes. Premier exemple $ cat fonction

#!/bin/sh

#

# Exemple de script avec fonctions

usage()

{

echo "usage: $1 $2"

}

main()

{

if [ $# = 0 ]; then

usage `basename $0` "fichier";

exit 1

fi

}

main $*

Exemple Ecrire une fonction qui affecte une valeur, appartenant à un intervalle, à une variable. exemple d'appel : J=`choisi Jour 1-31`, ce qui signifie : affecter à la variable J une valeur comprise entre 1 et 31. Le nom de la fonction est "choisi", Jour étant une chaîne de caractères indiquant à l'utilisateur qu'il s'agit d'un jour compris entre les valeurs 1 et 31. Analyse La seule difficulté est la validité des données dans l'intervalle donné. En outre, il faut entrer des caractères numériques. Plus précisément, il faut entrer un ou deux caractères numériques.



Une première structure itérative lira un ou deux caractères numériques et une deuxième structure itérative vérifiera la validité de l'intervalle. Dans le programme ci-dessous, on saisit la date en imposant un intervalle à chaque élément. La commande « while : » est une boucle infinie. La sortie se fera grâce à un « break ». On sort de la structure la plus interne après avoir entré correctement un ou deux chiffres. On sort de la structure externe si la donnée est bien dans l'intervalle passé en paramètre à la fonction choisi et repéré par les paramètres de position 1 et 2 ($1, $2). # la fonction choisi

choisi()

{

while :

do

while :

do

echo "$1 ($2 - $3)" >&2

read A

case $A in

[0-9]) break ;;

[0-9][0-9]) break ;;

esac

done

if [ $A -le $3 -a $A -ge $2 ]

then

break

fi

done

case $A in

?)A="0$A";;

esac

echo $A

}

# programme principal

echo "mise à jour de la date et de l'heure"

J=`choisi Jour 1 31`

M=`choisi Mois 1 12`

A=`choisi An 55 99`

H=`choisi Heure 0 23`

MN=`choisi Minute 0 59`

date $M$J$H$MN$A

exit 0

K. Quelques commandes utiles

K.1. echo - affichage

echo argument ...



La commande « echo » affiche sur la sortie standard (stdin) la liste de ses arguments séparés par des espaces et terminé par un caractère fin de ligne. La commande reconnaît (selon les versions d’UNIX) un certain nombre de caractères : \b backspace \c pas de caractère fin de ligne \t tabulation etc.

K.2. test - commande conditionnelle

test arg

La commande « test » évalue l'expression indiquée. Si la valeur de cette expression est vraie, la commande prend pour code de retour la valeur zéro et une valeur différente de zéro si la valeur de l'expression est fausse. La commande test prend pour code de retour une valeur différente de zéro s'il n'y a aucun argument. Les arguments suivants doivent être utilisés pour construire une expression. Tous les opérateurs et toutes les options constituent des arguments séparés.

-r fich Le fichier existe et est accessible en lecture.

-w fich Le fichier existe et est accessible en écriture.

-f fich Le fichier existe et n'est pas un catalogue.

- d fich Le fichier existe et est un répertoire.

- s fich Le fichier existe et est d'une dimension supérieure à zéro.

- z s1 La longueur de la chaîne s1 est zéro.

- n s1 La longueur de la chaîne s1 est différente de zéro.

s1 = s2 Les chaînes s1 et s2 sont identiques.

s1 != s2 Les chaînes s1 et s2 sont différentes.

n1 -eq n2 Les entiers n1 et n2 sont algébriquement équivalents. Il est possible d'utiliser n'importe quel comparateur suivant : -ne, -gt, -ge, -lt, -le.

Ces opérateurs peuvent être associés avec les opérateurs suivants dans lesquels, l'opérateur -a possède une priorité supérieure à -o. ! Négation. -a ET. -o OU. ( expr ) Regroupement.



K.3. file - commande de classification

file [-f] arg

La commande file essaie de classifier le fichier arg (ASCII, binaire, répertoire, source C, source Shell, etc.). L'option f indique que le premier argument contient la liste des fichiers dont on veut déterminer le type.

K.4. read - commande de lecture

read var

La commande read permet d'initialiser la variable var par lecture de l'entrée standard stdin.

K.5. cmd - commande de comparaison

cmp [-l] [-s] fichier1 fichier2

Les contenus des deux fichiers en référence sont comparés. Selon l'option, les résultats sont :

-l imprime la position où commence la différence,

-s n'affiche rien. Dans tous les cas, la commande retourne le code suivant:

0 les fichiers sont identiques,

1 les fichiers sont différents,

2 problème, fichier inexistant par exemple.

K.6. grep - commande de recherche

grep [option] expression régulière [fichier ...]

Les commandes de la famille grep (voir aussi egrep, fgrep) recherchent dans les fichiers en entrée (stdin par défaut) les lignes qui contiennent une chaîne de caractères indiquée par l'expression régulière. Sauf option contraire, chaque ligne ayant cette propriété est écrite sur la sortie standard. Les principales options de la commande sont :

-c afficher uniquement le nombre de lignes contenant la chaîne.

-i pas de distinction entre minuscules et majuscules.

-n chaque ligne est précédée de son numéro d'ordre dans le fichier.

-v afficher toutes les lignes sauf celles contenant la chaîne.



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

0 au moins une ligne satisfaisante

1 aucune ligne satisfaisante

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



K.7. sed -le filtre éditeur

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

ou par sed -f fichier-des-requêtes

Les requêtes sont appliqués à l'entrée standard. Le texte des requêtes peut être mis entre apostrophes, pour éviter l'interprétation de certains caractères par le Shell. La forme générale d'une requête est: adresse1, adresse2 requête argument.

Si les adresses ne sont pas indiquées, la requête s'applique à toutes les lignes. Si les deux adresses sont identiques, une seule adresse est suffisante. D'une manière générale, les adresses déterminent le morceau du fichier qui est concerné par la requête. Les adresses peuvent être décrites par un nombre décimal ou par une expression régulière (semblable à celle de ed) placées entre /. Les opérateurs + et - ne sont pas autorisés pour adresser une ligne. De la même manière que pour ed, la requête s'applique à la ligne dont l'adresse correspond à l'expression. Les requêtes de sed sont les suivantes:

s/.../.../ Remplacer une chaîne.

d Détruire une ligne.

a\ Ajouter le texte après la ligne courante.

i\ Insérer du texte avant la ligne courante.

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

Elle produit la liste de tous les catalogues de la variable Shell $PATH. for j do

for i in `echo $PATH | sed -e 's/:/ /g'`



do if test -f $i/$j

then echo $i/$j

fi

done

done

K.8. sort - tri et fusion de fichiers

sort fichier1 fichier2 ...

Lorsqu'on exécute la commande : sort fichier1 fichier2 ..., toutes les lignes de tous les fichiers sont triées et envoyées sur la sortie standard. Si aucun nom de fichier n'est précisé, c'est l'entrée standard qui est triée, cela permet d'utiliser sort en tant que filtre. Le tri se fait, par défaut, sur la ligne entière en utilisant l'ordre lexicographique de chaque octet (en général c'est le code ASCII qui est employé). On peut demander un tri numérique à l'aide d'une option. La forme +pos1 -posl

restreint la zone qui est utilisée pour le tri au champ qui commence avec la position pos1 et qui se termine juste avant pos.2. Par exemple, la commande suivante trie sur le premier et le quatrième champ : sort +0 -1 +3 -4

Une position de départ peut être suivie de la lettre n pour indiquer un tri numérique sur la zone. Par exemple : sort +0n...

indique que l'on trie numériquement sur le premier champ. Le caractère de séparation de champ est par défaut le blanc, on peut modifier cette valeur par l'option -t. Ainsi, sort -t: ...

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

-n Trier en utilisant la valeur numérique du champ.

-r Trier par ordre décroissant.

-u Supprimer toutes les lignes identiques (sauf une).



K.9. basename-dépouiller une chaîne

basename chaîne [suffixe]

La commande basename supprime dans la chaîne tout préfixe qui se termine par / ou par le suffixe indiqué. Le résultat est affiché sur la sortie standard.

K.10. expr - évaluation des arguments en tant qu'expressions

expr arg ...

Les arguments sont considérés comme des expressions. Après l'évaluation, le résultat est envoyé sur la sortie standard. Chaque élément de l'expression est un des arguments. La liste des opérateurs est donnée ci-dessous. Cette liste est donnée dans l'ordre croissant des priorités. Les opérateurs qui ont une même priorité ont été regroupés :

expr1 | expr2 Prend la valeur de la première expression si elle est non nulle, sinon prend la valeur de la deuxième expression.

expr1 & expr2 Prend la valeur de la première expression si les deux expressions sont différentes de zéro, sinon prend la valeur de la deuxième expression.

expr1 op expr2 Prend la valeur 1 si le résultat de la comparaison est vrai, prend la valeur 0 sinon. L'opérateur op est l'un des suivants : <, <=, =, !=, >, => . La comparaison est numérique si les deux expressions sont des entiers, elle est lexicographique dans tous les autres cas.

expr1 + expr2

expr1 - expr2 Addition ou soustraction des arguments.

expr1 * expr2

expr1 / expr2 Multiplication, division ou reste après division des arguments

expr1 % expr2

expr1 : expr2 On compare la chaîne de caractères (première expression) avec l'expression générique (deuxième expression). La syntaxe de l'expression générique est la même que dans l’éditeur ed(1). On peut utiliser les séquences \ (et \ ) pour extraire une sous-chaîne du premier argument. Cette comparaison donne comme résultat le nombre de caractères identiques (0 si aucun).

( expr ) Utilisation des parenthèses pour regrouper des expressions. Il est souvent nécessaire de neutraliser les caractères spéciaux à l'aide du caractère \. Par exemple, on écrira : expr \* expr pour que le caractère * perde sa signification de caractère spécial du Shell.



Les codes de retour possibles d'un processus exécutant la commande ont la signification suivante :

0 : l'expression n'est ni vide ni nulle

1 : l'expression est soit vide soit nulle

2 : l'expression est incorrecte.

>2 : erreur en cours de l'évaluation de l'expression.



L. Un résumé de quelques commandes par ordre alphabétique

Nom Description Options Paramètres cal affiche le calendrier de

l'année spécifiée en paramètre

mois année

cat affiche sur la sortie standard le contenu du fichier mentionné

nom(s) de fichier(s)

cd se positionne sur le répertoire désigné

sans paramètre, se positionne sur le répertoire de login

chemin d'accès à un répertoire

chmod change les permissions en lecture, écriture, exécution

-R change les droits récursivement à partir du nœud

(mode = ugo) mode- nom de fichier ou de répertoire

compres

s compresse un fichier (voir gzip)

-c : résultat sans modification du fichier d'origine -f : écrasement d'un fichier compressé préexistant -v : taux de compression

fichier

cp copie du fichier source vers la destination

-i : demande confirmation -p : conservation de date et droits -r : recopie récursive d'un répertoire

source- destination

date retourne la date courante diff compare deux fichiers et

affiche les différences -c : affiche 3 lignes avant et 3 lignes après

fichier1 fichier2

echo envoi en écho des paramètres spécifiés à la suite ($PATH, "bille")

-n : supprime le retour chariot en fin de commande

elm courrier électronique

-s : chaîne de caractères qui sera le sujet du message -f : nom de la boîte à lettres

destinataire

file retourne le type de fichier spécifié (ascii, ps, exé.sparc ou 68040)

nom de fichier

find

réperto

ire

recherche récursive d'un fichier à partir du répertoire

-name fichier : fichier à chercher -print : affiche le chemin trouvé

grep affiche les lignes du fichier contenant la chaîne de caractères

-v : seulement les lignes ne contenant pas la chaîne -i : majuscules et minuscules

chaîne de caractères - fichier



identiques -n : avec numéros de lignes -c : nombre de comparaisons positives

gunzip décompresse un fichier -c : le résultat est produit sans modification du fichier d'origine -v : taux de compression

nom de fichier

gzip compresse un fichier (voir compress) par défaut, la destination est la sortie standard qu'on redirige vers un fichier si on veut obtenir un fichier compressé

-c : résultat sans modification du fichier source -f : écrasement d'un fichier compressé préexistant -v : taux de compression -d : force une décompression -9 : niveau maximum de compression

nom de fichier

head liste les n premières lignes du fichier

-n : nombre de lignes affichées (par défaut 10)

source > destination

id retourne le nom de login, l'UID, le groupe et le GID

kill envoi d'un signal à un processus

-l : liste des signaux disponibles -n : numéro du signal à envoyer 2 : INT (ctrl-c : ) 3 : QUIT (ctrl-\) 9 : KILL

numéro du processus

ln création d'une nouvelle référence pour un fichier préexistant

-s : création d'un lien symbolique

source - destination

logname retourne le nom de login de l'utilisateur

ls liste le contenu d'un répertoire

-a : prise en compte des 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

nom de répertoire



-r : ordre inverse mail courrier électronique

-s : chaîne de caractères qui sera le sujet du message -f : nom de la boîte à lettres -v : trace du mail jusqu'à sa délivrance

destinataire - <fichier>

man retourne le mode d'emploi de la commande s'il existe

nom de commande

mkdir création d'un répertoire nom de répertoire

more liste le contenu d'un fichier page par page

nom de fichier

mv déplace fichiers et répertoires

-i : demande confirmation source – destination

ps liste des processus BSD -a : processus détenus par les autres utilisateurs -u : nom du propriétaire du processus -x : processus sans terminal associé -l : description complète -t : terminal particulier

ps liste des processus Système V

-f : ou l : description plus ou moins longue -e : liste tous les processus -p : processus dont le numéro suit l'option p -t : processus attachés au terminal spécifié -u : processus appartenant au propriétaire dont le nom ou l'UID est donné

pwd retourne la référence absolue du répertoire courant

rlogin ouvrir une session vers une machine distante (sortie :exit)

-l : nom de login nom de machine

rm supprime la référence du fichier dans le répertoire

-f : force la commande sans s'occuper des droits -i : demande confirmation -r : destruction récursive

nom de fichier ou de répertoire

rmdir suppression d'un répertoire vide

nom de répertoire

sleep ne fait rien pendant n temps en



secondes secondes sort tri des lignes du fichier

suivant l'ordre ASCII -r : tri inverse -u : élimine les lignes identiques

fichier

tail liste les n dernières lignes du fichier

-n : nombre de lignes affichées (par défaut 10)

nom de fichier

talk,

ytalk permet de converser avec une machine distante

destination

tar archivage/désarchivage de fichiers

c : création de l'archive x : restauration de 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

archive -répertoire ou fichiers

telnet établir une connexion avec une machine distante (sortie : exit)

nom de machine

touch modifie les caractéristiques d'un fichier (option -a : par défaut) crée un fichier vide s'il n'existe pas déjà

-a : dernier accès seulement -m : dernière modification seulement

fichier

tty donne le nom du terminal uname donne le nom du système

d'exploitation -a : informations 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 destination après suppression des lignes identiques

-u : seules les lignes uniques sont recopiées

source destination

uudecod

e restitue un fichier binaire à partir du fichier ASCII créé avec uuencode

fichier

uuencod

e encode un fichier binaire en fichier ASCII

fichier - indication >fichier encodé

w aperçu de l'activité de la machine

-h : supprime l'entête -s : affichage restreint

nom d'utilisateur

whereis retourne le chemin complet d'accès à tous les répertoires contenant la commande

nom de la commande



which retourne le chemin complet d'accès à une commande

nom de la commande

who

(am i)

retourne le nom des utilisateurs qui ont ouvert une session

lycée polyvalent diderot département...

Documents