Vi comment l'utiliser ?

2. Édition de textes sous Linux

Une des tous premiers utilitaires dont on a besoin sur tout système 
d'exploitation, c'est un éditeur de texte. Par ''texte'', j'entends
bien sûr les textes ''brut'', sans formatage. 
Sur les systèmes de type Unix,
on est certain de trouver le célèbre éditeur vi, même sur les
systèmes très anciens : vi est livré en standard sur tous les
Unix, ce qui en fait l'éditeur à base installée la plus large, le plus
utilisé.
Il en existe un autre, GNU/Emacs, très performant et
très versatile. Écrit par Richard Stallman lui-même (alias RMS),

Emacs sait éditer des textes, lire des mails ou des news, 
lancer un shell, etc. Mais il n'est pas toujours installé,
car il occupe beaucoup plus d'espace disque.

2.1 Qu'est-ce que vi ?

vi, est une abréviation pour ''VIsual editor''.
C'est une extension de ed et ex, deux éditeurs
plus anciens ne pouvant éditer les fichiers que ligne par ligne.
Mais vi est tout de même un éditeur plein écran. 

vi est rapide, puissant et compact : il tient sur une 
disquette de boot, capacité que lui envient pas mal d'autres éditeurs. 
Sous Linux existe une version améliorée de vi. 
Il s'agit de vim, pour ''VI iMproved''.
Il est tout de même nettement conseillé d'utiliser vim
plutôt que vi, car il dispose d'un certain nombre de 
fonctionnalités supplémentaires que d'aucun jugerait indispensable 
d'un point de vue confort. Néanmoins, en cas de gros problème nécessitant
de rebooter sur disquette, il vaut mieux savoir utiliser vi
pur, étant donné que plus rien d'autre n'est possible, dans ce cas.


2.2 Fonctionnalités de vi

Dans la suite, le terme ''vi'' réfèrera à ''vim'', par facilité et abus de
langage. Les fonctionnalités de vi sont bien plus élevées que celles 
attendues d'un éditeur texte par les utilisateurs de systèmes non Unix/Linux.
Parmi celles-ci, on trouve notamment

Edition en mode (texte) plein écran, pas ligne par ligne
Indépendance par rapport au terminal (via stty)
Edition de fichier: insertion, modification, etc
Edition de fichiers multiples
Recherche/Remplacement avec des expressions régulières
Coloration syntaxique automatique, en fonction du type de fichier
édité (code source en C, fichier HTML, PHP, SGML, etc)

Lancement de commandes shell
Macros, abréviations
Répétition de commandes
Undo infini
Insertion du contenu d'un fichier externe à partir de la position
du curseur
Fenêtrage multiple (oui, en mode texte!)


2.3 Cas où vi est particulièrement adapté

L'administration sous Linux consiste souvent à éditer des fichiers de 
configuration en mode texte. C'est à ce niveau que l'on a un contrôle
maximal sur ce qui peut se passer sur son système : il n'y a pas d'interface
graphique qui cache les détails.
L'outil idéal de modification des fichiers de configuration en mode texte
est incontestablement vi. Une fois qu'il est suffisamment maîtrisé, il n'est
pas impossible d'avoir terminé une édition avec vim alors que la même édition
sous Emacs en est encore au stade du chargement de l'éditeur.
Pour l'édition de scripts vim est aussi un maître-achat. Il existe d'ailleurs
un nombre considérable de formats de fichiers textes pour lesquels vim 
utilise une coloration syntaxique appropriée.
Les seuls cas où l'on pourrait se dire que vim n'est pas l'éditeur idéal,
c'est sans doute dans le cadre de projets plus importants. Lorsque l'on
édite plus d'une vingtaine de fichiers simultanément, ça devient vite 
lourd. Dans ces cas, le besoin de plugins se fait sentir, et Emacs, 
l'éditeur le plus personnalisable au monde, remplit parfaitement cette
tâche.

3. Concepts de base sous vim

Avant de commencer à expliquer les commandes utilisés sous vim, il
est indispensable d'avoir bien compris les quelques principes de base
de vim. Ils surprennent souvent le débutant, par leur caractère peu
répandu.

3.1 Edition de fichiers

Pour lancer vim, rien de plus simple. Il suffit de taper son nom:


vim




