unix linux utilisation des systèmes - anakal.free.franakal.free.fr/ebooks d'informatique -...
Post on 16-Sep-2018
224 Views
Preview:
TRANSCRIPT
Unix Linux:
utilisation des systèmes
Table des matières
Introduction..........................................................................................................................3avantpropos......................................................................................................................3versions d'Unix – Linux......................................................................................................4composantes......................................................................................................................6syntaxe des commandes.................................................................................................10connexion ........................................................................................................................11à l'aide !............................................................................................................................20TP : premières commandes.............................................................................................22
Arborescence unix – Linux...............................................................................................24Arborescence des systèmes Unix...................................................................................26Les types de fichiers........................................................................................................27Un inode, c'est quoi ?......................................................................................................28manipuler les fichiers.......................................................................................................29Les caractères spéciaux..................................................................................................43TP : Manipuler les fichiers...............................................................................................46afficher du texte...............................................................................................................48TP : Afficher le contenu des fichiers................................................................................56gestion des liens..............................................................................................................57TP : les liens....................................................................................................................60
Commandes de recherches..............................................................................................61Les expressions régulières..............................................................................................61Rechercher dans les fichiers...........................................................................................64 Rechercher dans l'arborescence ...................................................................................65TP : recherches................................................................................................................67
Editer du texte....................................................................................................................68vi.......................................................................................................................................69D'autres commandes ......................................................................................................78TP : vi...............................................................................................................................79
Processus et mécanismes................................................................................................82Les processus .................................................................................................................82les processus en arrière plan ..........................................................................................86priorité des processus .....................................................................................................89redirections.......................................................................................................................91pipelines...........................................................................................................................93TP : Redirections d'entrées/sorties..................................................................................95
Version : 0.6 1
Les droits d'accès..............................................................................................................96Gestion des Permissions.................................................................................................96TP : permissions............................................................................................................103
Archivage et compressions............................................................................................104archiver ..........................................................................................................................105compresser ...................................................................................................................108TP : sauvegardes...........................................................................................................112
Le shell..............................................................................................................................113les variables....................................................................................................................116les alias...........................................................................................................................119le rappel de commandes et la gestion de l'historique....................................................122
Les scripts........................................................................................................................128Créer des scripts............................................................................................................128Les variables dans les scripts........................................................................................130Les caractères spéciaux du shell...................................................................................132Les commandes internes au shell.................................................................................134les conditions (test, if, case)...........................................................................................136TP : scripting utiliser les éléments base......................................................................139les boucles (while, until, for)...........................................................................................142TP : scripting les structures de contrôle......................................................................146les fonctions...................................................................................................................150TP : scripting les fonctions...........................................................................................152
Des commandes pour les scripts ..................................................................................154TP : scripting les commandes......................................................................................171
Plus loin avec les variables.............................................................................................172Substitution de variables................................................................................................172L'arithmétique entière.....................................................................................................174les variables de tableau.................................................................................................176TP : scripting scripts de synthèse................................................................................177
Index des commandes.....................................................................................................178
mémo de vi........................................................................................................................180
mémo sur les tests...........................................................................................................184
Version : 0.6 2
Introduction
avantpropos
Unix est le premier système d'exploitation à ne pas avoir été écrit par un constructeur. Il a de ce fait ouvert une brèche dans un domaine jusque là réservé.
Qu'est-ce qu'un système d'exploitation ?
Un système d'exploitation est un programme ou un ensemble de programmes qui est chargé de gérer les ressources matérielles (périphériques, mémoires…) d'un ordinateur et de les mettre à disposition des utilisateurs.
Quelques exemples :
Systèmes propriétaires
GCOS (Bull)
MPE (HP)
OS400 (IBM)
Système ouvert mono poste, mono tâche (micro)
DOS
Système ouvert multiposte, multitâche, multiplateforme
UNIX
IntroductionVersion : 0.6 3
versions d'Unix – Linux
Historique
1969 BELL Lab se retire du projet MULTICS. Cependant, l'équipe de Bell Lab continue ses recherches. Dans cette équipe, on trouve trois grands noms de l'histoire d'UNIX : Ken Thompson, Dennis Ritchie et Brian Kernighan.
1971 Première version d'Unix sur PDP 11/20 (Digital Equipment Corporation). Matériel qui dispose de 24 Ko de mémoire dont 16 Ko occupés par le noyau Unix, 8 Ko restant disponibles pour les utilisateurs. Capacité du disque dur : 512 Ko, taille maximale des fichiers 64 Ko.Le langage C est créé par Dennis Ritchie (reprise du langage B qui avait été écrit par Ken Thompson)
1973 Le noyau UNIX est réécrit en langage C par Ken Thompson. Les autres outils utilisés sous UNIX le seront également.Cette version d' Unix est connue sous le nom "Unix Timesharing System V4"L'université de Californie à Berkeley est la première à disposer d' Unix (avec sources)
1976 Sortie d'Unix Timesharing System V6 aux Bell Labs d'AT&T. Version qui sera disponible avec les sources pour une somme symbolique. Les universités sont les premières concernées. Bell Lab d'AT&T développent UUCP (Unix to Unix Copy Program). Premier protocole d'échange de données qui sera très utilisé avant l'arrivée de TCP/IP.1982 SunOs 1.0 (dont l'origine est 4.1BSD)
1983 Création du projet GNU
1986 AIX/RT 2
1989 SCO Unix System V /386
1990 SunOs 4.1.1 (Solaris 1)
1991 Naissance du noyau Linux (version 0.02) et distribution sur les premiers serveurs ftp
1992 Solaris 2.0 (Sparc)
1996 Sortie de l'environnement de bureau KDE
1997 sortie de l'environnement de bureau Gnome
1997 SCO Open Server 5.0.4
AIX 4.3
2003 Solaris 9 X86 PE
IntroductionVersion : 0.6 4
IntroductionVersion : 0.6 5
composantes
Le noyau UNIX
Le noyau UNIX est le programme principal du système. Il est généré à l'installation et relié en cas de modification de configuration matérielle.
Son rôle est de :
Gérer les ressources d'un ordinateur à travers la couche logicielle (périphériques, mémoire, ...)
Ordonnancer les différentes tâches (processus)
Mettre ces ressources à la disposition des utilisateurs
IntroductionVersion : 0.6 6
Matériel
Noyau
Shell
Outils
Applications
Dans un sens plus large, on entend souvent par noyau Unix le noyau luimême ainsi que l'ensemble des programmes essentiels tels que :
les interpréteurs de commandes (shell)
l'assembleur
les compilateurs
l'éditeur de lien
les éditeurs de texte (vi, ed, sed)
les services divers (communication, impression…)
Les langages SHELL
Une commande est une suite de mots séparés par des espaces. Le premier mot est le nom de la commande, les éventuels mots suivants sont les arguments. Sous Unix, cet ensemble de mots est analysé et interprété par un programme appelé shell (interpréteur de commandes).
Attention ! Le shell différencie les majuscules et les minuscules.
Un shell peut être assimilé à un langage. Assez complet, il permet la déclaration de structures de contrôles (alternatives et répétitives) et la manipulation de variables. Il est possible d'enregistrer des ensembles de commandes dans des fichiers de commandes appelés scripts shell. Les commandes ainsi créées disposent des mêmes caractéristiques que les commandes système.
Un shell traite les informations entrées ou à restituer sous forme de flux. Par défaut, le shell lit une commande à partir du flux nommé stdin (correspondant au clavier), écrit le résultat sur le flux stdout (l'écran) et écrit les éventuelles erreurs sur le flux stderr (également l'écran). Ces trois flux peuvent être remplacés par un fichier ordinaire ou un fichier spécial (périphérique) grâce au mécanisme de redirections d'entrée/sortie.
SHELL : Interpréteur de commandes (pas de notion de compilation). Interface entre utilisateurs et système.
Les 4 principaux shell :
• le sh (Bourne Shell) est d'origine AT&T
• le csh (C Shell) provient des unix BSD
• le ksh (Korn Shell) est issu d'AT&T
• le bash (Bourne Again Shell) est le shell du projet GNU
IntroductionVersion : 0.6 7
Le ksh est un surensemble du sh, il combine les avantages du csh avec la syntaxe du bourne shell.
Le csh a une syntaxe proche du langage C, mais les procédures csh ne s'exécutent pas sous sh et ksh.
Les principales autres différences :
• historique dans csh et ksh
• éditeur de ligne dans ksh
• les syntaxes des boucles diffèrent entre csh, ksh et sh :
csh : while … end
ksh et sh : while … do … done
• goto n'existe qu'en csh
• le mécanisme de substitution des variables ksh est plus élaboré
• l'arithmétique entière n'existe qu'en csh et ksh
• le mécanisme d'alias (abréviation de commande) n'existe qu'en csh et ksh
Particularité sur les systèmes d'exploitation AIX, le Bourneshell s'appelle bsh
COMMANDES, OUTILS, LANGAGES
* Langages et compilateurs intégrés :• C cc ccompiler• Cobol• Fortran 77• Pascal, Basic• Java javac
* Editeurs de texte :• vi• ed• sed
* Utilitaires de développement :• JDK 1.4.2.05 (Java Development Kit)
IntroductionVersion : 0.6 8
• make Compilation conditionnelle en prenant en compte les dépendances• sdb Symbolic Debugger . .Point d'arrêt
. Source et compilé en parallèle
. variables
* Outils de traitement de texte et génération de document
* Outils de réalisation de compilateurs : yacc, lex
* Communication entre utilisateurs :• mail• write• uucp Unix to Unix Communication Protocol• tcp/ip avec FTP File Transfer Protocol
* Outils graphiques
* Outils d'administration• scoadmin sur version SCO Unix• smit sur version AIX• smc sur version SOLARIS
Modularité
La modification de la configuration n'implique pas la réinstallation du système.
Multipostes
Plusieurs utilisateurs peuvent accéder simultanément à un système Unix.
Multitâches
Un utilisateur peut lancer plusieurs traitements qui s'exécutent en parallèle
Notion de user et de group
Pour accéder à un système Unix, un utilisateur devra disposer d'un nom de user. Un user est toujours membre d'au moins un groupe (group). L'utilisateur root est l'administrateur du système.
Les fichiers
Les fichiers Unix se répartissent en trois grand types :• les fichiers ordinaires, qui sont de simples suites d'octets non structurées• les fichiers répertoires, contenant les références d'autres fichiers• les fichiers spéciaux (périphériques d'entrée/sortie, mémoire, tubes nommés)
IntroductionVersion : 0.6 9
syntaxe des commandes
L'utilisation de la ligne de commande impose le respect de certaines règles, sans lesquels il n'est pas possible d'utiliser correctement le système.
La manière habituelle de lancer une commande est de taper la commande suivie des options, puis des arguments
• La commande doit toujours être située en premier dans l'instruction.• Les options permettent de modifier le comportement par défaut de la commande.
Elles sont généralement précédés du signe moins – ou plus +. elles peuvent être séparées par des espaces ou regroupées ensemble.
• les arguments sont les éléments utiles à la commande, sinon indispensables. Certaines commandes n'ont pas besoin d'arguments, alors que pour d'autre les arguments seront obligatoires.
• La commande, les options et les arguments doivent etre séparés par un espace
commande options arguments
ex :
who commande simple sans options ni arguments
ls /etc commande avec un argument
head n 5 /etc/nsswitch.conf commande avec une option et un argument
cp /tmp/fic1 $HOME commande avec deux arguments
tar xzvf archive.tar.gz commande avec quatre options (sans signe + ou ) et un argument
ATTENTION : les systèmes unix respectent la casse, il faudra prendre garde à respecter les minuscules et les majuscules.
IntroductionVersion : 0.6 10
connexion
Connexion
Pour se connecter à un système Unix, un utilisateur doit disposer d'un nom de user, auquel est généralement associé un mot de passe.
Quand un terminal permet la connexion d'un utilisateur, il propose une invite de type :
A cette invite, il faut entrer le nom de user pour provoquer l'affichage de l'invite de saisie du mot de passe :
Sur Solaris :
Sur AIX :
Le système vérifie l'existence du user et la cohérence du mot de passe avant d'afficher, sur certaines versions d'Unix la valeur de la variable TERM, le message de bienvenue (stocké dans le fichier /etc/motd) et l'invite du shell de connexion :
IntroductionVersion : 0.6 11
Si la connexion ne peut être établie (mot de passe incorrect), et après un certain nombre d'essais, le compte utilisateur sera verrouillé. Celuici devra alors demander à l'administrateur d'intervenir.
Déconnexion
La commande de déconnexion (fermeture de session) dépend de l'environnement shell de l'utilisateur.
Bourne shell $ CTRL + D
Korn shell n$ exit
C shell n% logout
IntroductionVersion : 0.6 12
tty affiche le nom du terminal
Syntaxe : tty
Sur AIX
Sur SOLARIS l teste si la ligne du terminal est une ligne synchrone
IntroductionVersion : 0.6 13
logname Affiche le nom du user de connexion
Syntaxe : logname
Commande simple. Pas de paramètre.
id affiche les noms et identificateurs des groupes et du user
Syntaxe : id
Sur Solaris
Sur AIX
IntroductionVersion : 0.6 14
who am i qui suisje ?
Syntaxe : who am i
Sur Solaris
Sur AIX
IntroductionVersion : 0.6 15
who informations sur les users connectés
Syntaxe : who [ H q T u ]
H Heading, affichage entête de colonnes
q Liste abrégée, noms et nombre d'utilisateurs
T Indique par + ou – s'il est possible d'écrire sur le terminal
u Informations complémentaires sur les différentes connexions
Sans option, la commande who affiche le nom user, le terminal et la date et heure de connexion.
Sur Solaris
IntroductionVersion : 0.6 16
passwd changement du mot de passe
Syntaxe : passwd [ s ]
Sans option, la commande passwd permet de modifier le mot de passe.
Sur Solaris, non autorisé par défaut, nécessite un droit d'utilisation positionné par l'administrateur
Sur AIX s permet de changer le shell de connexion
IntroductionVersion : 0.6 17
date Affichage de la date et heure
Syntaxe : date [OPTION]... [+FORMAT]
date [ u | utc | universal ] [ MMDDhhmm [ [CC] YY ] [.ss] ]
mmdd numéro du mois et du jour
HHMM heure minutes
cc yy numéro du siècle et de l'année
+format format de visualisation de la date, composé de texte et de différents paramètres identifiés par le caractère %
%a nom du jour abrégé%A nom du jour%b nom du mois abrégé%B nom du mois%d numéro du jour (01 à 31)%D date sous forme mm/dd/yy%j numéro du jour dans l'année%m numéro du mois%U numéro de la semaine%w numéro du jour dans la semaine (0 = dimanche)%y année sur 2 chiffres%Y année sur 4 chiffres (siècle inclus)
%H heure de 00 à 23%I heure de 01 à 12%M minutes de 00 à 59%S secondes de 00 à 59%T heure (24) sous forme HH:MM:SS
%n insertion nouvelle ligne%t insertion tabulation
Si aucun argument n'est passé à la commande date, un simple affichage est effectué.
date "+%nBonjour, nous sommes le %A %B %Y.%nIl est %Hh%M%n"
ATTENTION : la commande date utilisée par root permet de modifier la date et l'heure du serveur.
IntroductionVersion : 0.6 18
cal Génération de calendrier
Syntaxe : cal [ [ mois ] année ]
mois numéro du mois
année numéro de l'année siècle inclus
Sur Solaris et AIX :
Sans argument, la commande génère le calendrier du mois courant.
IntroductionVersion : 0.6 19
à l'aide !
Les commandes unix peuvent comporter un grand nombre d'options, qui ne sont de plus pas toujours facile à comprendre. Il est donc très important sur les sytèmes Unix d'accéder à de la documentation aisément.
Localement
la commande man est le premier outil utilisé pour obtenir de l'aide. Les administrateurs les plus chevronnés utilisent tous les jours la commande man qui est une véritable mine d'or de l'aide en ligne.
Les outils en ligne de commandes possèdent généralement des options permettant d'afficher une aide rapide. Générelement, l'option help permet l'accès à un récapitulatif des options possibles.
passwd --help
Les outils graphiques quand à eux possèdent en général leur documentation, en passant par le menu aide ou en appuyant sur la touche F1.
Sur Internet
Les distributions Linux bénéficient de l'activité des nombreuses communautés d'utilisateurs, et la consultation des sites des éditeurs est souvent très riche d'enseignements. Les forums permettent de résoudre nombre de questions techniques et les tutoriels permetttent d'en savoir plus sur un sujet donné.
www.tldp.org The Linux Documentation Project
traduc.org Un site de traduction en français des nombreuses documentations sur Linux
docs.sun.com Documentation officielle pour Solaris (SUN)
docs.hp.com Documentation officielle pour HPUX (HP)
publibn.boulder.ibm.com/cgibin/ds_rslt#1 Documentation officielle pour AIX (IBM)
IntroductionVersion : 0.6 20
man
La commande man permet d'accéder rapidement à l'aide en ligne. Il est cependant bien souvent nécéssaire de maîtriser la langue de shakespeare car les pages de man sont rarement ou imparfaitement traduites. Les distributions Linux sont en général mieux loties en terme de traduction grâce à ses nombreuses communautés qui fournissent quotidiennement un effort de traduction. Il faudra cependant toujours prendre garde aux traductions imparfaites qui peuvent altérer le texte original.
Les pages de man sont scindées en différentes sections. Si aucune section n'est invoquée, man recherchera dans les sections selon un ordre prédéterminé, et s'arretera dès qu'une occurence sera trouvée. Si une section est passée en option, la recherche se fera uniquement dans la section trouvée
Exemple de sections (sur un système Linux Ubuntu 9.04) 1 : Programmes exécutables ou commandes de l’interpréteur de commandes (shell) 2 : Appels système (Fonctions fournies par le noyau) 3 : Appels de bibliothèque (fonctions fournies par les bibliothèques des programmes) 4 : Fichiers spéciaux (situés généralement dans /dev) 5 : Formats des fichiers et conventions. Par exemple /etc/passwd 6 : Jeux 7 : Divers (y compris les macropaquets et les conventions). Par ex man(7), groff(7) 8 : Commandes de gestion du système (généralement réservées à root) 9 : Sousprogrammes du noyau [hors standard].
Obtenir de l'aide sur la commande passwd :
$ man passwd
Obtenir de l'aide sur le fichier /etc/passwd (ici sous Linux) :
$ man -s 5 passwd
Obtenir de l'aide sur les pages de man
$ man man
Si l'on ne connait pas la commande dont on souhaite l'aide, il est possible de taper un mot clé. par exemple, pour connaître les commandes relatives au motclé password :
$ man -k password
IntroductionVersion : 0.6 21
TP : premières commandes
1. Changer votre mot de passe, fermer la session et reconnectezvous pour vérifier le changement de mot de passe :
..................................................................................................................................................
2. Depuis quand êtes vous connecté : ..................................................................................................................................................
3. Quels sont les utilisateurs qui travaillent sur le serveur : ..................................................................................................................................................
4. Quel est le temps d'inactivité des utilisateurs connectés :..................................................................................................................................................
5. Quel est le numéro de processus de votre session :..................................................................................................................................................
6. Afficher vos identifiants d'utilisateur et de groupes (UID et GID) :..................................................................................................................................................
7. Quels sont vos groupes d'appartenance :..................................................................................................................................................
8. A l'invite de commande, afficher juste l'heure :..................................................................................................................................................
9. A l'invite afficher juste la date suivant l'exemple lundi 24 septembre 2009:..................................................................................................................................................
IntroductionVersion : 0.6 22
10. Commande cal avec et sans argument :
a) Afficher le calendrier de Janvier 1900 puis celui de toute l'année :.....................................................................................................................................
.....................................................................................................................................
b) Afficher le calendrier du mois de Janvier de l'année courante :.....................................................................................................................................
c) Afficher le calendrier de septembre 1752, avezvous une idée sur la particularité de ce mois ?
.....................................................................................................................................
IntroductionVersion : 0.6 23
Arborescence unix – Linux
La structure du système de fichiers (FS) est arborescente (Imbrication de répertoire), le chemin d'accès à un fichier permet de spécifier la position exacte de ce fichier dans l'arborescence.
Chemin absolu vs chemin relatif
Lorsque le chemin commence par le caractère /, il est donné depuis la racine : on parle alors de chemin absolu, sinon, le chemin est donné à partir du répertoire courant : on parle dans ce cas de chemin relatif.
Si le chemin d'accès (absolu ou relatif) à un fichier est composé d'un ou plusieurs répertoires, le caractère / sépare les différents niveaux.
Répertoire père et répertoire courant
Chaque répertoire, en dehors de la racine, contient au minimum deux sousrépertoires particuliers :
.. le répertoire père
. le répertoire courant
Il peut être judicieux, dans certains cas, de remonter dans l'arborescence plutôt que de descendre. Dans ce cas, le nom de chemin contiendra ".." pour se positionner dans le répertoire de niveau immédiatement supérieur à celui dans lequel on est positionné.
Arborescence unix – LinuxVersion : 0.6 24
Dans l'arborescence cidessus, le répertoire exo contient un fichier b1, et le répertoire prog un fichier ediuser.
Si la position courante dans l'arborescence est le répertoire marie, le chemin d'accès au fichier b1 pourra être l'un des suivants :
/home/marie/exo/b1exo/b1
De même, le chemin d'accès au fichier ediuser pourra être :/home/marie/source/prog/ediusersource/prog/ediuser
Arborescence unix – LinuxVersion : 0.6 25
/
home
marie
exo source
prog util divers
Arborescence des systèmes Unix
bin : Commandes de base UNIX
dev : fichiers de périphériques
devices : Noms physiques des périphériques (Solaris)
etc : Fichiers de configuration du système
export : Utilisé pour le partage de systèmes de fichiers
home : Répertoire d'accueil des utilisateurs.
kernel : Modules du noyau nécessaires au processus de démarrage (Solaris)
lost+found : Fichiers récupérés par la cde fsck
mnt : Répertoire d'accueil des arborescences diverses
opt : Répertoire pour les applications tierces.
platform : Modules du noyau propres à la plateforme (Solaris)
sbin : Exécutables essentiels au processus de démarrage
tmp : Fichiers temporaires
usr : Programmes, bibliothèques, scripts pour les users
var : Fichiers de taille variable (temporaires, journaux, état)
Arborescence unix – LinuxVersion : 0.6 26
/
Les types de fichiers
Sous Unix, tout est Fichier
L'utilisateur perçoit les fichiers comme rangés dans des répertoires, euxmême classés dans d'autres répertoires, cela nous permet d'avoir une vision hiérarchique de l'organisation des fichiers et d'en faciliter la gestion.
Le système d'exploitation en a lui une toute autre vision. Pour lui, un fichier est un ensemble de données écrites sur le support de stockage, sans aucune notion hiérarchique, mais accessible par un inode qui possède des pointeurs vers ses données.
Pour Unix, un écran, la souris ou un disque dur sont représentés par des fichiers. Même les processus sont des fichiers.
Il existe quatre type de fichiers :
Fichiers ordinaires
Les fichiers ordinaires sont tous les fichiers dans le sens usuel du terme, ainsi, les textes, les scripts, les commandes sont des fichiers ordinaires
Répertoires
Le répertoires est pour le système un type de fichier particulier, contenant les références permettant d'accéder à des fichiers.
Fichiers spéciaux
Les fichiers spéciaux désignent les périphériques matériel de la machine, ils sont subdivisés en deux parties :
• les fichiers spéciaux en mode bloc, qui concernent les périphériques de stockage
• les fichiers spéciaux en mode charactère ou raw, qui eux représentent les périphériques d'entrées/sorties comme le clavier, la souris ou l'écran.
Liens symboliques
Un lien symbolique est un fichier spécial qui permet de pointer vers un nom de fichier. Ils permettent de simplifier les accès aux fichiers et répertoire et à maintenir la compatibilité entre systèmes Unix
Arborescence unix – LinuxVersion : 0.6 27
Un inode, c'est quoi ?
Les inodes contiennent des informations concernant les fichiers stockés sur les systèmes de fichiers. Les inodes sont référencés par des numéro.
Lorsqu'un utilisateur tente d'accéder à un fichier, l'inode du fichier est lu. Si les permissions autorisent l'accès au fichier, les données seront accessibles grâce aux pointeurs.
L'inode contient des informations telles que :• l'identifiant de l'utilisateur propriétaire du fichier;
• l'identifiant du groupe propriétaire du fichier;
• les permissions d'accès au fichier;
• les dates de dernière modification, de dernier accès et de dernière modification de l'inode;
• la taille du fichier;
• le nombre de lien du fichier (nous y reviendrons);
• le type de fichier;
• les pointeurs qui permettent d'accéder physiquement aux données du fichier.
ATTENTION : L'inode ne contient pas le nom du fichier
Arborescence unix – LinuxVersion : 0.6 28
.
..fichier.txt (12345)
rep1
propriétairegroupe
permissionsnombre de liens
datestaille
pointeurs
12345
manipuler les fichiers
La gestion des fichiers implique de respecter des règles dans la désignation des fichiers :
Pas de notion d'extension
Les noyaux des systèmes Unix ne gère pas la notion d'extensions de fichier comme Windows. Aussi, le fait d'appeler un fichier fic.txt ou programme.exe n'indique en rien au système que nous avons à faire à un fichier texte ou un à une application. L'utilisation des extensions sera donc uniquement utile à l'utilisateur, pour reconnaître les types de fichiers.
Caractères interdits
hormis le slash / qui est le séparateur dans l'arborescence, il n'y a pas de caractères interdits pour le nommage des fichiers. Il faudra malgré tout prendre garde aux caractères spéciaux qui peuvent être difficiles à manipuler.
Gestion de la casse
Attention à la casse, fichier.txt, Fichier.txt et FICHIER.TXT sont trois fichiers différents.
les fichiers cachés
Les fichiers qui commencent par un point "." sont considérés comme "cachés" par certaines commandes et par les gestionnnaires de fichiers graphiques. Les fichiers de configuration des environnements utilisateurs contiennent souvent de tels fichiers.
Longueur des noms de fichiers
Les noms de fichiers peuvent atteindre 255 caractères.
Arborescence unix – LinuxVersion : 0.6 29
pwd affiche le chemin du répertoire courant
Syntaxe : pwd
La commande pwd affiche le répertoire courant, c'est à dire le répertoire dans lequel l'utilisateur se trouve au moment de l'exécution de la commande.
C'est une des rares commandes sans options ni arguments.
$ pwd
/home/beni
Arborescence unix – LinuxVersion : 0.6 30
cd changement de répertoire
Syntaxe : cd [ chemin ]
chemin Le chemin du répertoire dans lequel on veut se positionner.
Ce chemin peut être donné en absolu ou en relatif.
Sans indication du chemin, la commande cd permet de se positionner automatiquement dans le répertoire de connexion.
Arborescence unix – LinuxVersion : 0.6 31
mkdir création de répertoire
Syntaxe : mkdir [ m mode ] [ p ] nomrep
m mode mode est une valeur numérique permettant de fixer les permissions du répertoire si nécessaire
p création des répertoires parents inexistants (si nomrep est un chemin)
nomrep nom du répertoire ou du chemin à créer
Arborescence unix – LinuxVersion : 0.6 32
rmdir suppression de répertoire
Syntaxe : rmdir [ p ] nomrep
p suppression des répertoires parents uniquement s'ils sont vides
nomrep nom du répertoire ou du chemin à supprimer
Arborescence unix – LinuxVersion : 0.6 33
ls liste de fichiers
Syntaxe : ls [ aACdFilmrRstux ] [ répertoire | fichier(s) … ]
a liste de tous les fichiers, y compris les fichiers dont le nom commence par "." répertoires père et courant inclus
A liste de tous les fichiers, y compris les fichiers dont le nom commence par "." sauf les répertoires père et courant
C présentation en colonnes avec tri vertical
d affiche le nom des répertoires de façon identique au nom de fichier
F présentation en colonnes avec tri vertical, certains noms sont suivis d'un caractère indiquant le type : / pour un répertoire, * pour un fichier exécutable et @ pour un lien symbolique
i affiche le numéro d'inode
l affichage au format long : type et permissions, nombre de liens physiques, owner, group, taille (en octets) pour un fichier, date de dernière modification et nom du fichier ou répertoire
m présentation sous forme de liste de noms séparés les uns des autres par ","
r affichage des noms avec tri inversé
R liste récursive de tous les sous répertoires
s affiche la taille en blocs des fichiers (1 bloc = 512 octets)
t tri par date de dernière modification
u tri par date de dernier accès
x présentation en colonnes avec tri horizontal
rép nom du répertoire dont on souhaite visualiser le contenu
fichier nom du ou des fichiers concernés par la liste
La commande ls permet de lister les noms (et caractéristiques) d'un fichier ou d'un ensemble de fichiers. Par défaut, les noms de fichiers sont affichés par ordre alphabétique.
Les arguments répertoire et fichier peuvent contenir des métacaractères. Si aucun argument n'est spécifié à la commande ls, cette commande liste le contenu du répertoire courant.
Arborescence unix – LinuxVersion : 0.6 34
Sur Solaris et AIX, ls et ls –C donnent le même résultat d'affichage, pour obtenir un affichage sur une seule colonne, il faut associer l'option 1 (un) à la commande ls
Arborescence unix – LinuxVersion : 0.6 35
# ls -l /etc
...
-rw-r--r-- 1 root root 1467 2010-02-25 23:55 passwd
-rw------- 1 root root 1521 2010-02-25 16:15 passwd-
drwxr-xr-x 4 root root 4096 2009-10-30 13:56 perl
drwxr-xr-x 5 root root 4096 2009-10-30 16:20 pm
-rw-r--r-- 1 root root 7649 2009-10-30 16:24 pnm2ppa.conf
drwxr-xr-x 4 root root 4096 2009-10-30 16:17 polkit-1
-rw-r--r-- 1 root root 350 2009-10-30 14:13 popularity-contest.conf
drwxr-xr-x 8 root dip 4096 2009-10-30 14:13 ppp
lrwxrwxrwx 1 root root 22 2009-11-12 16:41 printcap -> /var/run/cups/printcap
-rw-r--r-- 1 root root 497 2009-10-30 13:56 profile
drwxr-xr-x 2 root root 4096 2009-10-20 02:04 profile.d
-rw-r--r-- 1 root root 2626 2009-09-15 14:02 protocols
drwxr-xr-x 2 root root 4096 2010-02-16 16:58 pulse
drwxr-xr-x 2 root root 4096 2010-03-01 12:52 purple
drwxr-xr-x 2 root root 4096 2009-10-30 13:57 python
drwxr-xr-x 2 root root 4096 2010-01-05 18:01 python2.6
1 Ensemble de 10 caractères indiquant le type du fichier (c1) et les permissions sur ce fichier pour le user (c234), le groupe (c567) et les autres (c8910).
type de fichier fichier ordinaired répertoireb périphérique de type blocc périphérique de type caractèrel lien symboliquep tube nommé (FIFO)
permissions pas de droit toutes positionsr droit de lecture première positionw droit d'écriture deuxième positionx droit d'exécution troisième position
2 Nombre de liens physiques pour un fichier, nombre de sousrépertoires (+ 2) pour un répertoire
3 Nom du user propriétaire4 Nom du groupe propriétaire
Arborescence unix – LinuxVersion : 0.6 36
1 2 3 4 5 6 7
5 Taille en octets pour un fichier6 Heure et/ou date de dernière modification7 Nom du fichier ou du répertoire
Arborescence unix – LinuxVersion : 0.6 37
touch modifier les dates de fichiers
Si les systèmes Windows ou Netware s'appuient sur un attribut "archive" pour réaliser des sauvegardes différentielles ou incrémentales, les systèmes Unix ne possèdent pas d'attribut permettant de savoir si un fichier doit être sauvegardé ou non.
Pour cela on utilise en général la date de dernière modification du fichier. Lors d'une sauvegarde complète ou incrémentale, il suffit d'utiliser un fichier de référence horodaté à une date voulue, et d'effectuer la sauvegarde des fichiers en fonction de la date de référence.
Accessoirement la commande touch crée un fichier lorsque le fichier mentionné n'existe pas, ce qui est très pratique pour réaliser des exercices sur des fichiers.
Nous ne rentrerons pas dans le détail de la commande touch, car la principale utilisation que nous en auront étant la création de fichiers vides.
Modifier la date de modification du fichier, s'il n'existe pas créer le fichier (il sera vide).
$ touch test.fic
Noter que la date de dernier accès, ainsi que la date de changement de l'inode sont également modifiés lors d'une modification du contenu du fichier.
Vérifier les changements
$ ls -l test.fic
Une autre commande, plus riche mais pas toujours présente :
$ stat test.fic
Arborescence unix – LinuxVersion : 0.6 38
cp copie de fichiers
Syntaxe : cp nomfichO nomfichC
cp nomfichO1 [ nomfichOn ] nomrep
nomfichO fichier origine ou nom du fichier à copier
nomfichC fichier cible ou nom du fichier à générer
nomfichO1 … n fichier(s) à copier
nomrep répertoire dans lequel les fichiers précédemment nommés doivent être copiés
Les noms de fichiers et répertoires peuvent être des chemins absolus ou relatifs.
Arborescence unix – LinuxVersion : 0.6 39
rm suppression de fichiers ou de répertoire
Syntaxe : rm [ fir ] nomfich [ …]
r Suppression récursive. Appliquée à un répertoire, supprime le répertoire et son contenu, y compris tous les répertoires de niveau inférieur.
i Demande de message de confirmation de suppression pour chaque fichier
f Supprime le message de confirmation automatique si le user (propriétaire) n'a pas le droit d'écriture sur le fichier
Fin des options ou aucune option, utilisé si l'on souhaite supprimer un fichier dont le nom est –f ou –r par exemple.
nomfich Nom du fichier ou du répertoire à supprimer. Ce nom peut être générique
Arborescence unix – LinuxVersion : 0.6 40
mv déplacer ou renommer un fichier
Syntaxe : mv nomfichO nomfichD
mv nomrepO nomrepD
mv nomfichO1 [ nomfichOn ] nomrep
nomfichO fichier origine ou nom du fichier à déplacer ou à renommer
nomfichD nouveau nom de fichier
nomrepO nom du répertoire à déplacer ou à renommer
nomrepD nouveau nom du répertoire
nomfichO1 … n nom(s) de fichier(s) à déplacer
nomrep nom du répertoire dans lequel les fichiers doivent être placés
Les noms de fichiers et répertoires peuvent être des chemins absolus ou relatifs.
Arborescence unix – LinuxVersion : 0.6 41
file détermine le type de fichier
Syntaxe : file nomfich
nomficnom du fichier. Ce nom peut être générique
Arborescence unix – LinuxVersion : 0.6 42
Les caractères spéciaux
Les commandes de gestion de fichiers autorisent l'utilisation de métacaractères qui peuvent être combinés avec des caractères dits spéciaux.
Métacaractères
Les métacaractères sont des caractères de substitution utilisés pour définir des noms génériques. Ces caractères sont les suivants :
* 0 à n caractères
? 1 caractère quelconque et un seul
[ liste car.] 1 seul caractère parmi ceux de la liste entre [ ]
[car. Début car. Fin] 1 seul caractère compris dans l'intervalle de caractères, bornes incluses
[ ! … ] négation, 1 seul caractère autre que ceux spécifiés entre [ ]
Exemple :
*.c tous les noms qui se terminent par " .c "
ab?h tous les noms de quatre caractères qui commencent par "ab" et se terminent par "h", la valeur du troisième caractère est quelconque
ab[bhmp]15 tous les noms de cinq caractères qui commencent par "ab" et se terminent par "15", la valeur du troisième caractère est "b" ou "h" ou "m" ou "p"
ab[ah15]2 tous les noms de quatre caractères qui commencent par "ab" et se terminent par "2", la valeur du troisième caractère doit être comprise entre "a" et "h" ou entre "1" et "5"
ab[!aei]h tous les noms de quatre caractères qui commencent par "ab" et se terminent par "h" dont le troisième caractère n'est pas "a" ou "e" ou "i"
[ A Z ] 1 caractère parmi les lettres majuscules
[ A Z a z] 1 caractère parmi toutes les lettres minuscules et majuscules
Arborescence unix – LinuxVersion : 0.6 43
Les expressions complexes
En plus des métacaractères, les environnements ksh et bash disposent d'expressions complexes permettant d'étendre les possibilités des remplacements de caractères :
?( … ) 0 à 1 fois l'expression entre parenthèses.
*( … ) 0 à n fois l'expression entre parenthèses.
+( … ) 1 à n fois l'expression entre parenthèses.
@( … ) 1 fois l'expression entre parenthèses.
!( … ) l'expression entre parenthèses ne sera pas présente
Nota : en bash, il faudra s'assurer que l'utilisation des expressions complexes est activée grâce à l'option extglob :
$ shopt
$ shopt -s extglob
Arborescence unix – LinuxVersion : 0.6 44
Caractères spéciaux
En plus des métacaractères, le shell interprète de façon particulières certains caractères appelés caractères spéciaux.
Ces caractères sont les suivants :
' ' Simple quote banalisent tous les caractères situés entre les simple quote
echo 'prix : 15$50'
" " double quote banalise tous les caractères situés entre les doubles quotes sauf $ ` \ (dollar backquote et antislash)
echo "aujourd'hui, vous êtes connecté sur $HOSTNAME"
\ antislash banalise le caractère suivant
$ dollar permet d'afficher le contenu d'une variable
`….` back quote permet l'utilisation du résultat d'une commande
Un équivalent est : $(.....)
Arborescence unix – LinuxVersion : 0.6 45
TP : Manipuler les fichiers
1. Où êtesvous positionnés dans l'arborescence :..................................................................................................................................................
2. Existetil des fichiers et des répertoires ?..................................................................................................................................................
3. Créer un fichier vide appelé MonPremierFichier :..................................................................................................................................................
4. Afficher les permissions et le propriétaire attribués à ce fichier : ..................................................................................................................................................
5. Afficher les fichier se terminant par l'extension .conf dans le répertoire /etc : ..................................................................................................................................................
6. Affichez les caractéristiques détaillées du répertoire /tmp (pas son contenu), que remarquez vous de particulier ?
..................................................................................................................................................
7. Affichez les fichiers et répertoires (pas leur contenu) dont le nom commence par a, b, c ou d du répertoire /etc :
..................................................................................................................................................
Arborescence unix – LinuxVersion : 0.6 46
8. Créez l'arborescence suivante dans votre répertoire de travail ($HOME) :
$HOME
bin Tp
Bourne KornShell Divers
Sources lib Executables
..................................................................................................................................................
9. Positionnezvous dans le répertoire Sources. Dans ce répertoire, créez un fichier qui comporte, dans son nom, un astérisque :
..................................................................................................................................................
..................................................................................................................................................
10. Sans vous déplacez dans l’arborescence, essayez de supprimer le répertoire Sources . Que constatezvous ?
..................................................................................................................................................
11. Supprimer le répertoire Divers en utilisant la commande rm : ..................................................................................................................................................
Arborescence unix – LinuxVersion : 0.6 47
afficher du texte
cat affichage et concaténation de fichiers
Syntaxe : cat [ options ] [ fichier … ]
n afficher les numéros de lignes (identique à la commande nl)
b affiche les numéros de lignes nonvides
s n'affiche pas les lignes vides consécutives
fichier nom (éventuellement générique) du ou des fichiers
Si plusieurs fichiers sont concernés par la commande cat, le contenu de chacun d'eux sera concaténé.
Si aucun fichier n'est spécifié, la commande cat va rechercher son flux d'entrée au clavier et ne s'exécutera qu'à la réception de fin de flux d'entrée : CTRL D
Arborescence unix – LinuxVersion : 0.6 48
more Visualisation avec pause à chaque page écran
Syntaxe : more [ options ] [ nblig ] [ nomfichier ]
d Affiche un message d’aide en bas de page
[Hit space to continue, Del to abort]
s Ne conserve qu’une ligne blanche si plusieurs lignes blanches consécutives
nblig nblig définit le nombre de lignes de la page de visualisation
nomfichier Nom du fichier à traiter. Ce nom peut être générique. A défaut de nom, la commande more travaille sur le flux d’entrée
A ce stade de l’affichage, il est possible d’exécuter un certain nombre de commandes. Parmi ces commandes, il en est une à retenir : h ou ? qui permet d’obtenir l’aide en ligne des sous commandes de more.
La commande v permet quant à elle de faire appel à l’éditeur vi.
Arborescence unix – LinuxVersion : 0.6 49
less Visualisation avec pause à chaque page écran
Similaire dans son principe à la commande more, less, commande très utilisée sur les environnements Linux, en améliore le fonctionnement.
Syntaxe :
less [options] fichier1 [fichier2]
La commande less offre l'avantage de ne pas quitter la lecture du fichier lorsque le curseur arrive à la fin du fichier. D'autre part, la recherche de chaînes de caractères est plus lisible.
Quelques commandes à effectuer lors de la lecture
h : accéder à l'aide
q : quitter le fichier ou l'aide
/Rigel : rechercher la chaîne Rigel
n pour continuer la recherche vers le bas
N pour continuer la recherche vers le haut
G : positionne en fin de fichier
g : positionne en début de fichier
Arborescence unix – LinuxVersion : 0.6 50
head Affichage des premières lignes d’un fichier
Syntaxe : head [ nnbl ] [ nomfichier ]
nnbl Nombre de lignes à afficher (10 par défaut)
nomfichier Nom du fichier à traiter. Ce nom peut être générique.
A défaut de nom, la commande travaille sur le flux d’entrée
Sur AIX :
cnbc Nombre de caractères à afficher (tous par défaut)
Arborescence unix – LinuxVersion : 0.6 51
tail Affichage des dernières lignes d’un fichier
Syntaxe : tail [nb ] [ nomfichier ]
Par défaut, tail affiche les 10 dernières lignes du fichier
nb Position, de début d'affichage, à partir de la fin du fichier
+nb Position, de début d'affichage, à partir du début du fichier
nomfichier Nom du fichier à traiter. Ce nom peut être générique.
A défaut de nom, la commande travaille sur le flux d’entrée
Affichage des 15 dernières lignes du fichier cal2002 :
Affichage des dernières lignes du fichier cal2002 à partir de la ligne 40 :
Arborescence unix – LinuxVersion : 0.6 52
wc compte les lignes, mots et caractères de fichiers
Syntaxe : wc [ lwc ] nomfich [ …]
l affiche le nombre de lignes
w affiche le nombre de mots
c affiche le nombre de caractères
nomficnom du fichier. Ce nom peut être générique
Sans option, la commande wc affiche les trois informations.
Arborescence unix – LinuxVersion : 0.6 53
cmp comparaison de fichiers
Syntaxe : cmp nomfich1 nomfich2
nomfich1 2 noms des fichiers à comparer.
La commande cmp indique la position (caractère, ligne) de la 1ère différence.
Arborescence unix – LinuxVersion : 0.6 54
diff liste des différences entre deux fichiers
Syntaxe : diff nomfich1 nomfich2
nomfich1 2 noms des fichiers à comparer.
Actions : a pour append
c pour change
d pour delete
dans l'un ou l'autre des deux fichiers comparés.
< les lignes précédées de < concernent le premier fichier
> les lignes précédées de > concernent le second fichier
Arborescence unix – LinuxVersion : 0.6 55
TP : Afficher le contenu des fichiers
1. Créer un nouveau fichier appelé MonDeuxiemeFichier à l'aide de la commande cat, dont le contenu sera :
Conseil :
pour bien utiliser la ligne de commande
faire des étirements de doigts avant chaque repas...................................................................................................................................................
2. Créer un fichier MonTroisiemeFichier avec cat, contenant le texte :
Ne pas oublier de lire au moins 4 pages de man
avant d'aller se coucher..................................................................................................................................................
3. Créer un nouveau fichier fichier2+3 par concaténation des deux fichiers qui viennent d'être créés :
..................................................................................................................................................
4. Combien de comptes d'utilisateurs ont été créés sur la machine, sachant que le fichier contenant les utilisateurs est /etc/passwd et qu'une ligne correspond à un utilisateur ?
..................................................................................................................................................
5. Afficher uniquement les 2 premières lignes du fichier /etc/hosts :..................................................................................................................................................
Arborescence unix – LinuxVersion : 0.6 56
gestion des liens
ln Gestion des liens sur fichier et répertoire
Syntaxe : ln [ s ] nomfich nomlien
s Option de création d'un lien symbolique. Par défaut lien physique
nomfich Nom du fichier à partir duquel le lien doit être créé
nomlien Nom du lien
Lien physique
Un lien physique correspond à une autre référence, dans le même répertoire ou dans un autre, qui pointe sur l'inode d'un fichier existant.
Exemple : Il existe un fichier fsource (inode 2133) auquel on souhaite accéder sous le nom de flien
Schéma du résultat de la commande : ln fsource flien
Arborescence unix – LinuxVersion : 0.6 57
marie
fsource flien
2133
référence
inodeinode
corps
Suppression d'un lien physique :
On peut supprimer n'importe quelle référence (n'importe quel fichier lié) sans que les autres soient modifiées.
Ce n'est que lorsque la dernière référence sera supprimée que le fichier (corps) sera supprimé aussi.
Contraintes des liens physiques :
Toutes les caractéristiques (sauf le nom ou référence) des fichiers liés sont toujours identiques (même propriétaire, mêmes permissions…).
Toute modification effectuée sur un fichier est systématiquement héritée par tous les fichiers liés physiquement.
Tous les fichiers liés doivent être situés dans le même filesystem.
Il est impossible de créer un lien physique sur un répertoire
Avantages des liens physiques :
Lors du déplacement (commande mv) d'un des fichiers liés (dans le même filesystem) tous les liens restent intacts.
Un lien physique ne provoque pas d'utilisation de nouvel inode.
Lien symbolique
Un lien symbolique consiste à créer un tout petit fichier (nouvel inode) d'un type spécial, dont le contenu correspond à la localisation (absolue ou relative) du fichier auquel il est lié. La taille de ce fichier est égale au nombre de caractères du chemin du fichier d'origine.
Arborescence unix – LinuxVersion : 0.6 58
/home/marie
forigfliensym
2147
référence
inodeinode
corps
/tmp
151
lecture ou écriture
Exemple : Il existe un fichier /home/marie/forig (inode 2147) pour lequel on souhaite créer un lien symbolique dans /tmp sous le nom de fliensym.
ln –s /home/marie/forig /tmp/fliensym
L'inode du fichier fliensym est 151, sa taille 17 octets et le type "l".
Un accès au contenu d'un lien symbolique nécessite pour le système deux accès successifs, un premier pour lire le nom du fichier pointé par le lien, un second pour accéder au fichier pointé et lire les données de ce dernier.
Suppression d'un lien symbolique :
La suppression d'un lien symbolique par la commande rm provoque la destruction du fichier qui contient le nom du fichier pointé. Le fichier pointé n'est pas altéré.
La suppression du fichier pointé, en conservant un lien symbolique sur celuici, provoque la destruction du fichier pointé et la modification du lien symbolique qui, après cette opération existe toujours mais ne pointe plus sur RIEN.
Le fait de récréer un fichier pointé du même nom que le précédent revalide le lien symbolique.
Contraintes d'un lien symbolique
Un lien symbolique augmente le temps d'accès aux données : le système doit faire deux lectures pour accéder aux données.
Si le fichier sur lequel pointe le lien symbolique est déplacé ou supprimé, le lien continue d'exister mais ne pointe plus sur RIEN.
Avantages d'un lien symbolique
Le problème de filesystem (disque physique ou partition) n'existe pas. Un lien symbolique peut être fait n'importe où dans l'arborescence.
Il est possible de créer des liens symboliques sur des répertoires.
La commande ls –l permet de lire clairement le nom du fichier pointé par le lien.
Si le fichier origine est supprimé puis recréé ensuite sous le même nom au même endroit, le lien est toujours valide.
Arborescence unix – LinuxVersion : 0.6 59
TP : les liens
1. Créez un lien physique du fichier Edition vers le fichier edition1.txt, vérifiez que vous pouvez afficher son contenu :
..................................................................................................................................................
..................................................................................................................................................
2. Créez un lien symbolique du fichier edition1.txt vers le fichier edition2.txt, vérifiez que vous pouvez afficher son contenu :
..................................................................................................................................................
..................................................................................................................................................
3. Créez un lien physique du fichier edition1.txt vers le fichier edition3.txt, vérifiez que vous pouvez afficher son contenu :
..................................................................................................................................................
..................................................................................................................................................
4. Affichez avec la commande ls les caractéristiques de ces 4 fichiers en mettant en évidence les différences :
..................................................................................................................................................
5. Supprimez le fichier edition1.txt, pouvez vous afficher le contenu de edition2.txt et edition3.txt ?
..................................................................................................................................................
..................................................................................................................................................
Arborescence unix – LinuxVersion : 0.6 60
Commandes de recherches
Les expressions régulières
Introduction aux expressions régulières
Une expression régulière est un modèle de chaîne de caractères auquel peut être associé un certain nombre de chaînes de caractères avec des caractéristiques communes : celles de l'expression régulière.
Une expression régulière est construite à l'aide de différents caractères dont certains ont une signification particulière. Ce sont les caractères spéciaux.
Les expressions régulières sont utilisés par les outils d'édition et de recherche dans les fichiers tels que vi, grep, sed, awk, ed, ex, et autres.
Caractères spéciaux
Les caractères spéciaux ont une signification particulière qu'ils perdent s'ils sont précédés du caractère \
. 1 caractère quelconque et un seul
. correspond à : a ou b ou x ou 2 …
.. correspond à : aB ou AA …
* répétition du caractère qui précède de 0 à n fois
a* correspond à : <rien> ou a ou aa ou aaa …
Commandes de recherchesVersion : 0.6 61
.* une séquence de caractères quelconque, correspond à :
<rien> ou une suite d'un nombre quelconque de n'importe quel caractère
[liste car] 1 seul caractère parmi ceux de la liste entre [ ]
[abc12] correspond à : a ou b ou c ou 1 ou 2
[intervalle caractères] [car. Début car. Fin] 1 seul caractère dans l'intervalle [AZ]correspond à une lettre majuscule
[AZaz] correspond à toutes les lettres minuscules et majuscules
[ah15] correspond à un caractère a ou b ou c … ou h ou 1 ou 5
[hm][08] correspond à h0 ou h8 ou i0 ou i8 ... ou m0 ou m8
[^caractères] 1 seul caractère autre que ceux entre [ ]
[^abc] correspond à un caractère autre que a , b et c
^chaîne chaîne de caractères placée en début de ligne
^B une ligne qui commence par B
^[aA\t] une ligne qui commence par a ou A ou par une tabulation
^[ \t]* une ligne qui commence par espace ou tabulation répété de 0 à n fois
chaîne$ chaîne de caractères placée en fin de ligne
fin$ une ligne qui se termine par fin
[^xyz]$ une ligne qui se termine par n'importe quel caractère autre que x, y ou z
^$ une ligne vide
^.*$ la totalité de la ligne quelque soit son contenu
Commandes de recherchesVersion : 0.6 62
\<mot un mot qui commence par "mot" sans tenir compte des espace avant.
mot\> un mot qui finit par "mot" sans tenir compte des espaces avant.
Facteurs d'occurrences
car\{m,M\} un caractère répété au minimum m fois et au maximum M fois
ab\{1,3\}c correspond à : abc ou abbc ou abbbc
car\{n, \} un caractère répété au minimum n fois
es\{2,\}ai correspond à : essai mais aussi à esssai, essssai …
car\{n \} un caractère répété n fois exactement
[AZ]\{3\} correspond à une chaîne de caractères composée de 3 majuscules
Commandes de recherchesVersion : 0.6 63
Rechercher dans les fichiers
grep Recherche d'expression dans les fichiers
Syntaxe : grep [ options ] [ f fichexpr ] [ e ] expression [ nomfich ]
c Nombre de lignes contenant l'expression
h Suppression du nom de fichier lorsque la recherche est faite dans plusieurs fichiers
i Ignore la distinction minuscule et majuscule
l Affiche uniquement le nom des fichiers contenant l'expression
n Chaque ligne est précédée de son numéro dans le fichier
v Affiche uniquement les lignes qui ne contiennent pas l'expression
f fichexpr Fichier dans lequel se trouve l'expression à rechercher
e Option facultative qui précède l'expression à rechercher
expression Expression régulière directement spécifiée ou stockée dans un fichier. Il est préférable de la protéger par des simples quotes.
nomfich Nom du fichier dans lequel la recherche doit être faite. Ce nom peut être générique. S'il n'est pas spécifié, la recherche est faite sur le canal d'entrée.
Rechercher, sans tenir compte de la casse, les lignes qui commençant par dupont dans le fichier Edition :
# grep -i "^dupont" Edition
Commandes de recherchesVersion : 0.6 64
Rechercher dans l'arborescence
find Recherche sur les noms de fichier et répertoire
Syntaxe : find chemin expr [ action ]
chemin Nom du ou des répertoires à partir desquels la recherche va être faite
expr Critères de recherche qui permettent une sélection très précise des fichiers. Ces critères sont très nombreux, mais les suivants sont les plus courants :
name nom recherche en fonction du nom. Ce nom peut être générique et dans ce cas, il doit être protégé par des quotes.
user nom recherche des fichiers dont le user propriétaire est nom.
group nom recherche des fichiers dont le groupe propriétaire est nom.
type t recherche en fonction de la nature des fichiers. t peut prendre les valeurs suivantes :
f fichier ordinaire
d répertoire
l lien symbolique
b fichier spécial en mode bloc
c fichier spécial en mode caractère
p canal nommé
perm [ ] perms recherche en fonction des droits. perms peut être exprimé en notation octale ou symbolique. Si la valeur de perms est négative, seul les fichiers dont les droits sont au moins perms seront retenus, dans le cas d'une valeur positive, les fichiers retenus seront ceux pour lesquels les droits sont strictement égaux à perms
size nb [c] recherche en fonction de la taille des fichiers exprimée en blocs (de 512 octets) ou en octets si nb est suivi du caractère c. Pour une
Commandes de recherchesVersion : 0.6 65
comparaison en blocs, la taille des fichiers est arrondie au bloc supérieur. Une comparaison octets impose que le ou les fichiers recherchés aient exactement le même nombre d'octets que celui spécifié par l'option size.
newer nom recherche les fichiers dont la date de modification est plus récenteque la date de modification du fichier nom.
atime nb recherche des fichiers sur la date de dernier accès. nb correspond au nombre de jours (1 pour la veille, 2 pour 2 jours avant, 3 pour 3 jours avant…)
ctime nb recherche des fichiers sur la date de création ou de dernière modification
mtime nb recherche des fichiers sur la date de dernière modification
inum num recherche des fichiers sur le numéro d'inode
print Affichage des noms de fichiers trouvés au fur et à mesure
exec cmd [ options ] { } \; Pour chaque fichier trouvé, exécution de la commande cmd. Le nom de chaque fichier est symbolisé par {} . La commande se termine obligatoirement par un espace suivi des caractères \;
ok cmd [ options ] { } \; Identique à exec avec demande de confirmation pour chaque execution de cmd
! Opérateur de négation
o Opérateur OU
a Opérateur ET (And)
( ) Parenthèse de regroupement. Attention, ces parenthèses doivent être protégées par \
Rechercher dans le répertoire /etc les fichiers réguliers ayant l'inode 24621
$ find /etc -type f -inum 24621
Rechercher dans son répertoire d'accueil les fichiers suffixés en .tmp et les supprimer
$ find $HOME -type f -name ".tmp" -exec rm {} \;
Commandes de recherchesVersion : 0.6 66
TP : recherches
1. Rechercher toutes les lignes contenant Dupont dans le fichier Edition :..................................................................................................................................................
2. Rechercher toutes les lignes contenant dupont quelque soit la casse dans le fichier Edition :
..................................................................................................................................................
3. Afficher toutes les lignes non vides du fichier Edition :..................................................................................................................................................
4. Lister les fichiers contenant localhost dans le répertoire /etc sans inclure les sousrépertoires :
..................................................................................................................................................
5. Rechercher tous les fichiers standards commençant par ho à partir du répertoire /etc :..................................................................................................................................................
6. Rechercher tous les répertoires depuis votre répertoire personnel :..................................................................................................................................................
7. Rechercher tous les fichiers standards de votre répertoire personnel se terminant par txt et en faire une copie avec l'extension .save :
..................................................................................................................................................
Commandes de recherchesVersion : 0.6 67
Editer du texte
Tous les systèmes d'exploitation basés sur Unix implémentent vi, il est l'éditeur de texte standard, est conçu pour fonctionner sur tout type de terminal et se contente d'un clavier minimum (sans touches de flèches, pavé numérique, etc).
Le korn shell traditionnellement utilisé sur les Unix s'appuie sur vi pour exploiter l'historique des commandes.
Certains utilitaires l'utilisent également par défaut pour l'édition de fichiers texte, comme le plannificateur de tâches cron.
En bref, il n'est pas concevable d'envisager l'administration de machines basées sur des systèmes Unix sans aucune connaissance de l'éditeur vi.
Sous Linux, c'est l'éditeur vim qui est utilisé à la place de vi. Il y ajoute certaines fonctionnalités, telles que reconnaissance de certains langages de programmation qui permet la coloration syntaxique, l'annulation sur plusieurs commandes, et un plus grand nombre d'options de l'environnement de travail.
il existe d'autres éditeurs de fichiers intérréssants, nous en citerons quelques uns ici :
emacs Le principal concurrent de vi dans la guerre des éditeurs
nano issu d'un autre éditeur : pico
joe acronyme récursif de Joe's Own Editor
jed multiplatforme : unix, windows, beos, qnx, etc.
jedit écrit en java, particulièrement pratique pour les développeurs de pages web en css, xhtml, php
ne un éditeur simple à utiliser (la touche echap permet d'accéder à un menu comme sur un éditeur graphique)
Editer du texteVersion : 0.6 68
vi
VI est l'éditeur de texte standard d'Unix. Il fonctionne en mode plein écran, ce qui implique que le type de terminal utilisé a beaucoup d'importance. La variable d'environnement TERM permet d'indiquer ce type de terminal.
Les modes de travail
mode insertion, saisie de texte
mode commande, les caractères tapés sont interprétés comme des commandes
mode commande ex, commandes de bas de page précédées de ":" (deuxpoints).
Les commandes se répartissent en 5 grandes catégories :
les commandes de déplacement/positionnement (qui n'altèrent pas le texte)
les commandes de modification de texte
les commandes d'entrée/sortie
les commandes diverses
la définition de l'environnement de fonctionnement VI
Un appui sur la touche <Esc> permet de revenir en mode commande.
Lancement de vi
vi [ options ] [ nomfich … ]
options :
R Lecture uniquement
+nb Positionnement dans le fichier à la ligne nb
+/chaîne Positionnement dans le fichier sur la première occurrence de chaîne
A l'entrée dans VI, vous êtes automatiquement en mode commande.
Editer du texteVersion : 0.6 69
Sortie de vi
ZZ sauvegarde et sortie de VI. La date de dernière modification sera affectée
:x uniquement si de réelles modifications ont été effectuées
:wq sauvegarde et sortie de VI. Affectation systématique de la date de dernière modification
:q [ ! ] sortie sans sauvegarde.
! force l'exécution de la commande qui précède, :q! permet de quitter vi sans tenir compte des modifications effectuées.
Commandes de déplacement et positionnement
Les déplacements du curseur sans défilement de l'écran
[nb]↑ ou [nb]k ou [nb]^P même colonne nb lignes avant
[nb]↓ ou [nb]j ou [nb]^N même colonne nb lignes après
[nb]← ou [nb]h ou [nb]<bs> nb caractères précédent sur la même ligne
[nb]→ ou [nb]l ou[nb]<espace> nb caractères suivant sur la même ligne
[nb] 1er caractère nb lignes avant
[nb]+ ou [nb]backspace 1er caractère nb lignes après
[nb]$ dernier caractère de la ligne courante + nb
[nb] | colonne nb de la ligne
0 (zéro) premier caractère de la ligne
^ premier caractère du premier mot de la ligne
[nb]w début du nbème mot suivant ou ponctuation
[nb]W début du nbème mot suivant, déterminé par un espace, une tabulation ou une nouvelle ligne
[nb]b début du nbème mot précédent ou ponctuation
[nb]B début du nbème mot précédent, déterminé par un espace, une tabulation ou une nouvelle ligne
[nb]e fin du nbème mot après le mot courant
[nb]E fin du nbème mot après le mot courant, déterminé par un espace, une tabulation ou une nouvelle ligne
[nb]G ou :nb aller à la ligne nb
Editer du texteVersion : 0.6 70
Les déplacements du curseur avec défilement de l'écran
[nb]^D Déplacement du curseur nb lignes plus bas et défilement de l'écran vers le haut, Down
[nb]^U Déplacement du curseur nb lignes plus haut et défilement de l'écran vers le bas, Up
[nb]^F Déplacement du curseur nb pages plus bas et défilement de l'écran vers le haut, aFter
[nb]^B Déplacement du curseur nb pages plus haut et défilement de l'écran vers le bas, Before
Les déplacements contextuels du curseur
[nb]( Déplacement du curseur au début de la nb ème phrase précédente. Délimitée par . ! ou ? suivi de 2 espaces
[nb]) Déplacement du curseur au début de la nb ème phrase suivante. Délimitée par . ! ou ? suivi de 2 espaces
[nb]{ Déplacement du curseur au début du nb ème paragraphe précédent.
[nb]} Déplacement du curseur au début du nb ème paragraphe suivant.
% Déplacement sur le caractère parenthèse ou accolade correspondant ( ouvrant / fermant )
H Déplacement en haut à gauche de la page écran (Home)
M Déplacement au début de la ligne centrale de la page écran (Middle)
L Déplacement en bas à gauche de la page écran (Last)
Pose de marque et déplacement sur une marque
m<az> Marque la position courante du curseur avec la lettre donnée. Par exemple, mf positionne la marque f à la position courante
'<az> Place le curseur au début de la ligne correspondant à la marque indiquée (une lettre)
`<az> Place le curseur sur la marque indiquée (une lettre)
Editer du texteVersion : 0.6 71
Positionnement par recherche de caractère ou de chaîne
[nb]f<car> Recherche de la nb ème occurrence suivante du caractère <car> spécifié
[nb]F<car> Recherche de la nb ème occurrence précédente du caractère <car> spécifié
; Répétition de la dernière commande f ou F dans le même sens
, Répétition de la dernière commande f ou F dans le sens inverse
/<chaîne>/ Recherche de l'occurrence suivante de la chaîne spécifiée. Si aucune chaîne n'est donnée, la dernière chaîne est recherchée
?<chaîne>? Recherche de l'occurrence précédente de la chaîne spécifiée. Si aucune chaîne n'est donnée, la dernière chaîne est recherchée
n Répétition de la dernière recherche de chaîne dans le même sens
N Répétition de la dernière recherche de chaîne dans le sens inverse
Commandes de modification
Passage en mode insertion de texte
a Insertion après le caractère courant
A Insertion après la fin de la ligne courante
i Insertion avant le caractère courant
I Insertion avant le premier caractère significatif de la ligne
o Ajout d'une ligne vide après la ligne courante et passage en mode insertion sur cette ligne
O Ajout d'une ligne vide avant la ligne courante et passage en mode insertion sur cette ligne
Un appui sur la touche <Esc> permet de revenir en mode commande, et donc de quitter le mode insertion.
Editer du texteVersion : 0.6 72
Suppression de texte
[nb]x Suppression de nb caractères suivants à partir du caractère courant
[nb]X Suppression de nb caractères précédents à partir du caractère courant
D Suppression du reste de la ligne à partir du caractère courant
[nb]dw Suppression de nb mots à partir du caractère courant
[nb]dd Suppression de nb lignes à partir de la ligne courante
La dernière suppression est stockée dans un tampon mémoire appelé tampon d'annulation.
Remplacement, substitution de texte, recherche et remplacement
r<car> Remplacement du caractère courant par le caractère <car> spécifié
R Passage en mode remplacement. Sortie de ce mode par appui sur <Esc>
[nb]s Substitution de caractère. Les nb caractères à partir du caractère courant sont remplacés par les caractères saisis. Le dernier caractère à substituer est signalé par $. Sortie de ce mode par appui sur <Esc>
[nb]S Substitution de ligne. Les nb lignes à partir de la ligne courante sont effacées, et l'on passe en mode insertion. Sortie de ce mode par appui sur <Esc>
[nb]cw Substitution de mot. Les nb mots à partir du caractère courant seront remplacés par les caractères saisis. Sortie de ce mode par appui sur <Esc>
Editer du texteVersion : 0.6 73
Recherche et remplacement d'une chaîne de caractères dans tout le fichier
...
: g/Dieu/s/Anubis/Isis/g
g Recherche globale dans tout le fichier (sinon recherche sur la ligne courante)
/Dieu/ Sélectionner uniquement les lignes contenant Dieu
s substitue
/Anubis/ la chaîne Anubis
/Isis/ par la chaîne Isis
g pour toutes les occurrences trouvées sur la ligne (sinon uniquement la première)
...
:11,20 g/Dieu/s/Anubis/Isis/g
Idem, mais de la ligne 11 jusqu'à la ligne 20 uniquement.
...
: g/Angers/s//Nantes/g
Dans ce cas, la chaîne à remplacer n'est pas définie, c'est la chaîne de sélection qui sera utilisée à la place. En d'autre termes, les occurrences de la chaîne Angers seront remplacées par la chaîne Nantes.
...
:g/Orléans/s/^#//
Ici, toutes les lignes qui contiennent Orléans seront seront décommentées.
Editer du texteVersion : 0.6 74
Transfert de texte
Le transfert de texte implique un passage par le tampon d'annulation ou par des tampons supplémentaires nommés par une lettre de l'alphabet en minuscule [ az ].
L'utilisation d'une lettre majuscule pour le transfert dans un tampon permet de compléter le contenu d'un tampon existant.
["<az>] [nb]yw Copie dans un tampon de nb mots à partir de la position courante
["<az>] [nb]yy Copie dans un tampon de nb lignes à partir de la ligne courante
["<az>] [nb]p Insertion après la ligne courante de nb fois le contenu du tampon
["<az>] [nb]P Insertion avant la ligne courante de nb fois le contenu du tampon
Pour les commandes cidessus, le tampon d'annulation est utilisé par défaut, sauf si l'on nomme explicitement le tampon avec lequel on souhaite effectuer le transfert, avec "<az>
Tous les tampons sont conservés en cas de changement d'espace de travail dans une même session vi.
Editer du texteVersion : 0.6 75
Commandes d'entrée / sortie
:r nomfich Insertion après la ligne courante du contenu du fichier nomfich
:nb r nomfich Insertion après la ligne nb du contenu du fichier nomfich
:r !cmd Insertion après la ligne courante du résultat de la commande cmd
:e [!] [nomfich] Chargement d'un fichier sans sortir de vi. Le contenu du fichier remplace le texte de l'espace de travail. Si nomfich n'est pas spécifié, le fichier courant est rechargé
:w Sauvegarde dans le fichier courant
:w [!] nomfich Sauvegarde dans le fichier nomfich. Si le fichier existe déjà, le ! est obligatoire pour écraser le fichier existant
:w>>nomfich Ajout du contenu de l'espace de travail à la fin du fichier nomfich
:n [!] Positionnement dans l'espace de travail suivant si plusieurs fichiers ont été spécifiés au lancement de vi
:n [!] nomfich Positionnement dans l'espace de travail qui contient le fichier nomfich
:rew [!] Retour au premier espace de travail (Premier fichier de la liste passée à vi)
:e # Commutation entre les fichiers
Commandes diverses
:!cmd Exécution de la commande cmd puis appui sur n'importe quelle touche pour revenir à l'environnement vi
:f ou ^G Affichage du statut du fichier chargé dans l'espace de travail
^L Rafraîchissement de l'affichage
. Répétition de la dernière commande de modification ou d'insertion de texte
u Annulation de la dernière commande exécutée
U Annulation de toutes les modifications effectuées sur la ligne depuis le positionnement sur cette ligne
[nb]J Jonction de nb lignes à la ligne courante. Les caractères <newline> sont remplacés par des espaces.
Editer du texteVersion : 0.6 76
Définition de l'environnement de vi
Il est possible de personnaliser son environnement de travail vi lors de chaque session ou d'enregistrer les différentes options dans un fichier qui sera pris en compte à chaque appel de vi.
la commande set permet de positionner les options d'environnement vi.
Syntaxe générale :
:set opt Active l'option opt
:set noopt Désactive l'option opt
:set opt? Affiche la valeur ou le statut de l'option opt
:set Affiche les options modifiées
:set all Affiche l'ensemble des options
Quelques options utiles
showmode Visualisation du mode de travail sur la ligne de statut
autoindent Indentation automatique, très utilisée en programmation
number Numérotation des lignes
ignorecase Pas de distinction minuscule / majuscule lors des recherches
tabstop Nombre de caractères entre deux tabulations (par défaut 8)
Enregistrement des options
Les options que l'on souhaite utiliser à chaque exécution de vi peuvent être stockées dans un fichier .exrc situé dans le répertoire de connexion de l'utilisateur.
ATTENTION : sous vi, le fichier .exrc ne doit pas contenir de lignes vides, sans quoi chaque lancement de vi sera suivi d'un message d'erreur (sans que cela soit préjudiciable au bon fonctionnement de l'éditeur). Ce problème n'est pas présent avec vim.
Editer du texteVersion : 0.6 77
D'autres commandes
unix2dos Conversion d'un fichier texte au format DOS
Conversion des caractères ISO standard en caractères DOS étendu.
Cette commande doit être utilisée devant la commande lp si l'on souhaite adresser la requête d'impression dans la file d'attente d'une imprimante connectée derrière un serveur Windows par exemple.
Syntaxe : unix2dos [ nomfich … ]
Résultat de la commande lp droit :
Résultat de la commande unix2dos droit | lp
Editer du texteVersion : 0.6 78
TP : vi
1. Ouvrir le fichier Edition de votre répertoire d'accueil avec vi :..................................................................................................................................................
2. Le premier Dupont Jean se prénomme en fait JeanJacques. Le premier Dupont Pierre se prénomme en fait JeanPierre. Rechercher la première occurrence de Dupont Jean :
..................................................................................................................................................
3. Déplacezvous sur le n de Jean puis insérer Jacques : ..................................................................................................................................................
4. De la même manière, rechercher Dupont Pierre et insérer Jean après vous être placé sur le 'P' de Pierre :
..................................................................................................................................................
5. Replacezvous en début de fichier :..................................................................................................................................................
6. Chercher le premier Dupont et insérer sur la ligne précédente votre nom et prénom :..................................................................................................................................................
7. Entrer le nom et le prénom de votre voisin après la ligne du dernier Dupont. Déplacezvous dans le fichier sur les différentes occurrences avec les touches 'n' et 'N' :
..................................................................................................................................................
8. Enregistrer les modifications apportées au fichier et sortir de l'éditeur :..................................................................................................................................................
Editer du texteVersion : 0.6 79
9. Dupont Jean s'appelle en fait MerlinDuval Jean. Recherchez Dupont Jean et changez Dupont par MerlinDuval :
..................................................................................................................................................
..................................................................................................................................................
10. Supprimer la ligne Couteau Jean après l'avoir retrouvée :..................................................................................................................................................
..................................................................................................................................................
11. Changez tous les Dupont en Durand :..................................................................................................................................................
12. Déplacer toutes les lignes contenant Durand en fin de fichier :..................................................................................................................................................
13. Ajouter un second Ben Raf, en dupliquant la ligne existante :..................................................................................................................................................
14. Sans sortir de la session vi, afficher la date et l'heure (pour savoir si c'est l'heure de la pause) :
..................................................................................................................................................
15. Créez un fichier .exrc dans le répertoire de connexion ($HOME), dont le contenu va permettre d'afficher le mode d'édition, les numéros de lignes et de positionner les tabulations tous les 5 caractères :
..................................................................................................................................................
16. Recherche globale avec remplacement : recherchez et remplacez tous les Durand en Dupont :
..................................................................................................................................................
17. Substituez Jean en JeanPaul : ..................................................................................................................................................
18. Substituer Jean en JEAN :..................................................................................................................................................
Editer du texteVersion : 0.6 80
19. Substituez JEAN en Jean en modifiant le séparateur de l'expression régulière :..................................................................................................................................................
20. Substituez Jean en JeanJean sur tout le texte :..................................................................................................................................................
21. Ajoutez (033) devant chaque numéro (en fin de ligne) commençant par 1,2 ou 3 :..................................................................................................................................................
22. Ajoutez 0 (zéro) à la fin de toutes les lignes qui commencent par F :..................................................................................................................................................
Editer du texteVersion : 0.6 81
Processus et mécanismes
Les processus
Les processus
On appelle processus l'image d'un fichier programme contenant du code exécutable binaire en cours d'exécution.
La connexion génère un processus, de même que tout programme exécuté.
Un utilisateur peut lancer plusieurs processus simultanément.
Un processus peut être exécuté en avant plan ou en arrière plan (notion de processus background ou tâche de fond).
Processus et mécanismesVersion : 0.6 82
ps Affichage du statut des processus
Syntaxe : ps [ options ]
e Affiche les informations pour tous les processus
u nomuser Affiche les informations pour l'utilisateur spécifié
t tty Affiche les informations pour un tty particulier
f Affiche les informations au format long
Sans option, la commande ps affiche les informations des processus de l'utilisateur présentées sur 4 colonnes qui sont les suivantes :
PID Process ID : identifiant unique d'un processus
TTY Nom du terminal auquel le processus est rattaché
TIME Temps cumulé d'exécution (vu du processeur)
COMMAND Commande qui est à l'origine du processus
Avec l'option -f les informations suivantes sont affichées en plus :
UID User ID : nom du user propriétaire du processus
PPID Parent Process ID : identifiant unique du processus parent
STIME Heure de départ du processus
Processus et mécanismesVersion : 0.6 83
kill Demande de terminaison d'un processus
Syntaxe : kill [ signal ] PID [ … ]
signalValeur numérique entière correspondant à des signaux envoyés aux processus
15 Terminaison logicielle
2 Interruption (^C)
9 Arrêt inconditionnel
PID Process ID : identificateur du processus à stopper
Sans valeur de signal, la commande kill envoie un signal 15 : Terminaison logicielle au processus spécifié par le PID. Ce signal peut ne pas être pris en compte par le processus, et dans ce cas, il peut être nécessaire d'envoyer un signal 9 : arrêt inconditionnel.
Mis à part root, seul le propriétaire du processus peut faire une demande de terminaison.
Processus et mécanismesVersion : 0.6 84
time Affichage du temps d'exécution d'un processus
Syntaxe : time cmd
cmd Commande pour laquelle on souhaite obtenir le temps d'exécution
La commande est exécutée normalement puis, le temps d'exécution est alors affiché. Ce temps est donné par trois valeurs :
real Temps écoulé depuis le lancement de la commande
user Temps d'exécution de la commande en mode utilisateur
sys Temps d'exécution de la commande en mode système
Le temps total d'exécution (d'utilisation du processeur) est obtenu en ajoutant les valeurs user et sys.
Processus et mécanismesVersion : 0.6 85
les processus en arrière plan
& , jobs , bg , fg Gestion des processus en arrière plan
Exécution en arrière plan
Le lancement d'un processus en arrière plan permet de récupérer "la main" juste après avoir lancé le processus.
Il ne faut pas oublier, dans ce cas, de rediriger les sorties générées par le processus.
Syntaxe : cde &
Après validation de la ligne de commande, deux informations sont retournées avant de récupérer le prompt :
1. Le numéro du job lancé en tâche de fond
2. Le numéro du processus (PID)
Outils pour le background (arrière plan)
Les processus lancés en background ou en arrière plan (par l'ajout d'un & derrière la commande) peuvent être gérés par la commande jobs.
Processus et mécanismesVersion : 0.6 86
jobs –lPermet d'afficher la liste des jobs et leur PID
Les informations retournées par la commande jobs sont les suivantes :
[ n ] numéro de job
+ job le plus récent
job qui précède directement le plus récent
PID numéro du processus
Etat du job (En cours d'exécution, Terminé)
Ligne de commande à l'origine du job
Il est également possible d'intervenir sur un job en tâche de fond pour le passer en avant plan ou au contraire, passer un processus d'avant plan en job (arrière plan).
Commande bg (background) permet de relancer un processus stoppé par CTRL Z ou par l'envoi du signal 17 SigStop
bg [ %numéro ] Permet de relancer un processus stoppé
Commande fg (foreground) permet de ramener en avant plan un job
fg [ %numéro ] Permet de ramener un job en avant plan
Processus et mécanismesVersion : 0.6 87
Signaux et suppression d'un job (processus)
Il est possible d'envoyer des signaux aux jobs, avec la commande kill, sans pour cela connaître le numéro de processus sur lequel on souhaite intervenir.
Dans ce cas, la syntaxe de la commande kill est la suivante :
kill –signal %numéro
Il existe plusieurs possibilités pour indiquer à la commande kill le processus concerné :
%n où n correspond au numéro de job entre [ ] affiché par la commande jobs
%% correspond au dernier job lancé
%+ identique à %%
% correspond à l'avant dernier job lancé
Processus et mécanismesVersion : 0.6 88
priorité des processus
nice
toutes les commandes et processus en cours d'exécution possèdent un niveau de priorité, allant de 20 à +19. Le niveau de priorité le plus fort est 20, le plus faible +19. Le niveau d'exécution est hérité de celui du parent, normalement le niveau zéro.
La commande nice permet d'exécuter une commande avec un niveau de priorité différent de zéro.
Seul l'utilisateur root peut lancer une commande avec un niveau de priorité négatif, c'est à dire supérieur à la normale. Les utilisateurs peuvent seulement exécuter une tâche avec un niveau de priorité plus faible, d'où le nom de la commande.
syntaxe : nice [options] [commande [arguments]]
Sans options ni argument, renvoie le niveau de priorité du shell en cours
nice
Exécuté monscript.sh avec le niveau de priorité +10
nice monscript.sh
Diminuer le niveau de priorité à +5
nice -5 monscript.sh
Augmenter le niveau de priorité à 5 (root seulement)
nice -n -5 monscript.sh
pour vérifier, ici sur une machine Linux
ps -eo pid,ni,user,args
Processus et mécanismesVersion : 0.6 89
renice
Permet de modifier la priorité d'une tâche en cours d'exécution. Hormis root, les usagers peuvent modifier seulement les processus dont ils sont propriétaires.
La commande renice comprend plus d'options car il est possible d'agir par numéro de processus, par utilisateur propriétaire ou par groupe propriétaire.
syntaxe renice priorité [[p] processID ...] [[g] processGROUP ...] [[u] user ...]
g pour agir sur les process appartenant au groupe
u pour agir sur les process appartenant à l'usager
p pour préciser un numéro de processus sur lequel agir (par défaut si aucune option n'est précisée pour un paramètre)
Changer la priorité des processus d'identificateurs 987 et 32, et tous les processus appartenant aux usagers daemon et root
renice +1 987 -u daemon root -p 32
Noter dans l'exemple l'utilisation du signe + indiquant le niveau de priorité, ce qui n'est pas possible avec nice.
Nota : les commandes nice et renice affectent les valeurs en absolu
Processus et mécanismesVersion : 0.6 90
redirections
UNIX travaille à partir de flux (suite non formatée d'octets). L'entrée d'une commande est traitée comme un flux, de même que le résultat et les éventuelles erreurs.
Pour chaque commande, il existe trois flux :
0 stdin flux d'entrée standard (clavier)
1 stdout flux de sortie standard (écran)
2 stderr flux de sortie erreur (écran)
Ces trois flux peuvent être redirigés vers ou à partir de fichiers.
Redirection du flux de sortie
> fichier Redirection du flux de sortie standard vers un fichier avec écrasement du fichier si existant.
>> fichier Redirection du flux de sortie standard vers un fichier en ajoutant en fin de fichier.
Processus et mécanismesVersion : 0.6 91
Commande
EntréeStandard
SortieStandard
SortieErreur
stdin : 0clavier
stdout : 1écran
stderr : 2écran
Redirection du flux de sortie erreur
2>fichier Redirection du flux de sortie erreur vers un fichier
2>&1 Possibilité de rediriger le flux erreur dans le même fichier de redirection du flux de sortie standard.
Redirection du flux d'entrée
< fichier Remplacement de l'entrée standard (clavier) par le contenu de "nom fichier".
Processus et mécanismesVersion : 0.6 92
pipelines
Les tubes
Un tube permet d'établir une liaison entre deux commandes. La sortie (le résultat) de la première devient l'entrée de la deuxième. Les tubes permettent de combiner les possibilités de plusieurs commandes et de les enchaîner de manière dépendante.
Le mécanisme des tubes permet entre autre chose de combiner les possibilités de commandes différentes.
Dans la formulation d'une commande, le tube est symbolisé par le caractère |
Un tube (pipe) est un canal unidirectionnel qui relie la sortie standard d'une commande à l'entrée d'une autre commande.
Pour afficher le nombre de fichiers standards du répertoire /etc qui finissent par .conf :
ls -l /etc | grep "^-" | grep "\.conf$" | wc -l
Processus et mécanismesVersion : 0.6 93
commande 1 commande 2
stdout stdin
tee Redirection double en sortie
La commande tee permet de rediriger le résultat d'une commande tout en conservant la sortie standard.
L'association de l'option –a à la commande tee permet d'ajouter à la fin du fichier spécifié.
Dans l'exemple suivant, le résultat de la commande who sera dirigé dans le fichier resultat.txt mais aussi affiché à l'écran :
who | tee resultat.txt
Processus et mécanismesVersion : 0.6 94
Commande
écran
fichier
tee
TP : Redirections d'entrées/sorties
1. Lister les processus qui finissent par un d. Le résultat sera stocké dans $HOME/process/daemons.txt :
..................................................................................................................................................
2. Rechercher les fichiers dont le nom se termine par .conf à partir de la racine. Cette recherche ne devra être effectuée que sur le système de fichier racine. Le résultat sera affiché à l'écran tout en étant stocké dans le fichier $HOME/resultats/fichiers.conf :
..................................................................................................................................................
3. La commande précédente à duré un certain temps, comment connaître le temps exact d"exécution de celleci ?
..................................................................................................................................................
4. En une commande, renvoyer dans le fichier $HOME/resultats/compteur.txt le nombre de fichiers trouvés dans la commande précédente. Le résultat devra comporter uniquement ce nombre (ce résultat sera réutilisé dans des scripts) :
..................................................................................................................................................
Processus et mécanismesVersion : 0.6 95
Les droits d'accès
Un fichier appartient à un user et à un group. Les droits d'accès à un fichier sont déterminées en fonction du user et du group propriétaire du fichier.
Gestion des Permissions
Chaque fichier ou répertoire est créé avec des permissions positionnées par défaut par rapport à la valeur du "umask".
Si la lecture des permissions sur un fichier permet de déterminer directement les accès possibles sur celuici, il faut interpréter les permissions sur un répertoire pour déterminer les droits d'accès de ce dernier.
Interprétation des droits sur un répertoire
Droit d'accès Fichier Répertoire
r lecture Visibilité du contenu du répertoire.
Nécessaire pour la commande ls et pour l'utilisation des modèles de critère de recherche sur les noms de fichier
w écriture Possibilité de créer ou supprimer des fichiers ou des répertoires dans le répertoire concerné.
x exécution Possibilité de positionnement dans le répertoire (commande cd)
Le nom du répertoire peut apparaître dans un chemin d'accès
Les droits d'accèsVersion : 0.6 96
chown Changement du user propriétaire
Syntaxe : chown nomuser [ :nomgroup ] nomfich [ … ]
nomuser Nom du nouveau user propriétaire
:nomgroup Nom du nouveau groupe propriétaire
nomfich Nom du fichier pour lequel on souhaite modifier le propriétaire. Ce nom peut être générique
Attention, l'utilisation de la commande chown nécessite une autorisation particulière qui doit être donnée par l'administrateur.
A défaut de ce privilège, seul le groupe propriétaire peut être modifié par le user propriétaire avec la commande chgrp.
L'administrateur (root) est, par défaut, le seul à pouvoir utiliser la commande chown.
Modification avec privilège :
Les droits d'accèsVersion : 0.6 97
chgrp Changement de groupe propriétaire
Syntaxe : chgrp [ R ] nomgroup [ nomfich | nomrep ] [ … ]
nomgroup Nom du nouveau groupe propriétaire. Ce groupe doit être l'un des groupes dont le user est membre.
nomfich Nom du fichier pour lequel on souhaite modifier le groupe propriétaire. Ce nom peut être générique.
ou
nomrep Nom du répertoire pour lequel on souhaite modifier le groupe propriétaire. Ce nom peut être générique.
-R Modification récursive du groupe propriétaire pour un ou plusieurs répertoires.
Attention, seuls le propriétaire du fichier ou répertoire et root peuvent modifier le groupe propriétaire.
Les droits d'accèsVersion : 0.6 98
newgrp Modification du groupe connexion
Syntaxe : newgrp nomgroup
nomgroup Nom du nouveau groupe par défaut. Ce groupe doit être l'un des groupes dont le user est membre.
Les droits d'accèsVersion : 0.6 99
umask Gestion du masque de droits par défaut
Syntaxe : umask [ S ] [ masque ]
masque La valeur du masque peut être passée en mode absolu (valeur octale) ou en mode symbolique (chaîne de caractères).
S Permet de visualiser la valeur du masque en mode symbolique
Si masque n'est pas spécifié, la commande umask [S] retourne la valeur actuelle du masque en octal ou symbolique.
Lors de la création d'un fichier ou répertoire, des droits par défaut sont positionnés. Ils sont déterminés par la valeur du masque retranchée à la valeur maximum des droits.
La valeur maximum des droits d'un fichier est en octal "666" ou en symbolique "r w ". Le droit d'exécution ne peut pas être positionné par défaut à la création du fichier.
La valeur maximum des droits d'un répertoire est en octal "777" ou en symbolique "r w x".
Ces droits (fichiers et répertoires) sont décomposés en 3 groupes de 3 positions. Chaque position a une signification précise (et ce pour les 3 groupes) :
Position 1 droit de lecture
Position 2 droit d'écriture
Position 3 droit d'exécution
Toutes positions le tiret ( ) indique que le droit pour la position n'est pas alloué
Exemple Owner Group owner
Other
Permissions symboliques r w x r x r
Permissions binaires 1 1 1 1 0 1 1 0 0
Permissions octales 7 5 4
Les droits d'accèsVersion : 0.6 100
chmod Gestion des droits de fichier et répertoire
Les droits d'un fichier ou d'un répertoire peuvent être positionnés en absolu ou en relatif. La première méthode étant plus "dangereuse" car elle implique une prise en compte des droits déjà positionnés.
Modification en absolu
Syntaxe 1 : chmod droits nomfich [ … ]
droits Valeur octale de 3 digits. Chaque digit correspond à un groupe, la valeur de chaque digit correspond aux droits positionnés pour le groupe.
Les valeurs possibles sont :0 aucun droit1 droit d'exécution (x)2 droit d'écriture (w)4 droit de lecture (r)
Ces valeurs peuvent être combinées pour obtenir la valeur octale des droits exacts à positionner.
nomfich Nom du fichier ou répertoire. Ce nom peut être générique.
Modification en relatif
Syntaxe 2 : chmod qui comment quoi nomfich [ … ]
qui Définit pour quel ou quels groupes positionner le ou les droits
Les valeurs possibles sont :u le groupe owner (user propriétaire)g le groupe group ownero le groupe othera tous les groupes (all)
Ces valeurs peuvent être combinées, par exemple go pour définir les droits des groupes group owner et other.
Les droits d'accèsVersion : 0.6 101
comment Opérateur d'affectation des droits
Les opérateurs possibles sont :+ permet d'ajouter le ou les droits aux droits existants permet de retirer le ou les droits aux droits existants= permet d'assigner les droits spécifiés sans tenir compte
de ceux qui existaient
quoi Le ou les droits à positionner. Les valeurs de base sont :r pour le droit de lecturew pour le droit d'écriturex pour le droit d'exécution
Ces valeurs peuvent être combinées, par exemple rw pour affecter des droits de lecture et écriture.
Les droits d'accèsVersion : 0.6 102
TP : permissions
1. Créer un fichier Bonjour qui contient les lignes suivantes :
#! /bin/shclearecho "Bonjour $LOGNAME"date "+Nous sommes le %D%nIl est %HH%m"
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
2. Quelles sont les autorisations d'accès qui ont été définies pour ce fichier ?..................................................................................................................................................
3. Quel est l'utilisateur propriétaire, le groupe propriétaire de ces fichiers ?..................................................................................................................................................
4. Pouvezvous exécuter le fichier Bonjour ?..................................................................................................................................................
5. Positionner les droits adéquats pour que le propriétaire puisse exécuter ce fichier :..................................................................................................................................................
6. Supprimer les accès à tous les utilisateurs membres de votre groupe ainsi qu'à tous les autres sur le fichier :
..................................................................................................................................................
Les droits d'accèsVersion : 0.6 103
Archivage et compressions
Il est indispensable de faire la différence entre l'archivage et la compression, qui correspondent à deux mécanismes différents :
l'archivage
Concaténation d'un ensemble de fichiers et répertoire en un seul fichier. La taille totale n'est pas particulièrement diminuée, l'opération permettant de manipuler un ensemble de fichier ou une arborescence plus facilement lors de manipulations telles que le téléchargement ou l'envoie de mail.
Nous verrons dans le cours la commande tar, mais il faut savoir que la commande cpio est également très utilisée sur les systèmes Unix, même si son usage la réserve particulièrement aux sauvegardes sur bande. rsync est également une commande très intéressante, car elle permet de faire des réplica, et peut fonctionner en mode client/serveur avec le démon rsyncd.
La compression
la compression agit fichier par fichier, son but étant de réduire au maximum la taille des (gros) fichiers pour accélerer les transferts ou minimiser l'espace disque lors des sauvegardes.
L'usage conjoint des deux outils est très courant, car facilitant au maximum la manipulation et le transfert de fichiers sur les liaisons lentes comme internet et la copie des sauvegardes sur les supports de stockage.
Archivage et compressionsVersion : 0.6 104
archiver
tar
Le première argument de tar doit être obligatoirement une de ces lettres: Acdrtux, suivis par n'importe quelles fonctions optionnelles. Les arguments finaux de tar sont les noms des fichiers ou des répertoires qui doivent être archivés. L'utilisation d'un nom de répertoire implique toujours que les sousrépertoires seront inclus dans l'archive.
OPTIONS PRINCIPALES
Il faut obligatoirement utiliser l'une des options suivantes :
A, catenate, concatenate
ajouter des fichiers archives à une archive.
c, create
créer une nouvelle archive.
d, diff, compare
trouver les différence entre une archive et les fichiers indiqués.
delete
supprimer des fichiers d'une archive. (à ne pas utiliser avec les lecteurs de bandes!)
r, append
ajouter des fichiers à la fin d'une archive.
t, list
liste le contenu d'une archive.
u, update
ajoute seulement les fichiers qui sont plus récents que ceux de l'archive.
x, extract, get restaure les fichiers contenus dans une archive.
Archivage et compressionsVersion : 0.6 105
OPTIONS ADDITIONNELLES
atimepreserve
ne modifie pas les dates d'accés des fichiers de l'archive.
C, directory DIR
aller dans le répertoire DIR.
f, file [HOSTNAME:]F
utilise le fichier archive F ou le périphérique F (par defaut /dev/rmt0).
ignorefailedread
n'abandonne pas l'opération si un fichier est illisible.
m, modificationtime
ne restaure pas la date de modification du fichier.
N, afterdate DATE, newer DATE
enregistre seulement les fichiers plus récent que DATE.
p, samepermissions, preservepermissions
restaure toutes les informations de protection.
P, absolutepaths
n'enlève pas les '/' au début des noms des fichiers.
preserve
comme p s
sameowner
conserve les appartenances des fichiers restaurés.
exclude FILE
exclut le fichier FILE du traitement.
X, excludefrom FILE
exclut du traitement les fichiers dont les noms sont contenus dans FILE.
z, gzip, ungzip
pour les distribution Linux, compresse l'archive avec gzip.
Archivage et compressionsVersion : 0.6 106
D'autres options existent, notament pour le traitement sur lecteur de bandes de sauvegardes.
Sauvegarder /etc dans une archive etc.tar de mon répertoire d'accueil :
tar cvf ~/etc.tar /etc
lister le contenu de l'archive
tar tvf ~/etc.tar
restaurer l'archive créée dans le répertoire existant repTest
tar xvf ~/etc.tar -C ~/repTest
restaurer uniquement le fichier hosts de l'archive dans son répertoire d'accueil
tar xvf ~/etc.tar -C ~ ./etc/hosts
Noter que le répertoire etc devra être restauré également
le signe – peutêtre utilisé pour remplacer le fichier d'entrée ou de sortie par un pipeline :
tar cvf - . | gzip > /tmp/home.tar.gz
dans le cas présent, l'utilisateur archive son répertoire d'accueil puis compresse cette archive dans /tmp/home.tar.gz
Noter que les distributions linux possèdent une commande tar améliorée qui permet d'invoquer les outils de compression plus aisément.
Archivage et compressionsVersion : 0.6 107
compresser
compress, gzip Compression de fichiers de données
compress permet de réduire la taille d'un ou plusieurs fichiers. Le résultat de la compression remplace le fichier origine pour lequel le nom est modifié : ajout du suffixe .Z
Syntaxe : compress [ f ] [ v ] [ nomfich …]
f Force la compression si un fichier .Z existe déjà
v Affiche le pourcentage de compression de chaque fichier
nomfich nom du ou des fichiers à compresser. Ce nom peut être générique
Archivage et compressionsVersion : 0.6 108
gzip permet également de réduire la taille d'un ou plusieurs fichiers ordinaires. L'extension .gz est ajoutée aux fichiers compressés.
Syntaxe : gzip [ f ] [ l ] [ nomfich … ]
f Force la compression si un fichier .gz existe déjà
l Affiche le pourcentage de compression de chaque fichier
nomfich nom du ou des fichiers à compresser. Ce nom peut être générique
Archivage et compressionsVersion : 0.6 109
uncompress, zcat, gunzip, gzcat Décompression de fichiers .Z, .gz
uncompress permet de retrouver le ou les fichiers originaux à partir d'un .Z
zcat a un fonctionnement identique à uncompress c
Syntaxe : uncompress [ c ] [ nomfich.Z …]
zcat [ nomfich.Z …]
c Permet d'écrire sur la sortie standard, donc pas de destruction du fichier compressé
nomfich.Z nom du ou des fichiers à décompresser. Ce nom peut être générique
Archivage et compressionsVersion : 0.6 110
gunzip permet également de retrouver le ou les fichiers originaux à partir d'un .gz
gzcat a un fonctionnement identique à gunzip c
Syntaxe : gunzip [ c ] [ nomfich.gz …]
gzcat [ nomfich.gz …]
c Permet d'écrire sur la sortie standard, donc pas de destruction du fichier compressé
nomfich.gz nom du ou des fichiers à décompresser. Ce nom peut être générique
Archivage et compressionsVersion : 0.6 111
TP : sauvegardes
1. Réalisez une sauvegarde de votre répertoire personnel dans /tmp, en utilisant votre login pour le nommage du fichier :
..................................................................................................................................................
2. Créez dans votre répertoire d'accueil un nouveau fichier vide, et réalisez une mise à jour de votre archive :
..................................................................................................................................................
..................................................................................................................................................
3. Listez le contenu de votre archive pour vérifier qu'elle contient le nouveau fichier : ..................................................................................................................................................
4. Créez une nouvelle archive de votre répertoire personnel, mais cette foisci en la compressant avec gzip, l'opération devant être réalisée en une seule instruction :
..................................................................................................................................................
5. Dans votre répertoire de connexion, créez le répertoire Restaurations et restaurez votre sauvegarde dans ce répertoire en une seule instruction :
..................................................................................................................................................
6. Créez une nouvelle sauvegarde, non compressée, en excluant ce répertoire :..................................................................................................................................................
Archivage et compressionsVersion : 0.6 112
Le shell
LE SHELL : interpréteur de commandes
Le shell est un programme permettant les échanges entre le système Unix et l'utilisateur : c'est un interpréteur de commandes d'Unix.
Son utilisation s'étend à la programmation, grâce à la gestion des variables, des boucles, et des flux Entrée / Sortie.
Plusieurs shell sont disponibles sur les systèmes Unix.
Les principaux interpréteurs de commandes
Le Shell considéré le plus ancien est le Bourne Shell (sh), du nom de son créateur Steve Bourne.
Bill Joy créa quand à lui le CShell (csh), incompatible avec le bourne shell, mais permettant le rappel de commande , le contrôles des tâches , et l'utilisation des alias de commandes.
Plus tard, David Korn repris le Bourne Shell en y incluant les fonctionnalités du Cshell. Ce nouvel interpréteur prendra lui aussi le nom de son créateur en s'appelant le korn shell (ksh). C'est le shell le plus utilisé des systèmes Unix commerciaux.
Le projet GNU développera aussi son alternative aux shell existants avec le Bourne Again Shell (bash), conforme comme le ksh à la norme POSIX en y ajoutant quelques extensions. C'est l'interpréteur de commande fournit en standard sur les distributions Linux
Quel shell utiliser dans un programme ?
Le Korn Shell et le Bash ont une compatibilité descendante avec le bourne Shell, aussi, l'écriture d'un script en Bourne Shell assure la meilleure portabilité possible. Il comporte cependant quelques lacunes et certaines fonctionalités font défaut, c'est pourquoi il est possible de lui préférer le Korn Shell ou le Bash.
Nous abordons dans ce cours le sh, le ksh et le bash. Ne serons pas vus le csh, le tcsh, le ash, le dash, ni même le zsh.
Le shellVersion : 0.6 113
Fonctionnement général d'un shell
Le shellVersion : 0.6 114
Affichage du prompt
Lecture de la ligne de commande
Analyse de la ligne lue
le 1er mot est-il une commande interne ?
Lancement de la fonction
Création d'un processus
oui non
L'environnement
Caractéristiques :
• Gestion de variables
• Structures de contrôle
• Commandes internes, propre au shell
Liste des variables : commandes UNIX "set" et "env"
Affectation, affichage, export
Variable PATH doit contenir :
.
$HOME/bin
Chronologie d'exécution d'une commande shell
• Recherche du chemin d'accès
• Création d'un shell fils héritant de l'environnement du père
• Traitement des variables et des métacaractères
• Exécution de la ou des commandes (séquentiellement, groupement, tâche de fond)
• Attente de la fin du processus
• Redirection des sorties (stdout, stderr, tube)
Le shellVersion : 0.6 115
les variables
Deux catégories de variables :
les variables locales, accessibles uniquement dans le shell cou rant
les variables d'environnement, éventuellement définies dans un shell père et accessibles depuis n'importe quel sousshell
Les différents types de variables
En Bourne shell les variables sont uniquement de type caractère. Une variable ne peut pas commencer par un chiffre.
Les autres shell acceptent d'autre types de variables :
• entier
• chaîne de caractères
• tableau d'entiers
• tableau de chaînes de caractères
Affectation
Un nom de variable
• commence par un caractère alphabétique ou un underscore : [azAZ_].
• Les caractères suivants sont alphanumérique ou underscore : [azAZ09_].
Attention à
• Ne jamais mettre d'espaces avant et après le signe '='
• Veiller à protéger les espaces dans le contenu des variables
• une variable non déclarée est considérée comme vide
var_un=valeur
var_deux='un deux trois'
Utilisation de la valeur stockée
echo $var_un
echo $var_deux
Le shellVersion : 0.6 116
echo $var_trois
Destruction d'une variable
unset nomvar
Visualisation des variablessetenvtypeset itypeset r
Protéger une variablereadonly var4=30typeset r var5=40
Quelques variables d'environnement
LOGNAME nom du user de connexionMAIL chemin d'accès au fichier boîte aux lettresPATH chemin de recherche des exécutablesPS1 prompt du shellPS2 prompt de continuationSHELL shell de connexionTERM type du terminal utiliséHOME répertoire de connexion~ répertoire de connexion
Ces variables peuvent être visualisées par la commande env ou la commande set.
Par convention, le nom des variables d'environnement est en majuscules.
Nota :
Les variables sont revues en détail dans la partie liée au scripting, car certains mécanismes liés aux variables prennent tout leurs sens dans la création de fichiers de commandes.
Le shellVersion : 0.6 117
Le shellVersion : 0.6 118
les alias
Un alias est un synonyme (une abréviation) auquel on peut associer une commande avec ou sans arguments. Il peut être défini en ligne de commande, dans ce cas, sa durée de vie est équivalente à la durée de la session.
Il peut aussi être défini dans un fichier d'initialisation d'environnement ( .profile ou .kshrc), ce qui en garantit l'existence et la possibilité d'utilisation d'une session à une autre.
alias Définition d'un alias
alias nom='texte'
Le nom de l'alias ne peut comporter que des lettres et des chiffres, aucun caractère spécial.
La substitution de l'alias par sa définition est effectuée avant toutes autres substitutions sur la ligne de commande et ce, uniquement si le nom de l'alias correspond au premier mot de la ligne de commande.
D'autres substitutions peuvent être effectuées si la définition du premier alias se termine par un espace.
Le shellVersion : 0.6 119
Liste des alias définis
alias sans argument
Le shellVersion : 0.6 120
unalias Suppression d'un alias
unalias nom [ nom … ]
Le shellVersion : 0.6 121
le rappel de commandes et la gestion de l'historique
En KSH
Le Korn shell offre la possibilité de travailler avec un fichier historique des commandes saisies et exécutées.
Par défaut, les 128 dernières commandes sont stockées dans le fichier $HOME/.sh_history. Il est possible de modifier le nombre des commandes à conserver dans ce fichier, sans toutefois dépasser le maximum fixé à 32767, en affectant la valeur à la variable HISTSIZE, ainsi que le nom du fichier historique en valorisant la variable HISTFILE.
Le contenu du fichier historique est géré par la commande fc
Affichage des commandes du fichier historique
fc –l affiche les 16 dernières lignes de commandes précédées de leurs numéros
fc –ln affiche les 16 dernières lignes de commandes sans les numéros
Le shellVersion : 0.6 122
Modification d'une commande pour réexécution
L'utilisation de l'option –s de la commande fc permet de substituer un mot par un autre et de réexécuter la commande ainsi modifiée.
Autre possibilité de modification de commande du fichier historique
Le principe consiste à se positionner sur la ligne à modifier et à utiliser les commandes de l'éditeur vi pour effectuer les modifications souhaitées.
<ESC> Passage en mode édition de ligne
k ou Remonte de ligne en ligne dans l'historique
j ou + Descend de ligne en ligne dans l'historique
l ou espace Déplace le curseur vers la droite caractère par caractère
h ou backspace Déplace le curseur vers la gauche caractère par caractère
w Déplace le curseur vers la droite mot par mot
a Insertion de texte à droite du curseur
A Insertion de texte à la fin de la ligne de commande
i Insertion de texte à gauche du curseur
La sortie du mode insertion est faite par appui sur <ESC>.
x Suppression du caractère courant
r Remplacement du caractère courant
etc
La plupart des commandes de l'éditeur vi pourront ainsi être utilisées.
Le shellVersion : 0.6 123
Transfert de lignes du fichier historique vers un fichier
L'utilisation de l'historique des commandes en Korn shell permet également de créer des fichiers (scripts) à partir de lignes de commandes déjà exécutées et donc testées.
Dans ce cas, il ne faut pas oublier l'option –n de la commande fc qui permet de supprimer les numéros de lignes.
Le fichier ainsi créé peut ensuite être modifié par l'éditeur vi et être exécuté de la même manière que les autres fichiers (après positionnement du droit d'exécution x).
Le shellVersion : 0.6 124
en bash
Les facilités offertes par le rappel des commandes et l'autocomplétion dans un shell tel que le bash lui procure un rendement très intéressant, à tel point qu'il est bien souvent plus efficace de se déplacer et d'exécuter des commandes dans un terminal plutôt que par le biais d'une interface graphique.
historique et rappel de commandes
↑ rappeller les commandes précédentes, on peut remonter dans tout l'historique des commandes
↓ rechercher dans l'ordre inverse
!! rappeler la dernière commande exécutée
!com rappeler la dernière commande exécutée commençant par la chaine "com"
!?fich rappeler la dernière commande exécutée contenant la chaine "fich"
history comme en ksh, afficher les commandes mémorisées
!287 rappelle la commande numérotée 287
Après examen de ses possibilités, des questions peuvent se poser, comme :
• Même après avoir fermé sa session ou même redémarré l'ordinateur le rappel de commandes reste disponible pour les utilisateurs, c'est donc que les commandes déjà saisies sont stockées dans un fichier. Quel est donc ce fichier ?
• Combien de commandes sont mémorisées ?
• Quel sont les paramètres passés au rappel de commande ?
Les réponses se trouvent dans des variables :
Le shellVersion : 0.6 125
$HISTCMD contient le dernier numéro de commande utilisé
$HISTFILE chemin et le nom du fichier de rappel
$HISTFILESIZE taille du nombre de rappels possibles
$HISTSIZE taille du nombre de commandes en mémoire
$HISTCONTROL liste des options au rappel de commande ignoreboth : ignorer les doublons de commandes
$HISTTIMEFORMAT N'est généralement pas présente par défaut, il permet d'horodater les commandes saisies.
On pourra par exemple pour le compte root, par mesure de sécurité, passer dans le .bashrc la déclaration de la variable comme ceci :export HISTTIMEFORMAT="%Y/%m/%d @ %T"
autocomplétion
Le bash permet la complétion automatique, c'est à dire l'incrémentation automatique des noms lors de la frappe. L'autocomplétion est activée en pressant une ou deux fois la touche Tabulation.
l'autocomplétion agit sur plusieurs niveaux :
les chemins d'accès
L'autocomplétion est très utilisée pour les chemins d'accès
ls /e
suivi de la touche tabulation se verra autocompléter le chemin /etc :
ls /etc
si l'autocomplétion n'agit pas, c'est que le chemin fournit permet plusieurs possiblités, on pourra alors presser la touche Tabulation deux fois de suite pour afficher les différentes options possibles
ls /etc/h
suivi d'une double frappe sur la touche tabulation pourra donner ceci :
hdparm.conf host.conf hostname hosts hosts.allow hosts.deny
Le shellVersion : 0.6 126
Les commandes
les commandes bénéficient également de l'autocomplétion :
fir
suivi de la touche tabulation donnera :
firefox
Les variables
Même chose pour les variables :
echo $LO
donnera :
echo $LOGNAME
Nota : certains environnements étendent l'autocomplétion encore plus loin, par exemple aux pages de man ou aux options sur certaines commandes.
Le shellVersion : 0.6 127
Les scripts
Créer des scripts
Les scripts shell sont des fichiers de texte dans lesquels sont stockées des suites de lignes de commandes. Ces fichiers peuvent être créés et modifiés par l'éditeur de texte vi.
Particularités des scripts Bourne shell
Une ligne de commentaire commence par le caractère # . Ce même caractère peut être placé derrière le dernier élément d'une ligne à condition qu'il soit précédé d'au moins un espace.
Tout utilisateur dont le shell de connexion est le Bourne shell possède normalement un fichier .profile, script qui est exécuté automatiquement à l'ouverture de session.
# @(#) profile 23.3 91/10/24
#
# Copyright © 1989-1991 The Santa Cruz Operation, Inc.
# All Rights Reserved.
# The information in this file is provided for the exclusive use of the licensees of The Santa Cruz Operation, Inc. Such users have the right to use, modify, and incorporate this code into other products for purposes authorized by the license agreement provided they include this notice and the associated copyright notice with any such product. The information in this file is provided "AS IS" without warranty.
# .profile -- Commands executed by a login Bourne shell
PATH=$PATH:$HOME/bin:. # set command search path
MAIL=/usr/spool/mail/`logname` # mailbox location
export PATH MAIL
Les scriptsVersion : 0.6 128
# use default system file creation mask
eval `tset -m ansi:ansi -m :\?${TERM:-ansi} -r -s -Q`
/usr/bin/prwarn # issue a warning if password due to expire
Les scriptsVersion : 0.6 129
Les variables dans les scripts
Les variables sont des éléments vitaux dans la réalisation de scripts, il est important de bien comprendre les mécanismes qui les régissent.
Modification du contenu d'une variable d'environnement
NOMVAR=valeurexport NOMVAR la variable "exportée" est alors visible à tous les niveaux
Les variables réservées
$ numéro du processus en cours
? code retour ( 0 si vrai, différent de 0 si faux )
exit 2 provoque la sortie avec le code retour "2"→
! numéro du dernier processus lancé en arrière plan
# nombre de paramètres reçus par le script
1 à 9 paramètres de la commande (1 pour le premier, 2 pour le deuxième, etc)
0 nom de la commande ou du script
@ ou * valeurs des paramètres reçus encadrés par " ". Certaines versions Unix concatènent les valeurs avec *
Exemple :
monscript valun valdeux valtrois
Dans cet exemple les variables suivantes sont affectées :
$# 3 trois paramètres reçus$0 monscript$1 valun$2 valdeux$3 valtrois$@ valun valdeux valtrois
Les scriptsVersion : 0.6 130
Décalage des paramètres
Le décalage des paramètres se fait, comme en Bourne shell, avec la commande interne :
shift [n]
Après l'exécution de la commande shift :
• $0 inchangé
• $1 perdu
• Deuxième paramètre devient premier paramètre ($1)
• Troisième paramètre devient deuxième paramètre ($2)
• …
• Paramètre n devient paramètre n1
• $# et $* sont REMIS à jour
Possibilité de décaler de n positions (exemple : shift 2 permet de décaler de 2 positions)
Commande set
la commande set permet d'affecter les variables réservées
set $LOGNAME `uname -n`
echo $1 $2
serveur102 user20
cas pratique : modifier son prompt principal
Affichage du prompt avec le nom de chemin du répertoire courant
Modifier le fichier .profile en ajoutant la ligne :
$ PS1='${PWD#$HOME/}(!):'
\d pour ajouter la date (format anglais)
\t pour ajouter l'heure (HH:MM:SS)
\u pour ajouter le nom de l'utilisateur
\r pour un retour à la ligne
\w pour ajouter le chemin complet du répertoire courant
\W pour ajouter le répertoire courant
\h pour ajouter le nom de la machine
Les scriptsVersion : 0.6 131
Les caractères spéciaux du shell
; Enchaînement systématique de commandes sur une même ligne.
&& Enchaînement conditionnel de commandes : la deuxième commande n'est exécutée que si la première s'est bien passée. (ET)
| | Enchaînement conditionnel de commandes : la deuxième commande n'est exécutée que si la première ne s'est pas bien passée. (OU)
Le regroupement de commandes :
Le regroupement de commande pourra être utilisé pour
– rediriger le résultat de plusieurs commandes vers un fichier ou un tube.
– exécuter plusieurs commandes dans un même environnement.
(cmd1; cmd2; cmd3 ) Création de sous shell dans une commande.
Renvoyer le nombre total de fichier contenu dans /bin et /usr/bin :
(ls /bin/; ls /usr/bin) | wc -l
{ cmd1; cmd2; cmd3; } Regroupement de commandes sans création de sous shell.
Attention, respecter le point virgule suivant le dernière commande et les espaces après et avant les accolades
{ ls /bin/; ls /usr/bin; } | wc -l
Les scriptsVersion : 0.6 132
Utiliser les couleurs dans le prompt
Il est possible d'utiliser quelques couleurs dans le shell. Il pourra être utile de les utiliser pour l'affichage à l'écran d'informations importante, ou dans le prompt de l'utilisateur.
Couleur Caractères Fond Attribut des caractères
Noir 30 40 0 : aucun
Rouge 31 41 1 : gras
Vert 32 42 4 : souligné
Brun 33 43 7 : inversé
Bleu 34 44 8 : invisible
Magenta 35 45 9 : barré
Cyan 36 46
Blanc 37 47
➔ Pour annoncer la couleur : \033[
➔ Pour finir la définition de couleur : m
➔ Pour remettre la valeur initiale : \033[0m
exemple :
$ echo -e "voici du \033[1;32mvert\033[0m
Les scriptsVersion : 0.6 133
Les commandes internes au shell
read Lecture au clavier et stockage des caractères saisis dans la ou les variables spécifiées, utilisé dans les scripts pour capturer une saisie clavier
$ echo "Veuillez entrer votre nom : "
$ read nom
$ echo "Bonjour $nom"
En ksh un syntaxe alternative est disponible :
$ read nom?"Veuillez entre votre nom : "
echo Affichage écran
$ echo expression
Si expression contient des caractères spéciaux, il faut la protéger avec des quotes.
\c inhibe le changement de ligne en fin de commande echo
\n nouvelle ligne
\t tabulation horizontale
\\ le caractère \
Note : en bash, il faudra utiliser le paramètre "e" pour prendre en compte les caractères spéciaux
exec Exécution d'une commande externe sans création de sousshell. ATTENTION : à la fin de la commande, le shell père est tué.
exec cmd
cd Changement de répertoire. ATTENTION : les changements de répertoires effectués dans un sousshell sont ignorés du shell père.
exit Sortie du shell (script)
exit [ n ] n est la valeur retournée au shell père dans la variable ?
Les scriptsVersion : 0.6 134
shift Glissement des paramètres. Supprime la valeur du premier paramètre et décale toutes les autres valeurs vers la gauche.
shift [ n ] n : valeur entière correspondant au pas de décalage
Après chaque décalage, les valeurs des variables #, @ et * sont remises à jour.
expr Calcul arithmétique. Si une variable est spécifiée, son contenu doit être numérique.
expr expression
Chaque opérateur doit être précédé et suivi d'un espace.
$ expr 2 + 7
$ expr 2 \* 7
nota : les commandes let et (( .... )) remplacent avantageusement expr, nous les étudions au chapitre "L'arithmétique entière"
Les scriptsVersion : 0.6 135
les conditions (test, if, case)
test Evaluation de condition
test condition
[ condition ] La condition doit être précédée et suivie d'un espace
Éléments de la condition :
Opérateurs entiers :eq égaliténe différencegt supérieurge supérieur ou égallt inférieurle inférieur ou égal
Opérateurs chaîne :
= égalité!= différencen nomvar variable non nullez nomvar variable nulle
Opérateurs de fichiers :d nomfich répertoiref nomfich fichier ordinairep nomfich tube nomméc nomfich périphérique caractèreb nomfich périphérique blocw nomfich droit d'écriturer nomfich droit de lecturex nomfich droit d'exécutions nomfich taille de nomfich > 0
Combinaisons :
a et ( laisser un espace autour de a et de o)o ou! négation( ) regroupement ( à isoler par des antislashs ex : \( ........ \)
Les scriptsVersion : 0.6 136
break Dans une structure répétitive, permet de sortir de la structure.
continue Dans une structure répétitive, permet de retourner à la condition.
Enrichissement de la commande test : [[…]]
Cette syntaxe permet l'utilisation des caractères spéciaux pour la comparaison de chaînes :
* 0 à n caractères
? 1 caractère quelconque
[…] 1 caractère parmi ceux entre crochets
[!...] 1 caractère n'étant pas entre crochets
Pour les caractères suivant, s'assurer que l'option extglob est activée
$ shopt
$ shopt -s extglob
?(...) 0 à 1 fois l'expression
*(...) 0 à n fois l'expression
+(...) 1 à n fois l'expression
@(...) 1 fois l'expression
!(...) 0 fois l'expression
*(...|...) De 0 à n fois l'expression 1 ou l'expression 2
valables également pour les caractères ? * + @ !
Exemple :
$ var=+123
$ [[ $var = ?([+-])+([0-9]) ]] && echo "Le nombre est valide"
var contient un nombre valide
tester avec 123, 132, 123.56
Les scriptsVersion : 0.6 137
améliorer le test en ajoutant la prise en compte des nombres décimaux
Attention : les opérateurs a et o sont remplacés par && et ||
exemple :
Syntaxe normale
$ [ -f fic1 -a \( -d rep1 -o -d rep2 \) ] && echo OK
Syntaxe avec [[ …. ]]
$ [[ -f fic1 && ( -d rep1 || -d rep2 ) ]] && echo OK
Les scriptsVersion : 0.6 138
TP : scripting utiliser les éléments base
1. Créer le script "test_var_read.sh" qui :
• prend un nom en argument. Si aucun argument n'est passé il demande la saisie du nom à l'utilisateur.
• si aucun nom n'est saisi, attribue le nom "invité"
• si le nom est "root":
• affiche "Interdit de se connecter en root" en rouge gras sur fond noir
• quitte le script avec le code retour 4
• Affiche : Bonjour <nom>, bienvenue sur la machine <nom_de_la_machine>
• si le nom est invité, affiche : "vous avez été redirigé sur le compte "invité"
• si le nom n'est pas invité, affiche : "Vous vous êtes connecté en <nom>"
• affiche : "Le script s'est correctement déroulé"..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
Les scriptsVersion : 0.6 139
if else
if condition
then action
[ elif condition
then action ]
[ else action ]
fi
condition peut être exprimée par : test condition ou [ condition ]
action est une instruction ou un ensemble d'instructions
Utilisation des structures imbriquées
if ………
then ………
elif ………
then ………
fi # le fi est commun avec elif
différent de
if ………
then ………
else
if ………
then ………
fi # le fi pour le second if
fi # le fi pour le premier if
Les scriptsVersion : 0.6 140
read rep
if [ z "$rep" ]
then echo "réponse nulle"
if [ $# eq 0 ]
then echo "Pas de paramètres"
exit
case
case $nomvar in
expr)
action
;;
expr)
action
;;
*)
action
;;
esac
case $var in
p)echo "la lettre est p"
;;
[0-9])
echo "un chiffre"
;;
a|b)
echo "a ou b"
echo "\?"
;;
*)
echo "n'importe quel autre caractère"
;;
esac
Nota : La commande case autorise l'utilisation de la substitution de caractères, même avec les expressions complexes
Les scriptsVersion : 0.6 141
les boucles (while, until, for)
while
while : tant que
Tant que la condition est remplie, on reste dans la boucle :
while CONDITION
do
ACTIONS
done
Exemple : imposer la saisie du nom à l'usager :
while [ -z "$nom" ]
do
echo -e "Veuillez entrer votre nom : \c"
read nom
done
echo Bonjour $nom
Il est possible de générer des boucles infinies avec le caractère " : ". Dans ce cas, la boucle se répète indéfiniment, on pourra utiliser cettre propriété pour la création de menus par exemple.
while :
do
echo menu
echo "1) copie des fichiers"
echo "2) restauration des fichiers"
echo "q) Quitter"
echo -e "Taper 1, 2 ou q pour continuer : \c"
read choix
case $choix in
1) echo copie des fichiers; read ;;
2) echo restauration des fichier; read ;;
q) exit 0;;
*) saisie incorrecte;;
Les scriptsVersion : 0.6 142
esac
done
until
until : Jusqu'à ce que
On reste dans la boucle jusqu'à ce que la condition soit remplie
until s'utilise en alternative de la boucle while
until CONDITION
do
ACTIONS
done
exemple :
until [ -n "$age" ]
do
echo -e "Saisissez votre age : \c"
read rep
done
Les scriptsVersion : 0.6 143
for
La boucle for permet de réaliser des actions en fonction d'une liste de valeurs qui lui est fournie.
for nomvar in LISTE
do
ACTIONS
done
$ for var in 1 2 b toto
>do
>echo "la valeur est : $var"
>done
la valeur est : 1
la valeur est : 2
la valeur est : b
la valeur est : toto
$
Cas particulier de la boucle for :
for (( initialisation de VAR; contrôle de VAR; modification de VAR))
do
ACTIONS
done
Exemple : compte à rebours :
for (( i=10; i>=1; i-=1 ))
do
echo "mise a feu dans $i sec."
sleep 1
done
echo '!!! BOUM !!! '
Les scriptsVersion : 0.6 144
NOTA: la boucle for utilise la valeur de la variable interne IFS (Internal Field Separator) comme champs de séparation. Il est parfois pratique de modifier cette valeur.
# set | grep ^IFS
IFS=$' \t\n'
Les scriptsVersion : 0.6 145
TP : scripting les structures de contrôle
1. faire une copie du script "test_var_read.sh" en "if.sh". Modifier le script pour utiliser la structure if elif dans les test.
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
Les scriptsVersion : 0.6 146
2. Faire une copie de "if.sh" en "case.sh". Modifier le script pour utiliser la structure case à la place de if elif.
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
Les scriptsVersion : 0.6 147
3. faire un copie du fichier "case.sh" en "while.sh" Modifier le script "while.sh" en obligeant la saisie clavier lorsque aucun argument n'a été fournit :
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
Les scriptsVersion : 0.6 148
4. Créer le script for.sh qui créé une sauvegarde de tous les fichiers du répertoire courant se terminant par ".sh" :
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
Les scriptsVersion : 0.6 149
les fonctions
Les fonctions permettent de regrouper plusieurs commandes qui pourront être exécutées de façon régulières durant le script.
Il sera possible de les mettre dans un fichier séparé, permettant un script plus lisible et la possibilité de les réutiliser pour d'autres scripts.
Les fonctions peuvent être invoquées avec des paramètres, comme pour un fichier de script.
Syntaxe de définition d'une fonction
nomfonction()
{
instructions qui composent la fonction pour fournir le résultat recherché
}
Exemple
Définition dans un fichier indépendant :
Les scriptsVersion : 0.6 150
Intégration du fichier bodyfonc et appel des différentes fonctions définies
Définition de la fonction directement dans le script où elle est référencée
Appel de la fonction
L'appel de la fonction se fait simplement en donnant son nom.
Il est possible de passer des paramètres positionnels à l'appel de la fonction de la même manière que le passage de paramètres lors de l'exécution d'une commande ou d'un script.
Les scriptsVersion : 0.6 151
TP : scripting les fonctions
1. Créer le script fonctions.sh qui propose de :
• sauvegarder les fichiers du répertoire courant se terminant par .sh avec l'extension .save
• supprimer les fichiers se terminant par .save
• quitter
Un autre fichier fonctions.fonc comportera les fonctions de sauvegarde et de suppression...................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
Les scriptsVersion : 0.6 152
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
Les scriptsVersion : 0.6 153
Des commandes pour les scripts
eval double évaluation
Le mécanisme de substitution est fait par le shell en balayant une fois les commandes et en interprétant les caractères de substitution.
On peut doubler ce passage par la commande eval
Il y a alors évaluation de la commande située derrière eval et ensuite exécution de cette commande. Cela permet, dans certains cas, d'effectuer deux passages de substitution.
Exemple
nom=Martin
var=nom
# Comment afficher le contenu de 'nom' en passant par 'var' ?
echo $var
nom # c'est nom qui s'affiche
echo $$var
2201var # ici, c'est la variable $$ suivi de var
echo ${$var}
${$var} : mauvaise substitution
eval echo \$$var
Martin # ça y est, grâce à la commande eval
Des commandes pour les scripts Version : 0.6 154
trap gérer les signaux
Les signaux renvoyés aux scripts ou au shell courant peuvent être interceptés par la commande trap afin de modifier leur comportement.
Rappel sur les principaux signaux :
Nom N° Usage
HUP 1 Rupture d'un ligne de terminal
relecture du fichier de configuration (pour les daemons)
INT 2 Arrêt prématuré du processus, en général ^C au clavier
TERM 15 Arrêt normal du processus
KILL 9 Arrêt inconditionnel.
Attention : on ne peut pas intercepter ce signal
kill l : affiche la liste de tous les processus
stty a : affiche les paramètres du terminal
syntaxe : trap ' <cmd1> ; <cmd2 >' <signal1> <signal2>
exemples:
faire un ^C renverra le résultat de la commande écho, sans interrompre le programme en cours
$ trap 'echo Ne pas interrompre' INT
ignorer totalement le signal SIGINT
$ trap '' 2
Supprimer les fichiers se terminant par tmp et sortir à la réception du signal INT ou TERM.
$ trap 'rm -f *.tmp ; exit 1' INT TERM
remettre les valeurs par défaut
$ trap 2 15
idem
$ trap – INT TERM
Des commandes pour les scripts Version : 0.6 155
clear effacement écran
Syntaxe : clear
Commande simple sans argument, permettant d'afficher une page écran vierge.
Des commandes pour les scripts Version : 0.6 156
tr suppression, remplacement de caractères
La commande tr agit uniquement caractère par caractère, elle permet de :
Supprimer des caractères
Afficher le fichier Edition sans les a, les b et les c :
$ cat Edition | tr -d abc
Remplacer des caractères par d'autres caractères
Afficher le fichier Edition avec les a, le b et les c remplacés respectivement par des x, des y et des z :
$ cat Edition | tr abc xyz
Afficher tout le contenu du fichier Edition en majuscule :
$ cat Edition | tr "[a-z]" "[A-Z]"
$ cat Editon | tr "[:lower:]" "[:upper:]"
Supprimer les doublons de caractères contigus
Supprimer les doublons des espaces contigus au résultat de la commande who :
$ who | tr -s " "
Afficher le fichier Edition sans lignes vides
$ cat Edition | tr -s "\n"
Explication : une fin de ligne comporte toujours le caractère (non visible) \n. Une ligne vide comporte donc uniquement ce caractère, si bien que la ligne précédente se terminant par un \n est suivi lorsqu'une ligne est vide d'un autre \n.
Combiner ces possibilités
transformer tous les espaces en | (tube) et supprimer les doublons de | (tubes) en sortie de commande who
$ who | tr -s " " "|"
Des commandes pour les scripts Version : 0.6 157
cut Découpage vertical de fichier
Syntaxe : cut c listecols [ nomfichier ]
cut f listechps [ d carsep ] [ s ] [ nomfichier ]
c listcols Spécifie les caractères sélectionnés. La liste de caractères peut être composée d'intervalles ( .... ) et/ou d'énumérations ( .. , .. , .. )
f listchps Spécifie les champs sélectionnés. La liste de champs peut être composée d'intervalles ( .... ) et/ou d'énumérations ( .. , .. , .. ). Un champ est, par défaut, déterminé par une tabulation.
d carsep Spécifie carsep comme séparateur de champs à la place de la tabulation. Si ce caractère est un caractère spécial, il doit être protégé de quotes.
s Utilisé avec l'option f, permet de supprimer les lignes sans caractère séparateur
nomfichier Nom du fichier à traiter. Ce nom peut être générique. A défaut de nom, la commande travaille sur le flux d’entrée.
Des commandes pour les scripts Version : 0.6 158
split Découpage de fichier en blocs de lignes
Syntaxe : split [ nbl ] [ a lgs ] [ nomfichier [ racine ] ]
nbl Nombre de lignes qui compose chaque bloc. Par défaut 1000.
a lgs Nombre de caractères du suffixe. Par défaut 2, composé de lettres : aa, ab, ac, ad…
nomfichier Nom du fichier à traiter. Ce nom peut être générique. A défaut de nom, la commande travaille sur le flux d’entrée, mais dans ce cas, il n'est pas possible de spécifier une racine.
racine Racine utilisée par la commande split pour générer les noms de fichiers. Par défaut la lettre 'x' est utilisée. A cette racine, split ajoute un suffixe composé d'au moins deux lettres.
Des commandes pour les scripts Version : 0.6 159
paste Fusion de lignes de fichiers
Syntaxe : paste [ s ] [ d liste ] nomfich1 nomfich2 …
s Fusion des lignes d'un ou plusieurs fichiers
d liste Liste de séparateurs de champs. Cette liste peut être composée de n'importe quel caractère et de caractères qui seront interprétés tels que :
\n nouvelle ligne \t tabulation
\\ backslash \0 chaîne vide (aucun caractère)
Les caractères sont interprétés les uns après les autres de manière circulaire.
Par défaut, le séparateur est une tabulation.
nomfich1 2 Nom du ou des fichiers à traiter.
Des commandes pour les scripts Version : 0.6 160
sort Tri des lignes de fichiers
Syntaxe : sort [ optcom ] k [ Fdeb [ .Cdeb ] ] [ optionTri ] , [ Ffin [ .Cfin ] ] [ optionTri ] nomfich
sort [ optcom ] [ +Fdebsaut [ .Cdebsaut ] ] [ optionTri ] [ Ffinsaut [ .Cfinsaut ] ] [ optionTri ] nomfich
Options qui modifient le comportement par défaut de la commande sort :
c Contrôle que l'entrée est bien triée
m Fusionne plusieurs fichiers d'entrée s'ils sont déjà triés
u Demande de suppression des valeurs en double dans les critères de tri définis
Options de tri :
optcom Options communes de tri qui seront prises en compte pour tous les critères
optionTri Option propre au critère qui la précèdeb Ignore les espaces situés en début de critèred Tri par ordre du dictionnaire, seuls les lettres, les chiffres et les
espaces sont pris en comptef Transforme les minuscules en majuscules avant la comparaisoni Ignore les caractères non imprimablesn Tri de type numériquer Inverse l'ordre de tri qui par défaut est croissant
Première méthode ( k )
Fdeb Champ de début de critère de tri
.Cdeb Caractère, dans le champ, de début de critère de tri
Ffin Champ de fin de critère de tri
.Cfin Caractère, dans le champ, de fin de critère de tri
Seconde méthode (+ )
Fdebsaut Nombre de champs ignorés. Le début du critère correspond au début du champ suivant
.Cdebsaut Nombre de caractères ignorés dans le champ. Le début du critère correspond au caractère suivant
Des commandes pour les scripts Version : 0.6 161
Ffinsaut Nombre de champs ignorés. La fin du critère correspond au début du champ suivant
.Cfinsaut Nombre de caractères ignorés dans le champ. La fin du critère correspond au caractère suivant
Quelle que soit la méthode utilisée, si le critère de début n'est pas spécifié, il correspond par défaut au début de la ligne, si le critère de fin n'est pas spécifié, il correspond par défaut à la fin de la ligne.
Si aucun critère de tri n'est spécifié, le critère retenu par défaut est la ligne entière.
Des commandes pour les scripts Version : 0.6 162
uniq supprimer les doublons de lignes
uniq permet de supprimer les lignes consécutives en plusieurs exemplaires afin de n'en conserver qu'une. Il est impératif que les lignes se suivent, aussi il faudra prendre soin de trier le fichier si nécessaire.
syntaxe : uniq [ options ] [ fichier1 [ fichier2]]
c chaque ligne est préfixée du nombre d'occurences trouvées
d n'affiche que les lignes en plusieurs exemplaires
u n'affiche que les lignes uniques
s n ignore les n premiers caractères dans la comparaison
w n compare jusqu'à n caractères dans chaque ligne
f n ignore les n premiers champs, délimités par espace ou tabulation
i igrore la casse
Exemple :
$ sort fic1 | uniq
Des commandes pour les scripts Version : 0.6 163
awk Présentation de l'utilitaire
Awk est un utilitaire qui permet de travailler sur le contenu d'un ou plusieurs fichiers.
Il possède des variables internes positionnées à la lecture des lignes. Parmi ces variables, les suivantes sont très intéressantes :
NF nombre de champs de la ligne
NR numéro de la ligne courante dans le fichier
FILENAME nom du fichier ouvert
$n le nième champ de la ligne
Structure du programme
Awk permet d'écrire des programmes complets avec des itératives, tests…
Le programme peut être passé en paramètre (en ligne de commande) à awk, dans ce cas, il sera protégé de quotes.
Il peut aussi être saisi dans un fichier dont le nom sera fourni à awk par l'option –f.
Structure générale :
[ BEGIN { action(s) begin } ]
[ sélection1 ] [ { action(s) 1 } ]
[ sélection2 { action(s) 2 } ]
…
[ END { action(s) end } ]
Si une telle structure est utilisée, le fonctionnement du programme sera le suivant :
Des commandes pour les scripts Version : 0.6 164
avant la lecture du fichier, awk exécute les actions "begin"
pour chaque ligne du fichier, awk évalue les sélections : si la sélection est valide pour la ligne courante, l'action ou les actions sont exécutées.
Si plusieurs sélections sont valides pour une ligne, alors toutes les actions correspondantes seront exécutées.
après lecture complète du fichier, awk exécute les actions "end".
Remarque :
Aucun des éléments de la structure cidessus n'est obligatoire lors de l'écriture d'un programme awk.
La séquence BEGIN { } et / ou la séquence END { } peuvent être absentes.
Si la sélection n'est pas spécifiée, l'action est exécutée pour toutes les lignes du fichier.
Si l'action n'est pas spécifiée, les lignes qui vérifient la sélection sont recopiées sur la sortie standard.
Séparateur de champs
Par défaut, le séparateur de champs est l'espace ou la tabulation.
Il est toutefois possible de le modifier :
avec l'option –Fs associée à la commande awk, où s est le nouveau séparateur
en affectant la variable FS dans la séquence BEGIN { } du programme
Description d'une action
Une action correspond à une séquence de code en langage C. La différence, c'est que awk est interprété (non compilé comme le langage C) ce qui n'oblige pas à déclarer toutes les variables utilisées.
Une variable non déclarée est toujours nulle ou vide à la première utilisation.
Toute constante de chaîne doit être encadrée par des double quotes.
Lors d'une affectation, il est possible de concaténer des champs en les séparant par des espaces.
Des commandes pour les scripts Version : 0.6 165
Fonctions internes
Les fonctions de manipulations de champs et d'impression sont les plus intéressantes, parmi les plus utilisées :
Permet d'imprimer un résultat
Chaque fonction print provoque un retour à la ligne
Il est possible d'utiliser la fonction print avec ou sans paramètre (voir les exemples suivants)
printf
Identique à la fonction print avec un formatage de la sortie.
{ printf ( "options formatage" , valeurs à imprimer ) }
Principales options de formatage :
%c 1 caractère
%s 1 tableau de caractères
%nbs chaîne cadrée à gauche
nb longueur de la chaîne, avec complément par espace
%d valeur entière
%nbd valeur entière avec un nombre de positions nb
%f réel
%e.df réel avec :
e nombre d'entiers
. séparateur décimal
d nombre de décimales
sprintf
Identique à la fonction printf avec affectation du résultat à une variable (sans utiliser la sortie standard)
{ vares = sprintf ( " %3d %4.2f " , $1 , $2 ) }
Des commandes pour les scripts Version : 0.6 166
length
Retourne la longueur de la ligne ou d'un champ passé en argument
{ print length($1) } longueur du champ 1
{ print length( ) } longueur de la ligne
index
Retourne la position d'une souschaîne dans la ligne ou dans un champ passé en argument
{ print index($1,"RECH") } position de "RECH" dans le champ 1
match
Identique à index, mais la souschaîne est remplacée par une expression régulière
{ match($1,"[EJ]") } position de "E" ou "J" dans le champ 1
substr
Extraction d'une chaîne à partir d'une position sur une longueur spécifiée
{ substr($1,2,3) } extraction du champ 1 de 3 caractères à partir du deuxième
sub
Substitution d'une chaîne par une autre
{ sub("recherche","remplacement", $1) }substitution de la chaîne "recherche" par la chaîne "remplacement" dans le champ 1
gsub
Identique à sub, mais agit sur toutes les occurrences de la chaîne recherchée
split
Décomposition d'un champ en souschamps (séparés par un caractère spécifié) avec valorisation d'un tableau.
Des commandes pour les scripts Version : 0.6 167
Dans l'exemple cidessus, on décompose la chaîne de caractères en souschamps, séparés par "_", le nombre de souschamps est affecté à une variable n, puis la valeur de chaque souschamp est affichée dans une boucle for (syntaxe du langage C)
toupper, tolower
Conversion en majuscules et en minuscules
{ print toupper( $1 ) } affiche le champ 1 en majuscules
{ print tolower( $1 ) } affiche le champ 1 en minuscules
Pour des applications relativement simples, il est possible de déterminer une liste d'instructions au niveau de la ligne de commande, tel que dans les exemples suivants :
Pour des applications un peu plus complexes, il est conseillé de créer un fichier qui contient les différentes instructions, tel que dans les exemples suivants :
Affichage des lignes pour lesquelles le nombre de champs est > 2 et affichage du premier champ si le troisième champ se termine par 1 ou 4
$ cat progawk
NF > 2 { print $0 }
$3 ~ /[14]$/ { print $1 }
On lance ensuite le programme par la commande :
$ awk –f progawk clients
Impression et calcul d'un total à partir d'un fichier de données :
Des commandes pour les scripts Version : 0.6 168
La section BEGIN permet d'imprimer les entêtes de colonnes et d'initialiser la variable total.
L'action composée de la fonction printf est appliquée à chaque ligne du fichier :
%10s cadrage à gauche du premier champ sur un nombre de positions égal à 10
%7d entier sur 7 positions
\n retour à la ligne
$1,$2 impression des champs 1 et 2
total += $2 cumul du champ 2 dans la variable total
La section END permet d'imprimer la valeur totale obtenue par le cumul
Exemples :
Afficher les champs 1, 2 et 3 du fichier clients lorsque la ligne se termine par 2 ou 3 :
awk '/[23]$/ { print $1, $2, $3 }' clients
Afficher les lignes du fichier clients lorsque le champ 3 commence par 2 ou 3 :
awk '$3 ~ /^[23]/ { print }' clients
Afficher le numéro de ligne et les champs 1 et 2 du fichier clients :
awk '{ print NR , $1 , $2 }' clients
Des commandes pour les scripts Version : 0.6 169
Afficher le nombre de champs de la ligne, le champ 1 et le dernier champ du fichier clients :
awk '{ print NF , $1 , $NF }' clients
Afficher les lignes du fichier clients dont le champ 3 est égal à 222222 :
awk '$3 == "222222" { print }' clients
Il est possible d'utiliser des opérateurs booléens pour exprimer une condition. Ces opérateurs sont les suivants :
&& ET|| OU| NOT
Exemple d'utilisation : afficher les lignes dont le champ 3 est égal à 222222 et dont le champ 2 commence par P :
awk '$3 == "222222" && $2 ~ "^P" {print}' clients
Utiliser les conditions :
Afficher les utilisateurs ayant un UID compris entre 500 et 10 000 :
awk -F":" '{ if ($3 >= 500 && $3 <= 10000) print }' /etc/passwd
Des commandes pour les scripts Version : 0.6 170
TP : scripting les commandes
1. Modifier le script fonctions.sh afin d'en interdire l'interruption par ^C. Un message "Veuillez taper q pour quitter le script" est renvoyé à l'utilisateur dans ce cas.
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
2. Modifier le script fonction.sh afin de toujours afficher le menu en haut de la fenêtre de la console.
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
3. Ajouter un nouvel item au menu en proposant d'afficher les noms et adresses IP de la machine.
Exemple :
nom et adresse IP :eth0 10.11.100.101/16eth1 172.16.5.1/24
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
..................................................................................................................................................
Des commandes pour les scripts Version : 0.6 171
Plus loin avec les variables
Substitution de variables
Utiliser une variable, si celleci n'est pas définie (ou vide) utiliser une valeur explicite
Afficher la valeur de $nom, si celleci n'est pas définie, afficher 'invité'
$ echo ${nom-invité}
Utiliser le 2eme paramètre, si celui est absent utiliser la valeur 'defaut'
$ user=${2-nobody}
Afficher la valeur de $nom, si celleci n'est pas définie ou vide, afficher 'invité'
$ echo ${nom:-invité}
Utiliser une variable, si celleci n'est pas définie (ou vide), lui affecter une valeur
Afficher la valeur de $nom, si celleci n'est pas défini lui affecter la valeur 'invité'
$ echo ${nom=invité}"
Afficher la valeur de $nom, si celleci n'est pas défini ou vide lui affecter la valeur 'invité'
$ echo "Entrer votre nom :"
$ read nom
$ echo "Bonjour ${nom:=invité}"
Retourner la longueur d'une variable :
$ var=caractères
$ echo ${#var}
10
Plus loin avec les variablesVersion : 0.6 172
Retirer le plus petit fragment à gauche : #
$ var=fic.save
$ echo ${var#??}
c.save
$ echo ${var#*.}
save
Retirer le plus grand fragment à gauche : ##
$ var=/usr/bin/test.sh
$ echo ${var##*/}
test.sh
Retirer le plus petit fragment à droite : %
$ var=fic.save
$ echo ${var%.*}
fic
Retirer le plus grand fragment à droite : %%
$ var=fic.save.save
$ echo ${var%%.*}
fic
Plus loin avec les variablesVersion : 0.6 173
L'arithmétique entière
Les commandes let et (( …. )) présentent de nombreux avantages sur la commande expr:• nombre d'opérateurs plus important
• pas besoin de séparer les arguments par des espaces
• les variables n'ont pas besoin d'être invoquées avec le signe $ (mais peuvent l'être)
• il n'est pas nécessaire de protéger les caractères spéciaux du Shell.
• Les affectations peuvent être faites dans la commande
Déclarer une variable de type "entier"
$ typeset -i variable2=20
Lister les variables de type "integer"
$ typeset -i
Les commandes let et (( … )) ne nécessitent pas de déclarer des variables de type entier :
$ let "k=i+j" OU ((k=i+j))
Les opérateurs arithmétiques sont :+ addition soustraction* multiplication/ division% reste de la division (modulo)
Les opérateurs de comparaison sont :<= inférieur ou égal>= supérieur ou égal> strictement supérieur< strictement inférieur== égal!= différent
$ i=15 ; j=10
$ (( i > j )) && echo "i est supéieur à j"
Plus loin avec les variablesVersion : 0.6 174
Les opérateurs logiques sont :! négation&& et|| ou
Syntaxe qui permet de savoir si k=i+j et h=k*2 :
Astuce :
la commande (( … )) ne renvoie rien, la syntaxe suivant ne sera donc pas valable :
$ nb=10
$ echo nb vaut `(( nb + 15 ))`
nb vaut
pour avoir l'affichage il faudra utiliser le caractère $ du shell :
$ nb=10
$ echo nb vaut $(( nb + 15 ))
nb vaut 15
Plus loin avec les variablesVersion : 0.6 175
les variables de tableau
Classiquement, pour créer puis afficher une variable
$ client=Dupont
$ echo $client
Dupont
Mais nous aurions aussi pu l'afficher en utilisant cette syntaxe :
$ echo ${client}
Dupont
Implicitement, la valeur d'une variable est définie comme étant le premier élément d'une variable de tableau. Pour afficher le premier index d'une variable de tableau :
$ echo ${client[0]}
Dupont
pour afficher le deuxième index d'une variable de tableau:
$ echo ${client[1]}
Aucune erreur n'est renvoyée, en fait, le deuxième index de la variable n'est pas rempli.
$ client[1]=Alexandre
$ echo ${client[1]}
Alexandre
Pour afficher le contenu de la variable entière
$ echo ${client[*]}
Dupont Alexandre
Il est possible de positionner une variable pour spécifier un numéro d'index :
$ prenom=1
$ echo ${client[prenom]}
Alexandre
Afficher le nombre de valeurs que comporte une variable de tableau
$ echo ${#client[*]}
Nota : Les variables de tableau vont de 0 à 1023
Plus loin avec les variablesVersion : 0.6 176
TP : scripting scripts de synthèse
1. Classer mes images
étape 1
Créer un script de classement de fichier
année mois jour fichiers→ → →
attention: les dates ne doivent pas être modifiées
étape 2
spécifier les formats de fichiers (*.jpg, *.avi, *.raw)
étape 3
pouvoir afficher/ajouter/supprimer des extensions de fichiers
2. Surveillance de serveurs
Créer un script que l'équipe MCO (maintien en condition opérationnelle) lancera chaque matin.
– espace disque : vérifier que l'espace disponible est supérieur à un seuil
– services : vérifier que les services syslogd et kjournald sont opérationnels (des services doivent pouvoir être ajoutés
– fichiers journaux : afficher les messages significatifs du jour du fichier /var/log/messages
3. Afficher les membres d'un groupe donné
Créer un fichier script members.sh qui permet d'afficher les membres d'un groupe donné en argument ou par saisie clavier. Attention au
Plus loin avec les variablesVersion : 0.6 177
Index des commandes
Aalias 119awk 164
Bbg 86
Ccal 19case 141cat 48cd 31chgrp 98chmod 101chown 97clear 156cmp 54compress 108cp 39cut 158
Ddate 18diff 55
Eeval 154
Ffg 86file 42find 65for 144
Ggrep 64gunzip 110gzcat 110gzip 108
Hhead 51
Iid 14if 140
Jjobs 86
Kkill 84
Lless 50ln 57logname 14ls 34
Mman 21mkdir 32more 49mv 41
Nnewgrp 99nice 89
P
Index des commandesVersion : 0.6 178
passwd 17paste 160ps 83pwd 30
Rrenice 90rm 40rmdir 33
Ssort 161split 159
Ttail 52tar 105tee 94test 136time 85trap 155
tty 13
Uumask 100unalias 121uncompress 110uniq 163unix2dos 78until 143
Vvi 69
Wwc 53while 142who 16who am i 15
Zzcat 110
Index des commandesVersion : 0.6 179
mémo de vi
Sortie de VI
:q!<CR> sort sans sauvegarde
ZZ<CR> sort avec sauvegarde
:wq<CR> idem (date de modification toujours changée)
:x<CR> idem (sans modification de date si aucun changement)
:sh<CR> sort avec un shell fils
:!cde<CR> sort temporairement avec cde
Insertion de texte
a<txt><ESC> insère après le curseur
i<txt><ESC> insère avant le curseur
A<txt><ESC> insère à la fin de la ligne courante
I<txt><ESC> insère au début de la ligne courante
o<txt><ESC> insère une ligne après la ligne courante
O<txt><ESC> insère une ligne avant la ligne courante
Déplacement du curseur
Sur caractères
Flèches déplace le curseur d'un caractère
Sur lignes
^ déplace le curseur en début de ligne courante
$ déplace le curseur en fin de ligne courante
<CR> déplace le curseur en début de ligne suivante
déplace le curseur en fin de ligne précédente
mémo de viVersion : 0.6 180
Sur page courante
H déplace le curseur en tête de la page
M déplace le curseur au milieu de la page
L déplace le curseur à la fin de la page
Sur mots
w déplace le curseur au début du mot suivant
W idem avec l'espace comme séparateur imposé
b / B déplace le curseur au début du mot courant
e / E déplace le curseur à la fin du mot courant
Sur phrases
( déplace le curseur au début de la phrase courante
) déplace le curseur à la fin de la phrase courante
Sur paragraphes
{ déplace le curseur au début du paragraphe courant
} déplace le curseur à la fin du paragraphe courant
Sur chaînes de caractères
/chaîne<CR>déplace le curseur sur chaîne
?chaîne<CR> idem en remontant dans le fichier
//<CR> recherche chaîne suivante
??<CR> idem en remontant dans le fichier
n recherche dans le même sens
N recherche en inversant le sens
Sur autres pages
z.<CR> affiche la page centrée sur ligne courante
z<CR> affiche la page avec ligne courante en haut
z<CR> affiche la page avec ligne courante en bas
<CTL>D affiche la page une demipage en bas
mémo de viVersion : 0.6 181
<CTL>U affiche la page une demipage en haut
<CTL>F affiche la page une page en avant
<CTL>B affiche la page une page en arrière
:n<CR> affiche la page avec ligne n en haut
nG idem
:$ ou G affiche la dernière page
Destruction
De caractères
x détruit le caractère courant
3x détruit 3 caractères à partir du courant
X détruit le caractère précédent
De mots
dw détruit le mot courant à partir du curseur
3dw détruit 3 mots à partir du mot courant
De lignes
dd détruit la ligne courante
3dd détruit 3 lignes à partir de la ligne courante
De texte
d$ détruit la fin de ligne à partir du curseur
d/chaîne détruit jusqu'à chaîne non comprise
Remplacement
De caractères
rc remplace le caractère courant par "c"
R<txt><ESC> remplace 3 caractères par les lettres "txt"
s<txt><ESC> remplace le caractère courant par "txt"
mémo de viVersion : 0.6 182
De mots
cw<txt><ESC> remplace un mot par "txt"
De lignes
S<txt><ESC> remplace la ligne courante par "txt"
De texte
C ou c$ remplace la fin de ligne
c/chaîne remplace jusqu'à chaîne non comprise
Copie de texte
y3w met les 3 mots dans le tampon
Y ou yy idem pour la ligne courante
5yy idem sur 5 lignes
p copie du tampon après le curseur
P copie du tampon avant le curseur
Possibilité de préfixer ces commandes de "x , où x correspond au nom du tampon (une et une seule lettre).
Divers
u annule la dernière directive de modification
U restaure la ligne courante
. répète la dernière modification
:r fic2<CR> contenu de fic2 inséré dans tampon de vi
:r !cmd<CR> résultat de cmd inséré dans tampon de vi
:e fic2<CR> chargement de fic2 dans tampon courant
:e #<CR> retour au fichier initial
J concatène la ligne courante et la suivante
<CTRL>L rafraîchit l'écran
~ inverse majuscule < > minuscule (possibilité de faire précéder d'un nombre de caractères)
:set nu<CR> affiche la numérotation des lignes
:set nonu<CR> supprime la numérotation des lignes
mémo de viVersion : 0.6 183
mémo sur les tests
Sur fichiers
r/w/x fic vrai si fic existe et a le droit r, w ou x
f/d fic vrai si fic existe et est ordinaire ou répertoire
b/c fic vrai si fic existe et est en mode bloc ou caractère
s fic vrai si fic existe et n'est pas vide
fic1 ef fic2 vrai si fic1 et fic2 sont liés
L fic1 vrai si fic1 est un lien symbolique
fic1 ot fic2 vrai si date de modif de fic1 plus vieille
fic1 nt fic2 vrai si date de modif de fic1 plus récente
Sur numériques
eq / ne / gt / ge / lt / le
== / != / > / >= / < / <=
Sur chaînes de caractères
ch1 = ch2 vrai si chaîne1 égal à chaîne2
ch1 != ch2 vrai si chaîne1 différente de chaîne2
z chaîne vrai si chaîne existe et est vide
n chaîne vrai si chaîne existe et n'est pas vide
mémo sur les testsVersion : 0.6 184
top related