Vimadvancedtutor
De Vim-fr.
Le vimadvancedtutor est un projet de [Utilisateur:psycojoker|Bram] pour répondre à la demande fréquente: "je viens de finir le vimtutor, comment je fais pour continuer à apprendre à me servir de vim ?".
Actuellement un chapitre a été écrit.
Le dépot git pour la dernière version est trouvable ici: http://git.worlddomination.be/?p=doc/vim-lessons.git;a=summary Nhésitez pas à envoyer des patchs !
Texte
<source lang="text">
Advanced Vim Tutor
==================
Ce cours a été écrit par Laurent Peuch, un des fondateurs de vim-fr.org Si vous
trouvez des erreurs ou que vous avez des remarques n'hésitez pas à m'envoyer un
mail sur vimfr@worlddomination.be ou venir me trouver sur
irc.freenode.net#vim-fr ou vim-fr@chat.jabberfr.org
Ce cours s'adresse à des personnes qui ont déjà au moins fait le vimtutor et
qui ont déjà un peu d'expérience pratique avec vim et souhaitent découvrir de
nouvelles choses. Il a pour objectif d'être relativement technique en vous
donnant directement des outils avec parfois un peu, mais pas trop, de théorie.
J'essayerais chaque fois que je le peux de donner un moyen mémotechnique pour
retenir plus facilement une commande mais mon imagination n'était pas illimité
et nos façons de penser et retenir toutes différentes n'hésitez pas à vous
faire les votres si ils vous conviennent mieux. Vous pouvez également me les
envoyer.
Il existe un dépot git pour ce cours à l'adresse TODO si vous voulez faire un
patch ou le traduire dans votre langue.
Gardez à l'esprit que vous ne pourrez tout de manière par retenir tout ce qu'il
y a dans ce cours, il est bien plus intéressant de savoir que cela existe,
comprendre comment cela marche et de garder à l'esprit un moyen de comment le
retrouver.
Remarque:
=========
Dans ce cours un ^ qui précède une lettre (ou autre) signifie l'usage de la
touche ctrl en même temps que cette touche. Autrement dit ^a correspond à
ctrl-a.
Les commandes qui nous manquent rapidement et dont ne parle pas le vimtutor:
============================================================================
Ce sont les commandes qui m'ont le plus rapidement manqué et/ou pour lesquelles
j'ai eu le plus souvent de question.
Comment annuler l'effet de la touche "u" ? (ou comment faire un "redo")
-----------------------------------------------------------------------
Il suffit de faire ^r en mode normal (r comme "redo" ou "re faire" en
français).
Comment copier du texte depuis le presse papier de X dans vim ?
---------------------------------------------------------------
Il existe deux presses papiers différents sous X, celui de la souris et celui
de l'option "copier" (aussi utilisé avec le raccourci ^v). Ces deux presses
papiers sont accessibles via deux registres différents de vim (les registres
seront détaillés plus loin) le registre * pour la souris et + pour "coller".
Plus concretement pour copier dans vim le texte du presse papier de la souris
il faut faire: "*p et pour copier du texte depuis le presse papier "coller" il
faut faire: "+p
Remarque: vim doit être compilé avec le support de X pour que ces commandes
fonctionnent.
Autre remarque: utiliser directement le bouton du milieu de la souris ou
l'option "coller" de certains terminaux fonctionne aussi mais se relève souvent
bancale.
J'ai ouvert mon fichier en oublier d'être en root, je fais comment pour sauver
------------------------------------------------------------------------------
quand même ?
------------
:w !sudo tee %
Comment copier du texte sans le supprimer ?
-------------------------------------------
Il faut utiliser la commande y en mode normal. Elle fonction exactement comme
la commande d (un fonctionnement détaillés de comment marche la plupart des
commandes se trouve au prochain chapitre).
Le fonctionnement générale d'une commande et la puissance des portés:
======================================================================
Commmençons par un petit peu de théorie sur les commandes du mode normal de
vim, ce sont elles que vous allez le plus utiliser, elles vous permettent de
manipuler beaucoup de texte très rapidement et ce sont une des grandes forces de
vim.
La plupart des commandes se présentent sous la forme suivante:
{quantifieur}commande[porté]
Contrairement à la porté, le quantifieur est optionnel, il permet de répéter
plusieurs fois une commande. En sont abscence la commande n'est exécuté qu'une
seule fois. A noter que certaines portés peuvent également recevoir un
quantifieur.
Un exemple concret: prennons la commande d (d pour delete) qui permet de
supprimez du texte et que vous connaissez normalement. dw permet de supprimer
un mot (ainsi que l'espace qui est juste après) où w est la portée (w pour
word). 2dw permettra de supprimer 2 mots.
Subtilité sans réel incidance: 2dw supprimera 2 fois un mot et d2w supprimera
une fois deux mots (le résultat est le même).
Quelques exemples de commandes qui ont ce fonctionnement: d, y (copier), c
(cut, comme d et rentre en mode insertion juste après), < (désindenter du
texte), > (indenter du texte), = (auto indenter du texte) etc ...
Voici une liste des portées classique, n'hésitez pas à les tester sur ce texte
pour vous donner une idée.
Touche | Description | Mémotechnique
-----------------------------------------------------------------------------------------------------------------
w | un mot avec l'espace qui suit, s'arrête sur de la ponction | word
W | comme w mais ne s'arrête qu'à un espace ou à la fin de la ligne | WORD
e | comme w mais sans l'espace qui suit le mot | à côté de w sur un clavier qwerty
E | comme W mais sans l'espace qui suit le mot | idem
b | l'inverse de e, recule d'un mot | back
B | l'inverse de E | BACK
0 | place le cuseur sur la première colonne de la ligne | comme le premier char de la ligne
^ | place le cuseur sur le premier caractère non blanc de la ligne | comme le regex, à gauche de $
$ | place le cuseur sur le dernier char de la ligne | à droite de ^, comme le regex
gg | va au début du fichier | go, ground
G | va à la fin du fichier | inverse de gg
Remarque: répéter la commande équivaut à l'appliquer à toute la ligne courante,
exemple: dd supprime la ligne où se trouve le curseur.
N'hésitez pas à les tester maintenant, l'apprentissage de vim passe surtout par
la pratique et l'habitude (rappel: u (undo) permet d'annuler la dernière
modification).
A noter que ces portés servent également à se déplacer (hjkl sont également des
portés).
Bon, maintenant qu'on a vu la base, passons aux portés avancées qui sont bien
plus intéressantes et puissantes. Une fois découvertes et comprisent elles
changent la vie et se relèvent vite addicitivent.
Elles ont la particularité de demander un argument, ce qui les rends légèrement
plus longue à écrivent mais bien plus pratiques.
Première série de portés avancées, elles acceptent un quantifieurs:
Touche | Description | Mémotechnique
-----------------------------------------------------------------------------------------------------------------
t[char] | déplace le cuseur juste avant le charactère écrit après t | unTill -> till
T[char] | pareil mais se déplace vers l'arrière | inverse de t
f[char] | comme t mais inclu également le charactère | forward
F[char] | pareil mais se déplace vers l'arrière | inverse de f
Exemple:
yt" copiera du cuseur jusqu'au prochain " sur la ligne courante
y2f" copiera du cuseur jusqu'au deuxième " de la ligne courante en l'incluant
ct; supprimera jusqu'au prochain ; de la ligne courante (pratique en c/c++/java/js ...)
Dans des phrases contenant des charactères spéciaux ces portés se relèvent très
utiles, elles permettent également de rendre plus "générique" des macros
(décrites dans un des chapitres suivants).
Elles sont également très pratiques pour se déplacer très rapidement.
Deuxième série de portés avancées, attention celles ci ne peuvent être utilisés
que avec des commandes, pas pour se déplacer. Elles ont la particularité de
concerner ce qui se trouve *autour* du curseur et pas d'un côté ou de l'autre
uniquement.
Touche | Description | Mémotechnique
-----------------------------------------------------------------------------------------------------------------
iw le mot qui se trouve autour du cuseur sans prendre les espaces in word
aw idem mais en prenant les espaces éventuels all word
iW comme iw mais sans s'arrêter à la ponctuation (comme W) in WORD, un peu comme W
aW idem mais avec les espaces all WORD
i" entre les " qui entourrent le caractères in ""
a" idem avec les " all ""
i' comme i" mais avec les ' bon, vous avez compris le principe ?
a' comme a" mais avec les '
i) dans les () (remarque: i( a le même effet)
a) idem en incluant les parenthèses
i] dans les []
a] idem avec les []
i> entre des <>, très pratique en html, i< marche aussi
a> idem avec les <>, a< marche aussi
i{ entre les {}, vous voulez réécrire toute une fonction ?
ci{, marche aussi avec i} et iB
a{ idem en prenant les {}, marche aussi avec a} et aB
ib fait un i) ou i" ou i] ou i' en fonction des premiers rencontrés b pour bloc
ab similaire à ib mais en remplaçant i par a
is intérieur d'une phrase (jusqu'à un . faire :h sentence pour s pour sentence
plus de détails)
as dans une phrase
ip dans un paragraphe, un bloc de texte en s'arrêtant aux lignes p pour paragraphe
vides (sans les prendres)
ap idem en prenant les lignes vides
it dans un tag html, cad entre des <tag></tag> t pour tag
at idem avec les tags html
Cela peut paraitre impressionnant comme liste, mais vous remarquerez bien vite
que la plupart sont très facile à retenir et tout à fait logique et évidentes.
Le mieux est d'en essayer quelques unes qui correspondent le mieux au langage
que vous utilisez (i{ pour le c/c++/java/js .. it, at, i<, a< pour l'(x)htm(l)
.. i) pour le lisp etc ...) puis de repasser voir celles qui pourraient vous
servir une fois les premières devenu une habitude.
Quelques exemples:
dap supprime un paragraphe
y2a) copie deux ensembles de () imbriqué l'une sur l'autre
ci} supprime l'intérieur de {} et passe en mode insertion
dat supprime tout un tag html
ci< supprime l'intérieur d'un <> et pass en mode insertion
>i} indente l'intérieur d'un {}
ci" supprime l'intérieur d'un "" et passe en mode insertion
d3a{ supprime 3 bloc de {} imbriqué l'un dans l'autre
Voici pas mal de texte pour vous entrainer sur ces nouvelles portées:
(Pour les curieux c'est un timer en javascript)
<html>
<head>
<script type="text/javascript">
var c=0;
var t;
var timer_is_on=0;
function timedCount()
{
document.getElementById('txt').value=c;
c=c+1;
t=setTimeout("timedCount()",1000);
}
function doTimer()
{
if (!timer_is_on)
{
timer_is_on=1;
timedCount();
}
}
</script>
</head>
<body>
<form>
<input type="button" value="Start count!" onClick="doTimer()">
<input type="text" id="txt">
</form>
Click on the button above. The input field will count forever, starting at 0.
</body> </html> TODO: ===== * les presses papiers * vimrc (et gvimrc) * comment mieux appréhender hjkl (utiliser surtout jk et des portées) * les maps * les marques pages * l'aide dont :helpgrep * à terme faire de l'aide spécifique à un langage * magic dot et similaires * les macros * la mise en page * les abréviations * quickfix * le visuel en bloc * rajouter le "sauver quand on a pas ouvert en root" dans les FAQ du début * hjkl "me font chier"
</source>