Pour éditer un fichier, il suffit de passer son nom en paramètre:


vim monfichier.txt


L'édition se passe comme l'on peut s'y attendre. Le fichier à 
éditer est chargé en mémoire. vim utilise le terme ''buffer'' pour se
référer aux fichiers édités, car ils sont placés en mémoire dans des
''buffers''. Ensuite, après avoir apporté toutes les modifications voulues
au buffer, on peut l'écrire sur disque (sans quoi elles sont bien sûr perdues).
L'écriture peut bien sûr se faire sous un autre nom, afin de garder intacte
la version originale du fichier.
Tout ceci est un fonctionnement classique bien connu.

3.2 Modes utilisés par vim

Les modes de travail utilisés par vim sont nettement moins naturels. Ils 
rebutent souvent le débutant, au premier abord. Mais une fois le pas 
franchi, ce système s'avère diablement efficace.
vim possède trois grands modes, entre lesquels on switche souvent :


Le mode saisie ou insertion.
C'est le mode que tout le monde connaît : 
lorsque l'on frappe des touches au clavier, les lettres sont insérées telles
quelles dans le fichier texte. C'est le fonctionnement classique des autres
éditeurs.
Le mode commande est plus inhabituel. C'est le mode dans lequel
on donne des commandes simples à effectuer sur le texte : déplacement dans le
buffer, suppression d'éléments, remplacement d'un mot, etc. Dans ce mode, 
chaque lettre tapée lance la commande correspondante !
Le mode ex, ou ligne de commandes. Mode similaire au
précédent, il permet d'entrer des commandes, mais plus complexes cette fois.
Dans ce mode, on tape une commande complexe après l'invite (:),
et on la valide par la touche ENTER. Ces commandes groupe notamment les
recherches/remlacement par expression régulière, l'écriture des buffers
dans des fichiers, la sortie de vim, etc.



3.3 Changer de mode

