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

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

Introduction à l’utilisation du système Unix Yahya SLIMANI

1

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

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


2

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

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


3

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.

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

/ /users

/bin

/usr

/usr/bin

/usr/local

/users/I3

/users/IF3 /users/IF3/IF3A

/users/IF3/IF3B

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

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


4

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

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


5

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

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


6

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 … nomfichn

Archive les fichiers nomfich 1 à n dans l'archive nomarchive

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


7

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.

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


8

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

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


9

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--).

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

Pour un répertoire :

Si vous tapez umask 022, vous partez des droits maximum 777 et vous retranchez 022, on obtient donc 755, par défaut les fichiers auront comme droit 644 (-rwxr-xr-x).

Si vous tapez umask 244, vous partez des droits maximum 777 et vous retranchez 244, on obtient donc 533,

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


10

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 :

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


11

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)

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


12

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

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


13

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 à

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


14

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.

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


15

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.

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


16

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 .

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


17

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 LIpplpipnp bp 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

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


18

ê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

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


19

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é.

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


20

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

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


21

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

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


22

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.

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


23

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.

^[

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


24

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"

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


25

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

commande variable=commande

awk, gawk extraction d'informations d'un fichier

-F : '...' : redéfinition du séparateur de champ 'commande' : traitement à faire sur les chaînes extraites

nom de fichier

cal affiche le calendrier de l'année spécifiée en paramètre

mois année

cat imprime le contenu du fichier mentionné

nom de fichier

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

chemin d'accès à un répertoire

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

-R change les droits récursivement à partir du noeud (mode = ugo)

mode - nom de fichier ou de répertoire

compress compresse un fichier (voir gzip) -c : résultat sans fichier

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


26

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

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, "bye")

-n : supprime le retour chariot en fin de commande

elm courier é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 68020)

nom de fichier

find "répertoire"

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 identiques -n : avec numéros de lignes -c : nombre de comparaisons positives

chaîne de caractères - fichier

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)

-c : résultat sans modification du fichier

nom de fichier

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


27

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

source -f : écrasement d'un fichier compressé préexistant -v : taux de compression -d : force une décompression -9 : niveau maximum de compression

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 process

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

-s : création d'un lien symbolique


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 -r : ordre inverse

nom de répertoire

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

destinataire - <fichier

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


28

lettres -v : trace du mail jusqu'à sa délivrance

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


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 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 secondes temps en secondes

sort tri des lignes du fichier suivant l'ordre ASCII

-r : tri inverse -u : élimine les lignesidentiques

fichier

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


29

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 : m 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

unalias supprime un alias variable 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

uudecode restitue un fichier binaire à partir du fichier éditable (ASCII) créé avec uuencode

fichier

uuencode encode un fichier binaire en fichier éditable (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 nom de la commande

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


30

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 -print

Recherche récursivement et affiche le chemin menant au fichier "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"

gzip -c exemple.c > exemple.c.gz

Compresse le fichier "exemple.c" en conservant le fichier d'origine. Le fichier compressé est "exemple.c.gz" .

gunzip -c > exemple.c exemple.c.gz

Décompresse le fichier "exemple.c.gz" sans perdre le fichier 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

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


31

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 [email protected] Lance une conversation sur la machine "[email protected]"

tar cf sources.tar sources Crée une archive, de nom "sources.tar" , du contenu du répertoire "sources"

tar xvf sources.tar sources

Extrait le contenu d'une archive, de nom "sources.tar" , dans 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

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


32

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

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


33

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... "

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


34

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

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


35

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

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


36

-lt Less than : inférieur

-gt Greater than : supérieur

-le Less ou equal : inférieur ou égal

-ge Greater or equal : supérieur ou égal

tests sur les fichiers

La syntaxe est

test option nom_fichier

Option Rôle

-f Fichier normal

-d Un répertoire

-c Fichier en mode caractère

-b Fichier en mode bloc

-p Tube nommé (named pipe)

-r Autorisation en lecture

-w Autorisation en écriture

-x Autorisation en exécution

-s Fichier non vide (au moins un caractère)

-e Le fichier existe

-L Le fichier est un lien symbolique

-u Le fichier existe, SUID-Bit positionné

-g Le fichier existe SGID-Bit positionné

tests combinés par critères ET OU NON

On peut effectuer plusieurs tests avec une seule instruction.

Critère Action

-a AND, ET logique

-o OR, OU logique

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


37

! NOT, NON logique

(...) groupement des combinaisons. Les parenthèses doivent être vérouillées $...$.

16. Instruction if ... then ... else

La structure if then else fi 'est une structure de contrôle conditionnelle.

If <commandes_condition> then <commandes exécutées si condition réalisé e> else <commandes exécutées si dernière condition pas réalisée> fi

17. Choix multiples case

La commande case … esac permet de vérifier le contenu d'une variable ou d'un résultat de manière multiple.

case Valeur in Modele1) Commandes ;; Modele2) Commandes ;; *) action_defaut ;; esac

Le modèle est soit un simple texte, soit composé de caractères spéciaux. Chaque bloc de commandes lié au modèle doit se terminer par deux points-virgules. Dès que le modèle est vérifié, le bloc de commandes correspondant est exécuté. L'étoile en dernière position (chaîne variable) est l'action par défaut si aucun critère n'est vérifié.

Caractère Rôle

* Chaîne variable (même vide)

? Un seul caractère

[...] Une plage de caractères

[!...] Négation de la plage de caractères

| OU logique

18. Les boucles

Elles permettent la répétition d'un bloc de commandes soit un nombre limité de fois, soit conditionnellement. Toutes les commandes à exécuter dans une boucle se placent entre les commandes do et done.

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


38

Boucle for

La boucle for ne se base pas sur une quelconque incrémentation de valeur mais sur une liste de valeurs, de fichiers ...

for var in liste do commandes à exécuter done

La liste représente un certain nombre d'éléments qui seront successivement attribuées à var.

Si on ne précise aucune liste à for, alors c'est la liste des paramètres soumise au script qui sera utilisée.

for params do echo "$params" done

Boucle while

La commande while permet une boucle conditionnelle « tant que ». Tant que la condition est réalisée, le bloc de commande est exécuté. On sort si la condition n'est plus valable.

while condition do commandes done

ou

while bloc d'instructions formant la condition do commandes done

Boucle until

La commande until permet une boucle conditionnelle « jusqu'à ». Dès que la condition est réalisée, on sort de la boucle.

until condition do commandes done

ou

until bloc d'instructions formant la condition do commandes done

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


39

19. La commande expr

La commande expr permet d'effectuer des calculs sur des valeurs numériques, des comparaisons, et de la recherche dans des chaînes de texte.

Opérateur Rôle

+ Addition

- Soustraction

* Multiplication

/ Division

% Modulo

!= Différent. Affiche 1 si différent, 0 sinon.

= Egal. Affiche 1 si égal, 0 sinon.

< inférieur. Affiche 1 si inférieur, 0 sinon.

> supérieur. Affiche 1 si supérieur, 0 sinon.

<= inférieur ou égal. Affiche 1 si inférieur ou égal, 0 sinon.

>= supérieur ou égal. Affiche 1 si supérieur ou égal, 0 sinon.

: Recherche dans une chaîne.

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

Documents