Les deux premiers modes sont les plus utilisés au début. Au lancement de
vim, on se trouve en mode commande. Pour pouvoir entrer du texte, il faut
donc passer en mode insertion. 
Pour passer en mode insertion lorsqu'on est en mode commande, il suffit
de donner la commande i (insert) pour passer en mode insertion et
insérer des caractères à partir de la position sous le curseur.
Une alternative est de donner la commande a (append)
pour passer en mode insertion et insérer des caractères à partir de la
position qui suit celle sous le curseur.
Après avoir entré le texte souhaité, il faut revenir au mode commande, 
y compris si la commande qu'on veut donner est un simple déplacement dans
le texte ! Pour sortir du mode insertion, il suffit d'appuyer sur la touche
Escape. On peut alors entrer des commandes simples
(déplacement dans le texte, suppression de la ligne courante, etc.
Le troisième mode devient vite indispensable pour profiter de la puissance
de vim. Pour y rentrer (à partir du mode commande), on tape le caractère
d'invite (:). vim passe alors en mode ligne de commande.
Il attend que l'utilisateur tape sa commande complexe validée par
la touche Enter. vim exécute alors la commande complexe (recherche, 
remplacement, etc), puis revient tout seul en mode principal, le mode
commande.

Il faut évidemment constamment passer du mode commande au mode insertion,
ce qui paraît abominablement lourd, a priori. Cependant, les avantages
contrebalancent largement ces inconvénients. Une fois l'habitude prise,
ce sont les modes plus classiques d'édition de texte qui paraissent
contre-naturels !
Comme d'habitude sous Linux, il faut mettre les mains dans le cambouis : 
lancer vim, essayer les quelques commandes, chipoter un peu pour bien
assimiler le concept, etc. Ce n'est qu'au fil du temps passé à s'exercer
que l'investissement consenti devient extrêmement rentable.

3.4 Comment sortir de vim ?

Une question angoissante est : comment sortir de vim ? La manière classique
est celle du mode ligne de commande (ex). Cela consiste à taper la ligne
suivante, en validant par Enter:


:q!



Cette commande ''complexe'' (:) fait sortir de vim 
(q), sans enregistrer les modifications (!).

Une autre manière classique est d'utiliser la commande simple 


ZZ



Cette commande (en mode commande, naturellement) fait sortir de vim,
mais en enregistrant les éventuelles modifications.

3.5 Principes généraux de vim

Dans le mode ligne de commande (ex), vim utilise un certain nombre 
de conventions qu'il est très utile de connaître.
Une première convention est l'utilisation du caractère !.
En ajoutant ce caractère directement après la commande, on obtient une
version légèrement modifiée de la commande. Ainsi, :q 

sort de vim, sauf si le buffer a été modifié, tandis que
:q! sort de vim même si le buffer a été modifié (càd avec
perte des modifications, dans ce cas).
Une seconde convention est similaire à son équivalent sous Emacs : c'est
la notion de répétition. En préfixant une commande par un 
nombre X (dans le mode commande ou ligne de commande/ex),
on obtient le même effet que si on avait entré X fois la
commande sans ce nombre. Ainsi, pour la commande dd qui 
supprime la ligne courante, la commande 5dd a pour effet
de supprimer 5 lignes (comme si on avait tapé 5 fois la commande

dd.
Après avoir rapidement passé en revue ces différents principes, on
peut raisonnablement se lancer dans l'exploration de vim. 
Il suffira de donner une liste des commandes les plus utilisées, 
et de faire des essais sur machine pour voir si l'on a bien compris.
Sous Linux, la meilleure façon de faire est bien souvent l'auto-formation
par l'action (de préférence après présentation des concepts par une 
personne compétente).

4. Utilisation basique de vim

Il est temps de passer à la pratique, en appliquant les principes vus
ci-dessus. Une première façon de faire est de lancer le tutoriel de vim.
Pour ce faire, lancer, au niveau du shell, la commande


vimtutor



Si cette commande n'est pas disponible, ce n'est pas très grave. Il
suffit de copier le fichier texte



/usr/share/vim/tutor/tutor



dans son répertoire personnel, puis de lancer vim en lui passant l'emplacement 
de la copie comme fichier à éditer (premier paramètre de la commande vim).
Une autre façon est de lire la documentation système (un peu longue), et
de se mettre à la tâche. Pour ce genre de solution, autant lire d'abord
ce qui suit avant de revenir à la doc complète : ce sont les formes les
plus utilisées de vim.

4.1 Commandes de déplacement

Une des premières choses à connaître, ce sont les commandes de déplacement
au sein d'un fichier. Parmi les très nombreuses, voici les plus utilisées.
Il en existe encore d'autres, mais elles ne sont pas vraiement indispensables
dans une utilisation standard (sauf pour les utilisateurs très avancés).

Déplacement d'une unité

Pour se déplacer d'un caractère (en mode commande), les commandes suivantes
sont disponibles :


h pour aller au caractère à gauche (flèche gauche)
j pour descendre à la ligne suivante (flèche bas)
k pour remonter à la ligne précédente (flèche haut)
l pour aller au caractère à droite (flèche droite)


Ceci a l'air fort primitif, mais est indispensable sur les claviers qui ne
disposent pas des touches fléchées ! Pour les autres claviers, l'utilisation
des touches fléchées est possible.

Déplacement au sein d'une ligne

Voici comment se déplacer à l'intérieur de la ligne courante :



0,  ou la touche ''home'' pour aller en début de ligne
$ ou la touche ''end'' pour aller en fin de ligne
w (word) pour aller au mot suivant
b (back) pour aller au mot précédent
fx (forward x) pour aller au prochain caractère ''x''.
Fx fait la même chose que fx, mais en reculant vers la gauche 
pour trouver le caractère ''x''
tx (to x) pour aller au caractère précédant le prochain caractère ''x''.
Tx fait la même chose que tx, mais vers la gauche



Les commandes ''f'' et ''t'' sont un peu spéciales. Elles acceptent comme 
argument un caractère. 
Par exemple: ''fp'' déplace le curseur sous le prochain caractère ''p'' 
de la ligne. C'est pratique pour un déplacement plus rapide au sein d'une ligne,
mais surtout en association avec la commande ''d'' de suppression.
Ainsi, ''df.'' supprime (d) tout depuis la position du curseur 
jusqu'au premier caractère ''.'' de la ligne (f.). Ceci correspond
à la suppression de la fin de phrase courante.
La commande 't'' est utile aussi. Lorsqu'on édite du HTML, il est souvent 
utile de supprimer le texte du curseur jusqu'au prochain début de tab, non
inclusif. Pour réaliser cela, la commande est ''dt
Déplacements entre lignes



G sert à se déplacer à la dernière ligne du fichier

xG sert à se déplacer à la ligne x (paramètre numérique x).
Exemple: ''1G'' sert à se déplacer à la ligne 1, càd en début de fichier.
:x pour se déplacer à la ligne x (paramètre numérique x)
ctrl+F (forward) pour se déplacer d'un écran vers le bas
ctrl+B (backwar) pour se déplacer d'un écran vers le haut
%  (sur une parenthèse) pour se déplacer sur la parenthèse correspondant
à la paire (ouverture-fermeture). Très utile lorsqu'on programme en C, et
surtout dans des langages fonctionnels, connus pour leur utilisation
massive des parenthèses.
{  ou }  pour se déplacer au bloc précédent ou suivant. La notion de bloc
varie selon le type de fichier édité. C'est par exemple un paragraphe en HTML,
ou le corps d'une fonction en langage C.


4.2 Commandes de changement de mode

En mode commande, lorsque l'on se trouve sur un caractère donné, 
on peut passer en mode insertion avec, principalement:

a pour insertion après le curseur
i pour insertion avant le curseur
I pour insertion en début de ligne
A pour insertion en fin de ligne
o pour insertion sur la ligne suivante
O pour insertion à la ligne précédente




4.3 Commandes de suppression

Toujours en mode commande, voici quelques commandes utiles de suppression.

x pour supprimer le caractère sous le curseur
X pour supprimer le caractère avant le curseur (backspace)
dw (delete word) pour supprimer la fin du mot courant
dd pour supprimer la ligne courante
xdd pour supprimer x lignes. Ex: 5dd pour supprimer 5 lignes
dG (delete, EOF) pour supprimer du curseur jusqu'à la fin du fichier

dfx (delete forward param x) pour supprimer du curseur jusqu'au prochain
caractère x (paramètre) de la ligne courante (ce caractère x inclus)
dtx (delete to x) pour supprimer du curseur jusqu'au prochain
caractère x (paramètre) de la ligne courante (ce caractère x exclus)


4.4 Commandes de modification

En mode commande, voici les commandes principales pour substituer du texte:

cw (change word) pour changer la fin du mot en cours (suppression
de la fin du mot et passage en mode insertion)
cc pour changer la ligne entière (suppression et passage en mode 
insertion)
s (substitute) pour substituer le caractère (suppression et entrée en
mode insertion)

xs (paramètre: x) pour substituer ''x'' caractères 
~ pour mettre la lettre sous le curseur en majuscule
x~ (param: x) pour mettre les x caractères suivants en majuscule 


4.5 Commandes ''Fichiers''



ZZ ou :x pour quitter vim et sauvegarder les changements éventuels
:w pour enregistrer le buffer courant (''Save'')

:w nom (param: nom) pour enregistrer le buffer sous un nouveau nom
(''Save as'')
:w! nom (param: nom) pour enregistrer le buffer sous un nouveau nom,
et l'écraser s'il existait déjà.
:q pour quitter (échoue si un buffer a été modifié)
:q! pour quitter vim (changements perdus si buffer modifié)
:e nom (param: nom) pour éditer un fichier supplémentaire (en gardant
les anciens en mémoire).


4.6 Commandes couper-copier-coller




yy ou Y pour copier la ligne en cours dans le tampon
p pour coller le contenu du tampon après le curseur
P pour coller le contenu du tampon après le curseur
dd pour couper la ligne en cours dans le tampon
"xyy (x: paramètre de type caractère) pour copier 
la ligne en cours dans le tampon portant le nom x
"xp pour coller le contenu du tampon de nom x (paramètre)
"xP idem, mais juste avant la position actuelle, pas juste 
après
y + commandes de déplacement pour mettre dans le tampon ce qui suit
le curseur jusqu'où arrive la commande de déplacement. Exemple: yw pour y 
placer le mot courant, y0 pour y placer le début de ligne jusqu'au curseur



5. Commandes plus avancées

Vim possède aussi un certain nombre de fonctionnalités bien plus avancées.
Les plus utiles parmi celles-ci sont présentées ci-dessous.

5.1 Recherches et remplacement

Pour chercher une occurence, il suffit de définir le terme recherché.

/nom pour rechercher la 1ère occurence de ''nom'', en paramètre.
''nom'' peut être simplement le texte cherché, ou une expression régulière.
n pour chercher l'occurence suivante
N pour chercher l'occurence précédente

set ic pour ignorer la casse lors des recherches
(ne pas différencier majuscules et minuscules)
set noic pour ne pas ignorer la casse lors des recherches
(recherche case-sensitive, celle par défaut)

Pour remplacer une occurence, on précise en plus le terme de remplacement
lorsque l'occurence est trouvée:

:s/avant/après pour remplacer la première occurence ''avant''
dans la ligne courante par ''après''
:s/avant/après/g pour remplacer toutes les occurences ''avant''
de la ligne courante par ''après''
:%s/avant/après/g pour faire un rechercher/remplacer global, sur tout
le fichier. ''%'' signifie toutes les lignes. On peut spécifier d'autres 
étendues (bloc en cours, de la ligne x à la ligne y, etc)



5.2 Sélection

Il est possible de définir un block sur lequel effectuer des actions
plus tard. C'est la sélection telle qu'on la connaît habituellement.

v pour définir un bloc qui commence sous le curseur et s'étend jusqu'où
on déplace le curseur avec les commandes de délacement.
V pour passer en ''mode visuel'', càd définir un bloc composé de lignes
entières, commançant à la ligne courante et s'étendant jusqu'à la ligne où
l'on se déplace.

Une fois la sélection effectuée, on peut effectuer des actions similaires
à celles du couper-coller, et plusieurs autres. Par exemple:

d pour couper la sélection dans un tampon
y pour copier la sélection dans un tampon

p pour coller la sélection après le curseur
P pour coller la sélection avant le curseur
:s... pour effectuer des rechercher/remplacer limités au bloc


5.3 Coloration syntaxique



:syntax on pour activer la coloration syntaxique
:syntax off pour la désactiver

:set background=dark pour que la coloration choisisse des couleurs
adaptées à un fond sombre (cas de la console texte)
:set background=light pour que la coloration choisisse des couleurs
adaptées à un fond clair (cas d'un xterm par exemple)


5.4 Insertion d'un autre fichier texte

:r filename pour inclure le contenu du fichier ''filename'' 
à partir de la position du curseur.

5.5 Lancer un sous-shell

Pour lancer une commande shell, taper :! commande, en remplaçant

commande par la commande désirée. C'est pratique dans de nombreux
cas. Exemples:

:! sgml2html -l fr -c latin1 -s 1 fichier.sgml pour 
générer les pages html correspondant au fichier source linuxdoc que l'on
édite
:! sortpour trier les lignes du fichier par ordre
alphabétique. Ce type de commande peut même agir sur un bloc, s'il a été
sélectionné avant.
ctrl+Z : mettre vim en arrière-plan. Cela correspond à la combinaison
de touche standard du shell pour mettre un processus en arrière-plan. Pour
le remettre au premier plan, utiliser la commande ''fg'' ou les raccourcis
du genre ''%n'' où n est le numéro du job.


5.6 Edition multi-fichiers



:e filename pour éditer ''filename'' en plus, en gardant les autres
buffers
:b filename pour passer le buffer ''filename'' (affichage)
:b n pour passer au buffer numéro n
:ls pour lister les buffers ouverts
ctrl-^ pour switcher entre deux buffers (dits ''alternate'').


6. Pour aller plus loin

''Linux in a nutshell, a desktop quick reference'', est une
excellente référence à avoir sur son bureau. On y trouve un condensé
et des rappels sur les commandes de bases de Linux, sur les shells
de type sh et csh, sur les expressions régulières, sur les éditeurs
vi et emacs, les langages sed, awk, et perl, sur les gestionnaires
de version RCS et CVS, etc. Comme souvent sous Linux, ce livre est
disponible aux très bonnes éditions O'Reilly.
Pour en savoir plus sur vim, il suffit de consulter la documentation
disponible sur son système (man, info, /usr/doc/vim/*).
On trouve également un tutoriel nommé ''vimtutor''. Enfin,
vim possède une documentation intégrée, accessible à l'intérieur de
vim par la commande :help (:q pour sortir
de l'aide et revenir à vim).
Si vous avez encore des questions après avoir lu tout cela, il vous
reste deux possibilités: consulter un gourou local, voire
lire le code source (pour une éventuelle modification).