Vim - Antisèche

VIMINFO

Tags Action Shortcut Mnémo
Définir les éléments à sauver dans le fichier viminfo :set vi=<paramètres>[COMMAND] :set viminfo
Valeurs avec <parametres> :
'<nombre> : le nombre de fichiers pour lesquels il faut sauver les marques locales. P.e. :set vi='1000
f1/f0 : sauvegarde ou non des marques globales. P.e. :set vi=f1 (oui)
/<nombre> : nombre de lignes d’historique de recherche (entreprises par /). P.e. :set vi=/100 => 100 lignes de recherche
% : conservation de la liste des buffers. P.e. :set vi=%
! : conservation des variables globales. P.e. :set vi=!
Exemple
:set viminfo='1000,f1,:100,/100,%,! => on conserve les marques locales de 1000 fichiers ('1000), qu'on conserve les marques globales (f1), qu'on conserve 100 lignes d’history (:100) et 100 ligne d'historique de recherche (/100), qu'on sauve et restaure la liste des buffers (%) et qu'on sauve les variables globales (!).
Forcer l’écriture de viminfo [COMMAND] :wviminfo[!] [path/to/fichier]
Note Sans précision de fichier, c'est le fichier ~/.viminfo qui sera utilisé.
Forcer la lecture du viminfo [NORMAL] :rviminfo[!] [path/to/fichier]
Note Sans précision de fichier, c'est le fichier ~/.viminfo qui sera utilisé.

UTILES

Tags Action Shortcut Mnémo
Touches dans les commandes <left> = left arrow = flèche gauche
<up = up arrow = flèche haut
<right> = right arrow = flèche droite
<down> = down arrow = flèche bas
<CR> = Return = touche entrée
<BS> = Backstack = touche effacement arrière

HELP

Tags Action Shortcut Mnémo
aide Ouvrir l’aide :h[COMMAND] :help help
Tagger un dossier [COMMAND] :! ctags -R .
Note 1 « tagger un dossier » consiste à repérer toutes les fonctions, les définitions, etc.
Note 2 Il faut se trouver à la racine du dossier voulu (dossier du programme)
Note 3 On peut définir le fichier où seront placées les tags avec l’option -f <path/to/file>
Note 4 Ça fonctionne parfaitement en Ruby
Note 5 On peut le faire en dehors de Vim, puisque c’est une ligne de commande : ctags -R .
tag Se rendre à une tag [NORMAL]
Note 1 « se rendre à une tag » signifie par exemple « se rendre à la définition d’une fonction/méthode »
Note 2 Utiliser pour revenir à l’endroit précédent
Note 3 Normalement, c’est ], mais ça ne fonctionne pas sur Mac
Exemple
Se placer sur l’utilisation d’une méthode, taper => Vim ouvre le fichier contenant la définition de la méthode et l’affiche.
tag Revenir à la position précédente (après avoir cherché une tag) [NORMAL] Tag
tag Passer en revue les tags parcourues (au cours de la session) [NORMAL]
aidecommande Obtenir l’aide d’une commande dans un mode particulier :h <pref>_<commande>[NORMAL] :help <préfixe mode>_<commande>
Valeurs avec <préfixe mode> :
i pour mode insertion
v pour mode visual
c pour mode command
Exemple
:h i_CTRL-H => conduit à l’aide sur la command en mode insertion
aideoption Obtenir l’aide sur une option :h '<option>':help '<option>'
Note Il faut l'entourer d’apostrophes simple
Exemple
:help 'nowrap' => conduit à l’aide à propos de l’option « nowrap »
Obtenir de l’aide sur le mot sous le curseur [NORMAL] Keyword lookup
Lancer Vim en mode Verbose $> vim -V <nombre> Verbeux
Note Utile pour débugger les scripts Vim.
Définir la hauteur de la fenêtre d’aide [COMMAND] :set helpheight=<nombre de lignes>

PREMIÈRES COMMANDES UTILES

Tags Action Shortcut Mnémo
Activer le mode INSERT en se plaçant au bout de la ligne [NORMAL]
Activer le mode INSERT en se plaçant après le caractère courant [NORMAL]
Activer le mode INSERT avant le caractère courant [NORMAL]
Note La première touche frappée ajoutera un caractère avant le curseur.
Activer le mode VISUAL normal [NORMAL]
Note Le mode visual « normal » se distingue du mode par ligne et du mode par block.
Activer le mode VISUAL ligne [NORMAL]
Note Le mode visual « ligne » permet de sélectionner des lignes entières.
Activer le mode VISUAL block [NORMAL]
Note Le mode visual « block » permet de sélectionner des blocks de signes, sans tenir compte des lignes, comme si c’était un dessin. Cf. l’exemple.
Exemple
                         
 Ceci est un dessin      
 Uune sortede dessin     
 Pour pouvo sélectionner 
 Tout en block.          
                         
annulerquitter Quitter un mode quelconque, annuler, renoncer
action Répéter la dernière action [NORMAL] . ()
macro Enregistrer une macro [NORMAL] <-> <jouer la macro> maqro
macro Jouer une macro [NORMAL] <a-z>

SESSIONS

Tags Action Shortcut Mnémo
Enregistrer la session courante :mks <fichier>[COMMAND] :mksession <fichier> make session
Exemple
:mksessions session.vim => enregistre l’état courante dans "session.vim"
Restaurer une session précédente [COMMAND] :so[urce] <fichier session>
$> vim -c ":source <fichier session>"
Note Pour définir ce qui doit être sauvé au cours d’une session, cf. la définition suivante.
Exemples
:source session.vim => restaure la session enregistrée dans "session.vim"
$> vim -c ":source session.vim"
Définir ce qui doit être mémorisé dans une session [COMMAND] :set sessionoptions=<element1>,<element2>,<element3>...<elementN>
Valeurs avec <element> :
buffers sauve les buffers
globals sauve les variables globales qui commencent par une majuscule et contiennent au moins une minuscule
help sauve la fenêtre d’aide
blank sauve les fenêtres vides ouvertes
options sauve toutes les options et la carte clavier (keyboard mapping)
winpos sauve les positions de fenêtre (GUI)
resize sauve la taille de l’écran
winsize sauve les tailles des fenêtres si possible
slash sauve les paths escapés (pour utilisation de unix/mac à windaubes)
unix sauve avec des retours chariots unix

MAPPING

Tags Action Shortcut Mnémo
Définition du mapping
Note Le mapping est le fait d’associer une touche (ou une combinaison de touches) à une action. C’est une sorte de macro.
Définir une map pour la session courante [NORMAL] :map <touche> <action>
Exemples
:map <F1> "ay => en pressant la touche F1, on copie le texte sélectionner (y) dans le registre "a" ("a)
:map <F2> "ap => en pressant la touche F2, on colle le texte du registre "a" au curseur.
:map ^A dd => en pressant , on delete la ligne courante
:map ^B ^A => en pressant , on produit la même action que
Définir une map pour un mode particulier [NORMAL] :<lettre mode>map <touche> <action>
Valeurs avec lettre mode :
i (im[ap]) pour le mode [INSERT]
c (cm[ap]) pour le mode [COMMAND]
Note : :map! pour les deux modes [INSERT] et [COMMAND]
v (vm[ap]) pour le mode [VISUAL]
n (nm[ap]) pour le mode [NORMAL]
s (sm[ap]) pour le mode [SELECT]
o (om[ap]) pour l’operator pending (mode dans lequel on entre lorsqu’une touche attend une « motion », par exemple « d » pour delete)
Note Apparemment, pour que des lettres (par exemple « CAM ») se transforme en autre chose dans le mode [INSERT], il faut vraiment utiliser imap (voir l’exemple).
Exemple
:imap CAM Camille => Taper produit l’écriture de « Camille ».
Lister toutes les maps (enregistrées ou non) [NORMAL] :map
Supprimer une map [NORMAL] :[<mode>]unmap <touche>
Supprimer toutes les mappings :mapc[NORMAL] :mapclear

SNIPPETS

Tags Action Shortcut Mnémo
snippet Définir une abbréviation/un snippet :ab[breviate] <snippet> <remplacement>
Note Cette abbréviation sera valable pour le mode [INSERT] comme pour le mode [COMMAND]. Utiliser ia[bbrev] pour un snippet qui ne fonctionne qu’en mode insertion.
Exemples
:abbreviate @phil Philippe Perret <philippe.perret@yahoo.fr> => en tapant @phil, on insert le texte 'Philippe Perret etc.'
:ab multiline Une définition<CR>Sur plusieurs<CR>lignes => à mettre dans un fichier à charger ou .vimrc.
snippet Définir une abbréviation pour le mode INSERT seulement :ia[bbrev] <snippet> <remplacement>
[dans fichier config] iabbrev <snippet> <remplacement>
Note On peut utiliser ou pour l’étendre dans mode [INSERT].
Exemples
:iabbrev C Camille
:ia J Joaquim
snippet Définir une abbréviation pour le mode COMMAND seulement :ca[bbreviate] <snippet> <remplacement>
Exemples
:cabbreviate l list
:ca J Joaquim
Définir des abbréviations (ou des mappings) pour un type de fichier Créer un fichier avec le nom du language dans le dossier ~/.vim/ftpluging avec l’extension .vim
Exemple
Dans le fichier ~/.vim/ftplugin/ruby.vim, on peut placer les abréviations et mappings pour le code ruby et elles seront automatiquement chargées au lancement d’un fichier ruby.
snippet Résoudre une abbréviation en mode INSERT [INSERT] <snippet>
[INSERT] <snippet>
snippet Supprimer une abbréviation précédemment définie :una[bbreviate] <snippet>
snippet Supprimer une abbréviation du mode INSERT :iuna[bbreviate] <snippet>
snippet Supprimer une abbréviation du mode COMMAND :cuna[bbreviate] <snippet>
snippet Supprimer toutes les abbréviations [NORMAL] :abc[lear]
snippet Supprimer toutes les abbréviations du mode INSERT [NORMAL] :iabc[lear]
snippet Supprimer toutes les abbréviations du mode COMMAND [NORMAL] :cabc[lear]
snippet Afficher toutes les abbréviations :ab[breviate]
snippet Enregistrer les abbréviations (et mapping et set) dans un fichier :mkvimrc <path/to/fichier> make vimrc
Recharger les abbréviations (+ map et set) depuis un fichier (créé avec mkvimrc) :so[urce] <path/to/fichier>

FENÊTRES & HUBLOTS

Tags Action Shortcut Mnémo
Ouvrir plusieurs fichiers dans des “hublots” $> vim -o<nombre fichiers> file1 path/file2 file3
Note J’appelle “HUBLOT” la traduction de “VIEWPORT” ou “LAYOUT”. C’est la sous-fenêtre dans la fenêtre, où apparait l’extrait du fichier, comme dans le hublot du navire apparait un extrait de la mer.
Exemples
vim -o3 ./*.rb => Ouvrir au maximum 3 fichiers ruby du dossier courant
Indiquer un nombre pour limiter le nombre de hublots : vim -o3
Ouvrir la fenêtre alternative [NORMAL] ^
Note TODO Qu’est-ce qu’une fenêtre alternative ?
function Afficher la définition de la fonction :pt[NORMAL] :ptag <fonction>
Note Il faut avoir, au prélable, demandé de faire la liste des méthoes par :!ctags -R .
preview Fermer la fenêtre de prévisualisation :pc[NORMAL] [":pclose", "", ""] preview close
Note Elle se ferme même lorsque l’on n’est pas dedans
Définir la hauteur de la fenêtre de prévisualisation [NORMAL] :set previewheight=<nombre de lignes>
split Split (signature générale) :sp[NORMAL] :[<hauteur> ][+<commande> ][++<opt> ]sp[lit][ <path/to/file>"]
Note Pour voir le détail des +commandes et des options, rechercher :help +cmd et :help ++opt
Exemples
:10 split ou :10sp splitte la fenêtre en 2 en faisant une nouvelle vue de 10 lignes
:split mon/fichier.txt splitte la fenêtre en 2 et ouvre le fichier désigné dans la nouvelle vue.
:+ split fichier.txt splitte la fenêtre en ouvrant fichier.txt dedans et se place sur la dernière ligne (+)
:+10 split fichier.txt splitte la fenêtre en ouvrant fichier.txt dedans et se place sur la 10e ligne
:+/XXX split fichier.txt splitte la fenêtre en ouvrant fichier.txt dedans et se place sur la 1ère ligne contenant “XXX”
:++fileformat=dos split fichier.doc splitte la fenêtre en ouvrant fichier.txt dans un format DOS.
splitfenêtre Spliter la fenêtre active :sp[":spit", ""] spiter
splitfichier Spliter la fenêtre en créant un nouveau fichier dans le nouveau hublot [NORMAL] :new
splitfenêtre Spliter verticalement la fenêtre active :vs
:vsp:vsplit		 vertical split
hublotligne Spliter en définissant la taille (lignes) du nouveau hublot <nombre ligne>sp
hublotligne Spliter verticalement en définissant la taille (colonne) du nouveau hublot <nombre colonnes>vsp
Faire défiler deux fenêtres en même temps [COMMAND] :set scrollbind
Note La procédure exacte est la suivante : il faut ouvrir deux fichiers en splitant verticalement la fenêtre (:vert split) puis taper :set scrollbind pour chacune des hublots.
hublotsplit Aggrandir le hublot courant quand on focusse dedans [COMMAND] :set winheight=36
Exemple
set winheight=40 est placé dans le .vimrc. La fenêtre est splittée en deux hublots horizontaux. Dès qu’on focusse dans l’un d’eux, il prend la taille de 40 lignes.
hublotsize Redimensionner précisément le hublot courant :res[NORMAL] [":resize [+|-]<nombre>", "z <nombre>ntree"]
Exemples
:resize 10 => mets le hublot à 10 lignes
:res +10 => augmente le hublot de 10 lignes
:res -10 => diminue le hublot de 10 lignes
Redimensionner verticalement précisément le hublot courant :vert res[NORMAL] [":vert :resize [+|-]<nombre>"]
Exemples
:vert :resize 100 => mets le hublot à 100 colonnes
:vert :res +100 => augmente le hublot de 100 colonnes
:vert :res -100 => diminer le hublot de 100 colonnes
hublotsize Redimensionner le hublot en l’aggrandissant [NORMAL] , <nombre> |
Exemples
, 10 augmente la taille du hublot courant de 10 lignes
, 20 diminue la taille du hublot courant de 20 lignes
hublotsize Redimensionner en maximisant le hublot courant [NORMAL] , (underscore)
[NORMAL] :resize (sans arg)
hublotsize Redimensionner le hublot en le diminuant [NORMAL] , [x]
hublotsize Redimensionner tous les hublots à la même taille [NORMAL]
hublot Activer le hublot suivant [NORMAL] window (fenêtre)
Activer le hublot en dessous du courant [NORMAL] comme pour descendre dans Vim
Activer le hublot à droite [NORMAL] comme pour aller à droite dans Vim
Activer le hublot au-dessus [NORMAL] comme pour monter dans Vim
Activer le hublot à gauche comme pour aller à gauche dans Vim
fenêtre Fermer la fenêtre courante [NORMAL]
[NORMAL] 		window, quit
Fermer toutes les fenêtres sauf la fenêtre courante [NORMAL]
fenêtre Maximiser , ne garder que la fenêtre courante :only
 only this window
Tall ?
Positionner la ligne courante en haut de l'écran [NORMAL]
Positionner la xième ligne en haut de l'écran [NORMAL] [numéro ligne]
Positionner la ligne courante en bas de l'écran [NORMAL]
Positionner la ligne courante au milieu de l'écran [NORMAL]
[NORMAL]
Exécuter une commande dans toutes les fenêtres ouvertes [NORMAL] :windo <commande>
Mémoriser la position des fenêtres et tabs [COMMAND] :mkview <path/to/file.vim>
Note ajouter « ! » à la commande pour forcer la réécriture d’un fichier précédent
Recharger la position des fenêtres et tabs [COMMAND] :source <path/to/file.vim>
Note Ce fichier doit avoir été sauvé avec :mkview.
Définir les éléments sauvés par mkview :set viewoptions=<L1>,<L2>,...<Lx>
Valeurs avec <Lx> :
cursor sauve la position du curseur
folds sauve l’état courant des foldings
options sauve les options incluant les options locales pour les buffers et fenêtres

TABS

Tags Action Shortcut Mnémo
Lister toutes les tabs ouvertes [COMMAND] :tabs
Ouvrir le fichier sous le curseur [NORMAL]
Ouvrir un fichier dans une nouvel tab [NORMAL] :tabedit path/to/file
Ouvrir un fichier existant dans une nouvel tab [NORMAL] :tabfind path/to/file[:<ligne>]
Ouvrir plusieurs fichiers en même temps dans des tabs $> vim -p file1 path/file2 path/to/file3
Exemple
Ajouter un nombre pour limiter le nombre d'onglets à ouvrir : vim -p4
Fermer la tab courante [NORMAL]
[NORMAL] :close
[NORMAL] :q
Fermer une tab quelconque [NORMAL] :tabclose <index tab>
Fermer toutes les tabs sauf la courante :tabo[NORMAL] :tabonly only = seulement
Activer la tab suivante (première si dernière) :tabn[NORMAL] :tabnext
Activer la tab précédente (dernière si première) :tabp
:tabN[NORMAL] :tabprevious
[NORMAL] :tabNext
Activer la première tab :tabfir
tabr[NORMAL] :tabfirst
[NORMAL] :tabrewind
Activer la dernière tab :tabl[NORMAL] :tablast
Activer une tab pour son index (1-start) :tabn[NORMAL] :tabnext <index>
Exécuter une commande dans toutes les tabs ouvertes [COMMAND] :tabdo <commande>
Exemple
:tabdo :%s/old/new/g => remplace le texte "old" par "new" dans toutes les tabs.
Placer une tab après une autre :tabm[COMMAND] :tabmove
Définir quand afficher la ligne d’onglets [COMMAND] :set showtabline=<nombre>
Valeurs avec <nombre> :
0 : ne jamais afficher
1 : afficher quand onglets
2 : toujours afficher

FICHIERS

Tags Action Shortcut Mnémo
Browser les fichiers :bro[NORMAL] :browse
Note TODO Voir ce qu’on fait avec
Définir le type du fichier (non détecté) [COMMAND] :set filetype=<le type>
[Ne plus] Produire un backup [NORMAL] :set [no]backup
Définir une extension propre pour le backup :set backupext=<extension>
Exemple
:set backuptext=.bak => le backup de fichier.txt sera fichier.txt.bak.
Définir le dossier du backup :set backupdir=/path/to/bckup/folder/
Note Par défaut, c'est le dossier du fichier. Si un dossier est choisi de cette manière, attention aux collisions de noms.
Définir les fichiers à ne pas backuper :set backupskip=...
Ouvrir le fichier en lecture seule (depuis Vim) [NORMAL] :view path/to/file
Ouvrir un fichier en lecture seule (depuis Terminal) $> vim -R fichier.ext
$> view fichier.ext
Ouvrir un fichier en encryption $> vim -x secret.txt
Ouvrir un fichier sans swap file $> vim -n secret.txt
Note Utilisé justement pour les fichier encryptés, afin que les swap-files ne puissent être consultés pendant l'édition du fichier apr un utilisateur qui auraient des superprivilèges.
Ouvrir un fichier quelconque en édition [NORMAL] :e
=> La liste du dossier courant s'affiche
<debut>
=> Le nom se développe.		 edit
Ouvrir un fichier sans enregistrer les changements du fichier précédent [NORMAL] :e! path/to/file edit ! attention : sans sauver les changements précédents
split Ouvrir un fichier en splitant la fenêtre [NORMAL] :sp <path/to/file> split
Exemple
:sp ~/.vimrc (ouvre vimrc en splitant la fenêtre)
Ouvrir un fichier en se plaçant sur une certaine ligne [XTERM] $> vim +<numéro ligne> <path/to/fichier.ext>
Ouvrir un fichier en se plaçant sur un mot particulier [XTERM] $> vim +/<search> <path/to/fichier.ext>
Ouvrir plusieurs fichiers en même temps :next <file1> <file2> etc.
:args
Nouveau hublot en splitant la fenêtre courante [NORMAL]
Enregistrer le fichier courant [NORMAL] :w[rite]
Enregistrer tous les fichiers courants (même les buffers cachés) [NORMAL] :wa[ll] write all
Enregistrer et quitter le fichier courant [NORMAL] wq write quit
Enregistrer sous un autre nom [NORMAL] saveas
Note Toutes les sauvegardes suivantes se feront dans ce fichier, contrairement à :write qui n'enregistre que ponctuellement dans un autre fichier.
Enregistrer en forçant un fichier ouvert en lecture seule [NORMAL] :w[rite]!
Enregistrer seulement un rang de lignes dans un fichier [NORMAL] :<de ligne>,<à ligne>[ <path/to/file.ext]
Exemple
:20,41 monfichier.txt enregistre les lignes 20 à 41 du buffer courant dans le fichier monfichier.txt
printpostscript Enregistrer le texte au format PostScript [COMMAND] hardcopy > <path/to/file.ps>
Note En fait, on utilise la commande pour imprimer, qu’on détourne vers un fichier.
Fermer le fichier courant sans l’enregistrer [NORMAL] :q! quit ! attention : sans sauver
Fermer le fichier courant en l’enregistrant [dans un autre fichier] [COMMAND] e[xit] [<path/to/file.ext>]
Note exit, contrairement à write, ne sauve que si le fichier a été changé.
Fermer le fichier courant en enregistrant un certain rang de lignes dans un autre [COMMAND] :<rang> e[xit] <path/to/file.ext>
Exemple
:.,.+10 exit ~/mon.txt => enregistre les dix lignes à partir de la ligne courante dans le fichier mon.txt et ferme le fichier.
Fermer/quitter tous les fichiers [NORMAL] :qa[ll] quit all
Note Ajouter ! à la fin pour forcer la fermeture sans enregistrer les modifications non enregistrées.
Fermer/quitter tous les fichiers en les enregistrant [NORMAL] :wqa[ll]
[NORMAL] :xa[ll]		 write quit all
dossier Définir le dossier courant en path et tous ses sous-dossiers :set path=$PWD/le/dossier/** (ne pas oublier les ** à la fin)
Rechercher un fichier et l'ouvrir :find <nom exact du fichier.extension> (il faut avoir setté le path avant : :set path=...)
Rechercher un fichier et l'ouvrir en splittant la fenêtre :sfind <nom exact du fichier.extension>
Lister dans le buffer courant les fichiers/dossiers courants [NORMAL] !!ls
comparerdiff Comparer deux fichiers $> vimdiff <path/to/file1> <path/to/file2>
[COMMAND] :vert splitdiff <path/to/file2>
Note Avec la seconde solution, le premier fichier doit être ouvert.
Aller à la [xième] différence suivante [NORMAL] [x]
Revenir à la [xième] différence précédente [NORMAL] [x]
diff Modifier l'autre fichier avec le texte du fichier courant [NORMAL]
[NORMAL] :[<range>] diffpu[t] [version à corriger]		 diff put
diff Modifier l'autre fichier avec le texte du fichier courant [NORMAL]
[NORMAL] :[<range>] diffg[et] [version à corriger]		 diff obtain
Modifier un fichier à l'aide d'un script bash (shell script) 1. Écrire le shell
2. L'enregistrer (dans change.vim par exemple)
3. $> vim -es monfichier.ext < change.vim
Note les options signifient : e = en mode ex, qui permet de shell script, s = en mode silencieux, pour ne pas avoir les retours de commande.
Exemple
Pour remplacer le mot PHIL par MARION dans plusieurs fichiers :
1. Enregistrer le code suivant dans le fichier change.vim ::%s/PHIL/MARION/g
:write
:quit
2. Écrire un fichier fichier.txt avec des PHIL.
3. Quitter Vim
4. Taper :
$> vim -es fichier.txt < change.vim`
=> Tous les PHIL sont remplacés par des MARION dans le fichier.
Revenir à la version du fichier un certain temps avant [NORMAL] :earlier <temps>
Note Avec <temps> qui peut être en secondes ([x]s) en minutes ([x]m) ou en heures ([x]h).
Exemple
:earlier 1h fait revenir à l'état du fichier une heure plus tôt.
Revenir à la version du fichier un certain temps après (quand :earlier a été utilisé) [NORMAL] :later <temps>
Note Avec <temps> qui peut être en secondes ([x]s) en minutes ([x]m) ou en heures ([x]h).
Exemple
Quand on a joué avant :earlier 1h (retour à l'état du fichier 1 heure avant), la commande :later 1h fait revenir au dernier état du fichier.

MULTI-FICHIERS

Tags Action Shortcut Mnémo
Définir les paths par défaut [NORMAL] :set path=<path/1>,<path/2>…,<path/N>
Valeurs avec path/N :
<dossier>/* => tous les dossiers du dossier
<dossier/** => toute la hiérarchie du dossier
=> le dossier courant (donc on doit avoir deux virgules dans la définition)
. => le dossier du fichier courant (fichier activé au moment de l’opération)
Définir un dossier au top de la recherche [NORMAL] :set path ^= <path/to/folder>
[NORMAL] :set path+=<path/to> (?)
Exemple
:set path ^= ../lib place le dossier lib situé dans le dossier parent du dossier parent dans les paths de recherche.
Ouvrir plusieurs fichiers dans des buffers $> gvim path/to/file1 path/to/file2 Ne semble pas fonctionner sur mac par défaut.
Passer au(x) fichier(s) suivants [NORMAL] :[x]n[ext]
Passer au(x) fichiers(s) précédents [NORMAL] :[x]p[previous]
[NORMAL] :[x]
Passer au dernier fichier édité [NORMAL] ^
Passer au premier fichier [NORMAL] :first
Passer au dernier fichier [NORMAL] :last
Passer au fichier suivant en enregistrant le courant [NORMAL] :wn[ext]
[NORMAL] :writen
Passer au fichier suivant sans enregistrer le courant [NORMAL] :n[ext]!
Passer en enregistrement automatique au changement de fichier [NORMAL] :set autowrite
Sortir de l’enregistrement automatique au changement de fichier [NORMAL] :set noautowrite

BUFFERS

Tags Action Shortcut Mnémo
Nouveau buffer sans nom (sans fichier) [NORMAL] :ene[w] edit new
Afficher la liste des buffers [NORMAL] :ls
[NORMAL] :buffers
[NORMAL] :files		 list
Activer le buffer précédent de la fenêtre courante [COMMAND] b#
Activer un buffer quelconque [NORMAL] :b
=> La liste des buffers s'affiche		 détail
Activer le [xième] buffer suivant [NORMAL] :[x ]bn
[NORMAL] :b[x ]next		 buffer next
Activer le [xième] buffer précédent [NORMAL] :[x ]bp[rev] buffer
Activer le [xième] buffer modifié [en splitant] [NORMAL] :[s]bmodified [x] buffer
Activer le premier buffer [NORMAL] :bf[irst]
[NORMAL] :br[ewind]		 buffer
Activer le dernier buffer [NORMAL] :bl[ast] buffer
Activer un buffer par son numéro (dans la fenêtre active) [NORMAL] :b[uffer] <numéro> buffer
Note On peut jouer :ls avant pour obtenir la liste des buffers avec leur numéro.
split Activer un buffer en splitant horizontalement la fenêtre [NORMAL] :sb[uffer] <désignation buffer>
split Activer un buffer en splitant verticalement la fenêtre [NORMAL] :vert[ical] :sb[uffer] <désignation buffer>
Activer un buffer par le nom du fichier/path dans la fenêtre active [NORMAL] :b <bout du nom> buffer
Ouvrir tous les buffers dans des fenêtres [NORMAL] ba[ll]
[NORMAL] sba[ll]
Ajouter un buffer (un fichier) à la liste, sans l’ouvrir [NORMAL] :bad[d] +>num ligne> <path/to/file> buffer add (ajouter)
Masquer le buffer courant [NORMAL] :hid[e]
Supprimer le buffer courant [NORMAL] :bd[elete] buffer delete
Supprimer le buffer courant sans enregistrer [NORMAL] :bd! buffser delete
Supprimer tous les buffers courant [COMMAND] <premier>,<dernier>bd
Note 1 À ma connaissance, il n’a pas de commande pour refermer d’un coup tous les buffers, mais on peut utiliser cette astuce.
Note 2 Elle fonctionne même s’il y a des “trous” (des numéros de buffer absents)

DÉPLACEMENTS

Tags Action Shortcut Mnémo
Mettre un signet (mark) sur la ligne courante. [NORMAL] m[ark] <lettre>
Mettre un signet (mark) sur une ligne pour son numéro. [COMMAND] :<numéro ligne> m[ark] <lettre>
[COMMAND] :<numéro ligne> <lettre>
Note Avec , on n’est pas obligé de laisser une espace avant la lettre du registre.
Déplacer plusieurs lignes à une ligne précise [COMMAND] :<range> move <ligne before>
Exemples
:2,4 move 9 => déplace les lignes de 2 à 4 (comprise) APRÈS la 9<sup>e</sup> ligne.
:.,.+2 move 10 => Si la ligne courante (.) est la 5e, copie les lignes 5 à 7 après la ligne 10.
Retourner à une position précédente [NORMAL] :ju[mps] => Choisir la destination
Retourner à la position précédente (jump) [NORMAL]
Retourner à la position suivante [NORMAL]
Retourner au dernier changement [NORMAL] g;
Note On peut avoir la liste des changements avec :changes.
Retourner au xième changement [NORMAL] [x]g, ()
Note On peut avoir la liste des changements avec :changes.
document Aller au début du document [NORMAL] go
mot Aller au mot suivant [NORMAL] [x] word
mot Aller à la fin du mot suivant [NORMAL] [x] end
mot Aller à la fin du [xième] mot précédent [NORMAL] [x] end
Aller au début de la ligne « écran » suivante [NORMAL]
Note La ligne « écran » correspond à la nouvelle ligne qu'on voit à l'écran, mais qui appartient peut-être à la même « ligne texte » que la ligne écran précédente.
Aller au début de la « ligne texte » suivante [NORMAL]
Note Cf. la note concernant la commande précédente
Régler les options pour que les touches H, M, L, G et -END (?) retourne au début de la ligne [COMMAND] :set [no]startofline
Aller au début de la « ligne texte » précédente [NORMAL]
Aller au début de la « ligne écran » précédente [NORMAL]
Aller au début de la [xième] phrase suivante [NORMAL] [x])
Note Les phrases sont reconnues grâce aux ponctuations : . (point), ! (point d'exclamation) ? (point d'interrogation). Le point-virgule n'est pas concerné.
Aller au début du [xième] paragraphe suivant [NORMAL] [x]} ou [x]+
Aller au début de la [xième] phrase précédente [NORMAL] [x]( ou [x]-
Aller au début du [xième] paragraphe précédent [NORMAL] [x]{
mot Aller au mot précédent [NORMAL] [x] backard
ligne Aller à la ligne <i>num</i> [NORMAL] :<numéro ligne>
[NORMAL] <numéro ligne>
[NORMAL] <numéro ligne> 		go
Aller à la première ligne de l’écran affiché [NORMAL] High
Aller à la [x]ième ligne de l’écran actuel [NORMAL] [x]
Aller à la dernière ligne de l’écran actuel [NORMAL] Last ou Low
Aller à la [x]ième dernière ligne de l’écran actuel (en partant du bas) [NORMAL] [x] Last ou Low
ligne Aller à la fin de la ligne [NORMAL] $ Comme dans les expressions régulières
lettre Aller au premier caractère non blanc de la ligne [NORMAL] ^ Comme expressions régulières
ligne Aller au début de la ligne [NORMAL] 0
ligne Aller à la fin de la xième ligne après la courante [NORMAL] <nombre lignes>
paragraphe Aller au début du paragraphe précédent [NORMAL] - -/+ pour les paragraphes
paragraphe Aller au début du paragraphe suivant [NORMAL] + -/+ pour les paragraphes
Aller au début du paragraphe suivant [NORMAL]
Aller à l’autre bout de la sélection [VISUAL]
Aller à la première occurrence du mot sous le curseur [NORMAL] [
Donc: 5,
Aller à l’occurrence suivante du mot sous le curseur [NORMAL] ]
Donc: °,
curseur Aller à la dernière position du curseur [NORMAL] ''
curseur Aller au début du dernier insert [NORMAL] '[ Note : ne semble pas fonctionner (sur mac)
lettre Aller au premier (ou xième) caractère suivant voulu [NORMAL] [x]f<caractère> find
lettre Aller juste avant le premier [ou xième] caractère suivant cherché [NORMAL] [x]t<car> 'til (until)
lettre Aller au premier [ou xième] caractère précédent voulu [NORMAL] [x]<car> f/F pour find avant/arrière
lettre Aller juste avant le premier [ou xième] caractère précédent voulu [NORMAL] [x]t<car> t/T pour until avant/arrière
écran Aller un demi-écran plus le bas [NORMAL] down
écran Aller à l’écran suivant [NORMAL]
écran Aller un demi-écran vers le haut [NORMAL] up
document Aller à la fin du document [NORMAL] Go
document Aller à un certain pourcentage du document [NORMAL] <x>%
Exemple
50% se rend à la moitié du document.
pairs Aller à l’élément paire (précédent/suivant) [NORMAL] % (ù)
pairs Définir les caractères formant des paires [NORMAL] :set matchpairs=<in>:<out>,<in>:<out>,etc.
Exemple
:set matchpairs=(:),[:],{:},<:>
pairs Ajouter une paire de caractères [NORMAL] :set matchpairs+=<in>:<out>
Exemple
:set matchpairs+=<:> ajoute la paire "<" et ">".
Définir le comportement du curseur en début et fin de ligne :set whichwrap=<lettre>

MARQUES

Tags Action Shortcut Mnémo
Supprimer toutes les marques [NORMAL] :delmarks
Bloquer les marques avant modification du fichier [NORMAL] :lockmarks
Conserver les marques avant modification du fichier [NORMAL] :keepmarks
Note Contrairement à lockmarks, qui ne raccourcit pas le fichier, ici, le fichier peut être raccourci et les marques des lignes supprimées sont supprimées elles-aussi.
mark Afficher toutes les marques définies [NORMAL] :marks
mark Afficher les informations sur une marque en particulier [NORMAL] :marks <lettre>
mark Définir la marque précédente [NORMAL] m' mark
markcurseur Placer une marque locale au curseur [NORMAL] <a-z> marque
Note La marque est « locale », c'est-à-dire qu'elle est propre au fichier/buffer et qu'elle ne peut pas être rejointe depuis un autre endroit que le fichier.
markfichier Placer une marque globale au curseur [NORMAL] <A-Z> marque
Note La marque est « globale », c'est-à-dire qu'on peut l'atteindre même depuis un autre fichier/une autre fenêtre.
mark Aller à une marque définie [NORMAL] '<a-zA-Z>
[NORMAL] `<a-zA-Z>		 "'" se rend au début de la ligne
"`" se rend à la ligne/colonne de la marque.

SÉLECTION

Tags Action Shortcut Mnémo
Sélectionner plusieurs lignes entières [NORMAL] / V majuscule bascule en mode visuel par ligne.
Sélectionner (pour copier) une grande portion de texte [NORMAL] 1. Placer une marque au début (mz)
2. se rendre à la fin de la portion
3. taper d'z
Sélectionner en mode block-visual
Sélectionner le mot sous le curseur et l’espace suivante [VISUAL]
Sélectionner le mot sous le curseur et seulement le mot [VISUAL] inner word
Sélectionner la phrase sous le curseur et l’espace suivante [VISUAL] sentence, phrase
Sélectionner la phrase sous le curseur sans l’espace suivante [VISUAL] inner sentence
Sélectionner le paragraphe sous le curseur et l’espace suivante [VISUAL] paragraphe
Sélectionner le paragraphe sous le curseur sans l’espace suivante [VISUAL] inner paragraph
Sélectionner le texte entre parenthèses et les parenthèses [VISUAL] (
[VISUAL] )
[VISUAL]
Sélectionner le texte entre parenthèses sans les parenthèses [VISUAL] (
[VISUAL] )
[VISUAL]
Sélectionner le texte sous le curseur entre < et > [VISUAL] <
[VISUAL] >
Sélectionner le texte sous le curseur entre les <...> sans les < et > [VISUAL] <
[VISUAL] >
Sélectionner le texte sous le curseur entre {/}, [/], '/', etc. avec les signes et l’espace suivante. [VISUAL] [signe]
Exemple
{ sélectionne tout ce qui est entre les crochets avec les crochets
Sélectionner le texte sous le curseur entre {/}, [/], '/', etc. sans les signes. [VISUAL] [signe]
Exemple
" sélectionne tout ce qui est entre guillemets sans les guillemets.
Sélectionner le texte entre deux tags XML avec les tags. [VISUAL] tag
Exemple
Avec <div>Mon texte.</div>, sélectionne <div>Mon texte.</div>
Sélectionner le texte entre deux tags XML sans les tags. [VISUAL] inner tag
Exemple
Avec <div>Mon texte.</div>, sélectionne Mon texte.
Déplacer le curseur d’un bout à l’autre de la sélection [VISUAL]
Resélectionner la sélection visuelle précédente [VISUAL]
Note Bascule entre la sélection courante et la précédente
Passer en mode sélection de caractère [NORMAL]
Note Attention, le déplacement ne peut plus se faire avec lettres.
Passer en mode sélection de lignes [NORMAL]
Passer en mode sélection par block [NORMAL]

TEXTE

Tags Action Shortcut Mnémo
Jouer une commande sur toutes les lignes correspondant à une pattern [COMMAND] :g[lobal][!] /<reg exp>/ <commande>
Exemples
:global ,^La, delete => Efface (delete) toutes les lignes qui commencent (^) par « La ».
:global! ,^La, delete => Efface (delete) toutes les lignes qui ne commencent pas (! et ^) par « La ».
:g ,Marion, print => imprime toutes les lignes contenant « Marion »
Jouer une commande sur toutes les lignes ne correspondant pas à une pattern [COMMAND] :global! ...
[COMMAND] :vglobal ...
Note Voir la commande précédente.
Insérer le texte du presse-papier système [NORMAL] :set paste, , :set nopaste
Note En fait, ça a l'air de fonctionner aussi avec normalement.
Insérer le contenu d’un fichier [après une ligne] [COMMAND] :[line]read <path/to/the/file.ext>
Note Si aucune ligne n’est spécifié, ajoute après la ligne courante. Si aucun fichier n’est spécifié, ajoute après le fichier courant.
Insérer le résultat d’une commande à la ligne courante [ou après une certaine ligne] [COMMAND] :[line]read !<commande>
[COMMAND] :r!<commande>
Exemples
:4 read !echo "Bonjour" => écrit « Bonjour » après la 4e ligne.
r!ls => écrit les fichiers du dossier courant dans la fenêtre courante
Insérer le contenu d’un registre (en mode insertion) [INSERT] <a-z du registre>
Note En répétant , on insert le contenu sans interprétation des caractères spéciaux tels que <BS>.
Insérer une nouvelle ligne sous la ligne courante et passer en édition [NORMAL] open up new line
Insérer une nouvelle ligne au-dessus de la ligne courante et passer en édition [NORMAL] Open up new line
Insérer des lignes à partir d’une certaine ligne en mode commande. [COMMAND] :<index ligne 0-start> a[ppend]
Ligne 1
Ligne 2 ... Ligne N
Exemple
:0 a
Une nouvelle ligne
.
 => Ajoute « Une nouvelle ligne » tout en haut du fichier.
Insérer des lignes à partir d’une certaine ligne en mode commande. [COMMAND] :<index ligne 1-start> i[nsert]
Lignes ...
Note Je mets « 1-start » mais en fait il faut comprendre que append ajoute au bout de la ligne et que insert insert avant.
Stopper le mode insertion introduit par insert [COMMAND] :stopinsert
Note C’est surtout utile quand on programme des commandes.
Exemple
:autocmd BufEnter * :stopinsert
Insérer du texte APRÈS le caractère courant [NORMAL] append after
Insérer du texte AVANT le caractère courant [NORMAL] insert
ligne Insérer du texte à la fin de la ligne [NORMAL] Append
Insérer du texte au début de la ligne [NORMAL] <texte>
Note Passe en mode INSERT après la touche
digraph Insérer un caractère spécial (digraphs) [INSERT] <2 lettres du digraph> Spécial karactère
Note Voir aussi plus bas.
Exemples
a> affichera â (a circonflexe)
i: affichera ï (i tréma)
Taper :digraphs pour voir la liste.
Insérer plusieurs fois le même caractère [NORMAL] <fois><signe>
Note Il faut bien utiliser la touche et non pas pour quitter le mode.
Exemple
80i- insert 80 tiret au curseur
Insérer n’importe quel caractère tel quel. [INSERT] <signe>|<numéro unicode>
Note Ça concerne aussi bien les retours chariot que les tabulations.
Exemples
â va écrire "â" à l’écran
226 va écrire aussi "â" à l’écran
Insérer le texte du presse-papier après le caractère courant [NORMAL] [x] paste
Insérer le texte du presse-papier AVANT le caractère suivant [NORMAL] [x] paste
date Insérer la date au curseur [NORMAL] !!date
Insérer une expression arithmétique (registre expression "=) ou une fonction/opérateur Vim [NORMAL] "=<expression>
Exemples
"=12*12 insert « 144 » au curseur
"= %:p insert le path (:p) du fichier courant (%) au curseur
"=$HOME colle au curseur le chemin vers home
"=$PWD colle au curseur le chemin vers le dossier racine courant.
Insérer le même texte sur plusieurs lignes [VISUAL-BLOCK] () sélectionner les lignes, , taper le texte,
Exemple
Si on utilise au lieu d'pour terminer, ça ne fonctionne pas.
Insérer des espaces sur plusieurs lignes [VISUAL-BLOCK] () sélectionner les lignes, >, ; pour augmenter
Exemple
Pour supprimer ces espaces, utiliser <
Insérer n'importe quel caractère par son numéro ASCII ou hexa [INSERT] <nombre>
Exemples
i pour passer en mode INSERT, 123 => insert le caractère « { »
i pour mode INSERT, x7b insert le caractère « { ».
Afficher tous les caractères spéciaux [NORMAL] :digraphs
Afficher les informations sur le caractère sous le curseur [NORMAL] :ascii
Afficher des informationssur la position courante [NORMAL]
Note Affiche la colonne/nombre de colonnes, la ligne/nombre de lignes, le mot/nombre de mots, la caractère/nombre de caractères, le byte, nombre de bytes.
Modifier le texte en le remplaçant [NORMAL] [w|c] change
Exemples
[NORMAL] => [INSERT] <nouveau texte>
[NORMAL] [VISUAL] [INSERT] => change le mot
Modifier toute la ligne (même si on n’est pas placé au début) [NORMAL]
Modifier depuis le curseur jusqu’à la fin de la ligne [NORMAL]
[NORMAL] 		Comme mais passe en édition.
Modifier le caractère courant (et les x suivants) [NORMAL] [x]<car> replace
Modifier la casse du caractère courant (et les x suivants) [NORMAL] [x]~ ()
Modifier la casse de toute la ligne courante [NORMAL] ~ ~
Donc :
Passer le texte en capitales jusqu’à la motion définie [NORMAL] <motion>
Exemple
Pour modifier depuis le curseur jusqu'à la fin de la ligne :
Passer le texte en minuscules jusqu’à la motion définie [NORMAL] <motion>
Exemple
Mettre en minuscules depuis le curseur jusqu'à la fin de la ligne :
Encrypter/décrypter le texte sélectionner [VISUAL]
Note Utilise l’encodange <em>Rot13</em>
Incrémenter [de x] le nombre sous le curseur [NORMAL] [x]
Note Tient compte de la base : un nombre commençant par 0 est considéré comme octal, un nombre commençant par 0x est considéré comme hexadécimal
[Dés]activer la correction autographique [NORMAL] :set [no]spell
Définir la langue du texte [NORMAL] :set spelllang=fr (ou 'de', etc.)
Définir sa propre liste de mots corrects [NORMAL] :set spellfile=<path/to/file.add[,<path/other/file.add]
Note L'extension doit obligatoirement être .add.
Compiler son propre dictionnaire [NORMAL] :mkspell [-ascii ]<out-file> <in-file> make spell
Note On ajoute l'option -ascii pour dire à vim de passer tous les caractères non-ASCII.
Le nom des fichiers d'entrée doit respecter la convention <langue>_<region> (fr_FR pour la France métropolitaine).
Ajouter un dictionnaire
Note Le télécharger à l'adresse https://extensions.libreoffice.org/extensions/dictionnaires-francais par exemple.
Ajouter un mot au dictionnaire personnel [NORMAL] Placer le curseur sur le mot puis taper
Ou[COMMAND]:spellg[ood] <mot>
Note Ajouter un index devant la commande si plusieurs dictionnaires sont spécifiés par :set spellfile
Exemple
2 => Ajoute le mot sous le curseur au deuxième dictionnaire spécifié.
Ajouter un mot correct au dictionnaire volatile (session) [NORMAL] Placer le curseur sur le mot puis taper zG ()
[NORMAL] [COMMAND]:spellg[ood]! <mot>
Ajouter un mot erroné au dictionnaire [NORMAL] Placer le curseur sur le mot puis zw ()
[NORMAL] COMMAND]:spellw[rong] <mot>
Ajouter un mot erroné au dictionnaire volatile (session) [NORMAL] Placer le curseur sur le mot puis zw! (!)
[NORMAL] [COMMAND]:spellw[rong]! <mot>
Annuler l'ajout au dictionnaire [NORMAL] Placer le curseur sur le mot puis
[NORMAL] [COMMAND]:spellu[ndo] <mot>
Annuler l'ajout au dictionnaire volatile (session) [NORMAL] Placer le curseur sur le mot puis !
[NORMAL] [COMMAND]:spellu[ndo]! <mot>
Obtenir des suggestions concernant le mot erroné [NORMAL] se placer sur le mot erroné et taper =
mot Définir ce qu'est un mot [NORMAL] :set iskeyword=<définition>
Note La valeur peut être une lettre ou son code ASCII
Exemple
:set iskeyword=a,e,i,o,u => les mots seront exclusivement des voyelles.
:set iskeyword=a-z => les mots seront exclusivement les mots minuscules, etc.
Affficher la liste des mots actuels [NORMAL] :spelld[ump]
Afficher la définition de ce qu'est un mot [NORMAL] :set iskeyword?
Aller à l’erreur orthographique suivante [NORMAL] ]s (°, )
Joindre des lignes par leur rang [sans espace] [COMMAND] :<rang> join[!]
Exemples
:4,6 join => join les lignes 4, 5 et 6 en les séparant par une espace.
:4,6 join! => join les lignes 4, 5 et 6 sans les séparer par une espace.
Joindre les lignes sélectionnées en mode visuel (espace séparatrice) [VISUAL] join
Joindre les lignes sélectionnées sans ajout d’espace [VISUAL]
Joindre la ou les lignes suivantes à la ligne courante [NORMAL] [x] join
Supprimer le dernier mot entré avant le curseur [INSERT] word = mot
Note Noter qu'il s'agit bien du mot INSERT et pas du mode NORMAL. En mode NORMAL, le raccourci permet notamment de switcher entre les fenêtres.
Supprimer la dernière ligne entrée avant le curseur [INSERT]
Note Noter qu'il s'agit du mode INSERT.
Supprimer la ligne courante [NORMAL] delete
Note Elle est mémorisée dans le registre par défaut et peut être pastée à l’aide de .
Supprimer la ligne courante en la mémorisant dans un buffer [NORMAL] "[a-Z] " pour indiquer le buffer, de a à z et A à Z
Supprimer jusqu’à la fin du mot courant ou du xième mot [NORMAL]
[NORMAL] [x]		 delete word
Exemples
"c'est un antidote pour les", => "c'est un ant pour les"
"c'est un antidote pour les", => "c'est un pour les" (le mot complet supprimé)
"c'est un antidote pour les", 3=> "c'est les" (trois mots supprimés)
Supprimer jusqu’à la fin de la ligne [NORMAL]
[NORMAL] 		= fin de ligne
Supprimer jusqu’à la fin de la ligne et passer en insertion [NORMAL] Change
Supprimer en mode visuel [NORMAL] [VISUAL] <move> "
Supprimer jusqu’à un certain caractère [NORMAL] df> (utiliser . pour répéter)
Supprimer/yanker une ligne par son numéro [et la placer dans un registre] [COMMAND] :<numéro ligne>delete [registre]
Note Si le registre est Majuscule, la commande ajoute le texte au texte présent dans le registre minuscule.
Exemples
:5delete => supprime la ligne 5.
:6delete z => supprime la ligne 6 en plaçant son contenu dans le registre "z".
:7delete Z => supprime la ligne 7 en AJOUTANT son contenu au registre "z".
Supprimer/yanker des lignes à partir d’un numéro et pour un certain compte [en les plaçant dans un registre] [NORMAL] :<ligne from> delete [registre] <nombre ligne>
Note Si le registre est majuscule, on AJOUTE le contenu des lignes au registre.
Exemples
:4 delete 10 => efface 10 lignes à partir de la 4e comprise
:2 delete s 4 => efface 4 lignes à partir de la 2 et place leur contenu dans le registre "s"
:10 delete S 2 => efface 2 lignes à partir de la 10e et AJOUTE leur contenu au registre "s"
Supprimer/yanker un rang de lignes [en l’insérant dans un registre] [COMMAND] :<range> delete [registre]
Note Si le registre est une capitale, c’est un ajout au texte existant qu’il faut faire.
Exemples
:1,3 delete a => supprime les lignes 1 à 3 en en mettant le contenu dans le registre "a"
:4,5 delete A => supprime les lignes 4 à 5 en AJOUTANT leur contenu au registre "a"
Supprimer/yanker des lignes en spécifiant un mot qu’elles contiennent [et placer le contenu dans un registre]. [COMMAND] :/<mot ligne de>/, /<mot ligne à>/ delete [registre]
Note Si le <mot ligne à> se trouve avant le <mot ligne de>, la commande ne produit rien.
Exemples
: /depuis/, /jusqu’à/ delete w => efface les lignes depuis la ligne contenant "depuis" jusqu’à la ligne contenant "jusqu’à" et met le contenu dans le registre "w".
:/de/, /à/ delete W => ajoute depuis la ligne contenant "de" jusqu’à la ligne contenant "à" au registre "w" en supprimant les lignes.
Supprimer/yanker des lignes en spécifiant un mot contenu dans une ligne précédente ou suivante [COMMAND] :/mot de/<+|-><nombre lignes>, /mot à/<+|-><nombre lignes> delete [registre]
Supprimer/yanker des lignes en spécifiant plusieurs mots recherchés à la suite [COMMAND] :/mot 1/ /mot puis/ /autre mot puis.../, /mot 2/ /mot puis/ delete [registre]
Supprimer/yanker des lignes en précisant à quelle ligne commencer la recherche par mot [COMMAND] :[<numéro ligne>]/mot de/, [<numéro ligne>]/mot à/ delete [registre]
Note Attention de s’assurer que le second mot se trouve bien après le premier.
Exemple
:7/Marion/, 8/Phil/ delete R => Efface depuis la première ligne contenant "Marion" à partir de la ligne 7, jusque la ligne contenant "Phil" en ajoutant ces lignes au registre "r".
Yanker une portion de texte [NORMAL]
[NORMAL]
[NORMAL]
[NORMAL] etc.		 yank
Note On fait la distinction entre « yanker », qui mémorise un texte et « copier » qui ajoute un texte au texte.
Yanker la ligne courante dans le registre par défaut [NORMAL] yank
Note On fait la distinction entre « yanker », qui mémorise un texte et « copier » qui ajoute un texte au texte.
Yanker un rang de lignes [dans un registre] (en mode commande) [COMMAND] :<rang> yank[ <lettre registre>]
Exemples
:1,4 yank => copie les lignes 1 à 4 dans le registre sans nom.
:5,$ yank f => copie les lignes depuis la 5 jusqu’à la fin dans le registre « f ».
Yanker du curseur à la fin de la ligne dans le registre par défaut [NORMAL]
Yanker depuis le curseur jusqu’au début de la ligne [NORMAL] 0
[NORMAL] ^
Yanker depuis le curseur jusqu’à une marque [NORMAL] 1. Placer la marque (m<a-Z>)
2. Se déplacer à l'endroit voulu.
3. y'<a-Z>
Yanker le mot courant dans le registre par défaut [NORMAL]
Yanker plusieurs lignes [NORMAL] [x] p.e. 3y
Copier plusieurs lignes à un endroit du texte. [COMMAND] :<range> copy <ligne before>
Note On fait bien la différence, ici, entre « yanker » (qui ne fait <em>que</em> mémoriser le texte) et « copier » (qui <em>ajoute</em> le texte au texte).
Exemple
:2,4 copy 9 => yank le contenu des lignes de 2 à 4 (comprise) et le colle APRÈS la 9<sup>e</sup> ligne.
Enregistrer un bout du texte dans un fichier [VISUAL] sélectionner le texte puis :write <path/to/file.ext>
Note La commande prévient si un fichier existe déjà. Pour l'écraser, ajouter ! à la fin de la commande.
Ajouter le texte actuel au bout d’un fichier [même s’il n’existe pas] [NORMAL] :write[!] >> <path/to/file>
Note Pour être clair, sans « ! », la commande produit une erreur dans le cas où le fichier n’existe pas encore.
« Piper » le texte actuel vers un programme externe [NORMAL] :write !<programme>
Aide sur la suppression en mode visuel [NORMAL] :help v_d visual delete
ligneindentation Réindenter [x] ligne[s] [x] == Mêmes espaces
Note x est le nombre de lignes à réindenter
Indenter la ligne courante [INSERT]
Note Bien noter que c’est en mode [INSERT].
La valeur de l’indentation dépendera de la valeur de l’option shilfwidth.
Désindenter la ligne courante [INSERT]
Note Bien noter que c’est en mode [INSERT].
La valeur de l’indentation dépendera de la valeur de l’option shilfwidth.
ligneindentation Indenter la [ou les] ligne[s] courante[s] [NORMAL] [x]
Indenter un rang de lignes [COMMAND] :<rang>
Exemple
:4, 6 => indente les lignes 4 à 6 (les pousse vers la droite).
Désindenter un rang de lignes [COMMAND] :<rang>
Exemple
:4, 6 => désindente les lignes 4 à 6 (les pousse vers la gauche).
ligneindentation Désindenter la [ou les] ligne[s] courante[s] [NORMAL] [x]
Désindenter plusieurs lignes successives [INSERT] 0
Note Noter plusieurs choses : d’abord, on est en mode [INSERT] et donc le 0 sera écrit à l’écran. Noter ensuite que cette désindentation n’est pas définitive. L’utilisation de la supprimera.
Désindenter seulement une ligne et revenir à la même colonne [INSERT] ^
Note Mêmes remarque que pour la commande précédente.
Définir la largeur max des lignes à entrer [NORMAL] :set textwidth=<nombre colonnes>
Définir la marge droite pour enroulement du texte [NORMAL] :set wrapmargin=<nombre colonnes>
Reformater paragraphe après modification (ajout/suppression) [NORMAL] Sélectionner le texte puis
Note Dépend de la définition de textwidth et/ou wrapmargin ci-dessus.
Reformater des lignes en changeant la largeur de texte [NORMAL] :set textwidth=<nombre colonnes>
Sélectionner le texte
Reformater des lignes en indiquant leur nombre [NORMAL] <nombre> j
Reformater le paragraphe courant [NORMAL] inner paragraph
Reformater la ligne courante [NORMAL]
[NORMAL]
Reformater les lignes jusqu’au prochain paragraphe [NORMAL] }
Reformater les lignes de commentaires [VISUAL] Sélectionner les lignes,
Reformater en utilisant un programme « externe » [NORMAL] :set formatprg=<programme>
Exemple
:set formatprg=fmt
Aligner des lignes au centre (aka centrer) [NORMAL] Sélectionner les lignes
:<from>,<to> center <width>
Aligner des lignes à droite [NORMAL] Sélectionner les lignes
:<from>,<to> right <width>
Aligner des lignes à gauche [NORMAL] Sélectionner les lignes
:<from>,<to> left <width>
Jouer commande en mode INSERT [INSERT] <command> out
caractères spéciaux Afficher tous les caractères spéciaux [NORMAL] :digraphs
Imprimer les lignes choisies [COMMAND] :[from],[to]print
Exemples
:5print => imprimer la ligne 5
:1,5print => imprimer de la ligne 1 à la ligne 5
:5,$print => imprimer de la ligne 5 à la fin du texte
Imprimer tout le fichier [COMMAND] :%print
Imprimer la ligne courante [COMMAND] :.print
Imprimer une ligne suivante par son contenu [COMMAND] :/<pattern>/print
Exemple
:/arbre/print => imprime la première ligne suivante contenant 'arbre'
Imprimer la première ligne précédente contenant un texte [COMMAND] :?<pattern>?print
Exemples
:?aigre?print => imprime la première ligne précédente contenant 'aigre'
:?bien? print => imprime la première ligne précédente se terminant par 'bien.'
Imprimer depuis et/ou jusqu'à une marque [COMMAND] :'<a-z>, `<a-z> print
Imprimer le texte en visual mode [VISUAL] Passer en mode visuel, sélectionner puis taper :print pour imprimer la sélection.
Sortir en console le nombre de lignes du fichier [COMMAND] :=

AUTOCOMPLÉTION

Tags Action Shortcut Mnémo
Afficher/ne plus afficher les fichiers possibles sur la barre de statut [COMMAND] :set [no]wildmenu
Note Cette option agit lorsque l’on cherche un path par autocomplétion et qu’il y a plusieurs <em>candidats</em> pour répondre au wildcard.
Exemple
Si l’on fait :e ./au et qu’il y a plusieurs fichiers commençant par « au » dans le dossier, le nom de tous ces fichiers sera affiché dans la barre de statut et l’on pourra choisir le fichier voulu à l’aide de la touche .
Régler l’autocomplétion fichier sur le plus long fichier [COMMAND] -':set wildmode=longest (1)' -':set wildmode=longest:full'
Note 1 Remplit avec le plus long fichier plus s’arrête
Note 2 Remplit avec le plus long fichier pour poursuit si on continue de tabuler.
Note 3 Pour le moment, dans le Terminal, ça ne fait rien…
Régler l’affichage de la liste des fichiers possibles quand la touche d’autocomplétion fichier est jouée [COMMAND] :set wildmode=list
Note Il semble que ça ne fonctionne pas comme décrit dans le fichier VIM, car ce mode n’a pas besoin de list:full pour procéder à l’autocomplétion après avoir affiché la liste.
Alterner les modes [COMMAND] :set wildmode=<mode 1>,<mode 2>, etc.
Valeurs avec <mode X> :
full
longest => le plus long nom de fichier
list => par liste
Activer l’autocomplétion Démarrer Vim avec $> vim -N
Spécifier un ou plusieurs dictionnaires d’autocomplétion :set dictionary=file1,file2...
Spécifier un ou plusieurs fichiers thésaurus :set thesaurus=file1,file2,...
Restreindre à une liste d’éléments (dictionnaire, tags, etc.) [INSERT] , choisir l'option avec <touche>
Note l'option peut être : définition de macro,  : nom de fichier,  : dictionnaire,  : thésaurus,  : fichiers courants et #includes (en C),  : lignes complètes,  : “omni” complétion (omnifun)
Afficher les mots suggérés [NORMAL]
Suggérer un mot du thésaurus [INSERT] , Thesaurus
Suggérer un mot d'un dictionnaire [INSERT] , DiKtionnaire
Suggérer un mot se trouvant dans les fichiers dans le dossier courant [INSERT] , File
Note Utiliser pour passer au fichier suivant
Choisir le mot précédent dans la liste proposée [INSERT] (x fois) Previous, précédent
Note Chaque pression de la combinaison passe au mot suivant
Choisir le mot suivant dans la liste proposée [INSERT] (x fois) Next, suivant
Note On doit avoir afficher la liste des mots avec

TEXTE EXTRAS

Tags Action Shortcut Mnémo
Classer les lignes sélectionnées [VISUAL] 1. Sélectionner les lignes
2. !sort
Piper (pailleper) les lignes courante en les passant par une commande [VISUAL] :!<commande>
Exemple
:!sort => classe les lignes sélectionnées
Surligner du texte [NORMAL] :match <type> /<texte>/ p.e. <code>:match Error /TOOD/
Surligner jusqu’à trois types/trois recherches en même temps [NORMAL] :match ..., :2match ..., :3match ...
Afficher tous les types de surlignages [NORMAL] :highlight
Supprimer tous les surlignages [NORMAL] :match none

RECHERCHE ET REMPLACEMENT

Tags Action Shortcut Mnémo
Régler recherche incrémentale [NORMAL] :set [no]incsearch incremental search
Régler la recherche en mode [non] sensitif [NORMAL] :set [no]ignorecase
Régler la recherche pour rechercher sans sensitivité si le mot est tapé en minuscule. [NORMAL] :set ignorecase " ne tient pas compte de la case
:set smartcase "la case du mot entré comme rechercher influence la recherche
Exemples
'mot' recherchera 'mot', 'MOT', 'Mot', 'mOt'
'Mot' recherchera 'Mot'
'MOT' recherchera MOT
Régler la fin de la recherche à la fin du fichier [ou non] [NORMAL] :set [no]wrapscan " sans 'no', recherche au début après la fin
Interrompre une recherche [NORMAL]
Atteindre la première occurrence du mot sous le curseur en avant [NORMAL] ()
Atteindre la première occurrence du mot sous le curseur en arrière [NORMAL] (`)
[NORMAL] ()
Atteindre la <xième> ligne [après ou avant] un mot [NORMAL] /<search>/[+|-]<x>
Note Recherche en arrière : ?<search>?[+|-]<x>
Exemples
/arobase/3 => Se place 3 lignes après le mot 'arobase'
/arobase/-2 => Se place 2 lignes avant le mot 'arobase'
Répéter la recherche précédente [NORMAL] /
Note ? en arrière
Répéter la recherche précédente en supprimant l'offset [NORMAL] //
Note ?? en arrière
Répéter la recherche précédente avec un autre offset [NORMAL] //[+|-]<x>
Note ??[+|-]<x> en arrière
Placer le curseur <x> caractères [avant ou après] la recherche [NORMAL] /<search>/b[+|-]<x>
[NORMAL] /<search>/s[+|-]<x>
Note Recherche en arrière : ?<search>?b[+|-]<x>
Exemples
/marion/b5 => Se place 5 caractères après le mot 'Marion'
/marion/b-6 => Se place 6 caractères avant le mot 'Marion'
?marion?b-6 => Se place 6 caractères avant le mot 'Marion' trouvé en recherche arrière
Placer le curseur au bout de l'expression recherchée [NORMAL] /<search>/e
Placer le curseur <x> caractères [avant ou après] le bout de l'expression recherchée [NORMAL] /<search>/e[+|-]<x>
Note Utiliser le code //<x> pour recommencer la recherche avec un autre offset.
Exemples
/Marion/e4 => Place le curseur 4 caractères après le 'n' de Marion
/Marion/e-2 => Place le curseur sur le 'i' de 'Marion'
Rechercher une expression régulière dans des fichiers quelconques [NORMAL] :vimgrep /<reg exp>/ <where>
Exemples
:vimgrep /phil(ippe)?/ ~/Programmation => recherche toutes les occurrences de 'phil' ou 'philippe' dans le dossier Programmation
:vimgrep /phil(ippe)?/ ./**/*.txt => toutes les occurrences de 'phil' ou 'philippe' dans les fichiers .txt du dossier courant et ses sous-dossiers.
Afficher dans une nouvelle fenêtre tous les résultats de :vimgrep :cope[n]
Exemple
:vimgrep /phil/ ./*.data, :copen, /, pour afficher le fichier.
Afficher le résultat suivant de :vimgrep :cn[ext] next = suivant
Afficher le résultat précédent de :vimgrep :cp[revious]
:cN[ext] ()		 previous = précédent
Afficher le premier résultat de :vimgrep dans le fichier suivant :cnfile next
Surligner/retirer l'exergue les textes trouvés [NORMAL] :set [no]hlsearch highlight search
Supprimer la mise en relief courante [NORMAL] :nohlsearch
Chercher en avant quelque chose [NORMAL] /<quelque chose> Il faut escaper les signes .*[]^%/\?~
Chercher en avant la première occurrence de la lettre, puis les suivantes [NORMAL] <lettre>, puis ; () pour les suivantes, ou « , » (virgule) pour les précédentes.
Chercher quelque chose en arrière [NORMAL] ?<quelque chose>
Aller au(x) prochain(s) quelque chose (avant ou arrière) [NORMAL] [x]
[NORMAL] [x]/
[NORMAL] [x]?
Aller au(x) prochain(s) quelque chose en sens inverse [NORMAL]
Inverser la recherche [NORMAL] ? si on est en avant, sinon /
Afficher l’historique des recherches en avant [NORMAL] /
/ /		 Pour en sortir sans rien faire : ou ":"
Afficher l’historique des recherches en arrière [NORMAL] ?
? ?		 Pour en sortir sans rien faire : ou ":"
Substituer du texte dans le fichier courant \:[<range> ]s[ubstitute]/<get>/<set>[/<flags>] seach
Valeurs avec <flags> :
g => toutes les occurrences dans la ligne courante
p => en écrivant ((p)rint) les lignes modifiées
c => demande confirmation pour chaque changement
e => pas de sortie d’erreur, même si aucune occurrence
i => substitution non sensible à la casse
I => substitution sensible à la casse, même si l’option dit le contraire
l => imprime la ligne en mode « liste » après la substitution
n => indique le nombre de substitution opérée mais sans rien faire.
r => si la pattern de recherche est vide, utiliser la précédente
Note On peut remplacer le « / » par n’importe quel autre caractère à part un nombre, une lettre, la balance arrière, les doubles guillemets ou la barre verticale. Voir les exemples.
Exemples
:s/Phil/Marion/ => remplace une seule fois « Phil » par « Marion » dans la ligne courante.
:s ,Phil,Marion,gp => Remplace tous (drapeau « g ») les « Phil » par des « Marion » dans la ligne courante et écrit la dernière ligne modifiée en console (drapeau « p »).
:% +Phil+Marion+g => Remplace tous (flag « g ») les Phil par des Marion dans le fichier (rang « % »)
Substituer toutes les occurrences de la ligne courante :s/<get>/<set>/g seach, global
Substituer dans tout le fichier [COMMAND] :% s/<get>/<set>/g seach, global, % signife «tout le texte»
Substituer toutes les occurrences dans plusieurs lignes consécutives Passer en mode visuel avec [VISUAL-LINE] Sélectionner les lignes [COMMAND] :s/.../.../g
Substituer toutes les occurrences dans plusieurs lignes consécutives [COMMAND] :<de ligne>,<à ligne> s/.../.../g
Note Pour la dernière ligne, on peut utiliser .
Substituer avec une expression régulière [COMMAND] :s,<reg exp>,<set>[,<flags>] (si l’option « magic » est active)
[COMMAND] :sm[agic],<reg exp>,<set>[,<flags>] (si l’option « magic » n’est pas active)
Substituer sans expression régulière [COMMAND] :s,<exp>,<set>[,<flags>] (si l’option « magic » n’est pas active)
[COMMAND] :sno[magic],<exp>,<set>[,<flags>] (si l’option « magic » est active)
Exemple
:snomagic,***,+++,g => remplacera vraiment les « *** » par des « +++ »
Substituer à nouveau en modifier le rang ou les drapeaux [COMMAND] :<rang> & <drapeau>
Note Il faut répéter les drapeaux s’il y en a dans la définition initiale
Exemple
On joue d’abord s,Phil,Marion qui remplace une fois Phil par Marion dans la ligne. Si on fait :&gp, ça remplace tous les Phil et ça montre la ligne modifiée.
Substituer en remplaçant [ou non] par défaut toutes les occurrences de la ligne [COMMAND] :set [no]gdefault
Note Attention, ça peut entrainer des conséquences fâcheuses sur certains scripts.
Remplacer le caractère au curseur par le caractère fourni [NORMAL] <lettre>
Remplacer les caractères au curseur jusqu'à la sortie du mode [NORMAL] <texte> (ou )
[NORMAL] <texte>
Remplacer les [x] caractères par le texte fourni [NORMAL] [x]s<texte>
Note Vim passe en mode INSERT après que la touche a été pressée.
Remplacer le caractère courant par le texte fourni [NORMAL] s<texte>
Note Mais contrairement à qui reste en mode [NORMAL], Vim reste en mode [INSERT] après que la touche a été pressée.
Remplacer la ligne courante par le texte fourni [NORMAL] <texte>
Note Vim passe en mode INSERT après que la touche a été pressée.
Remplacer le texte en mode [SELECT] [NORMAL] , /pour sélectionner, <texte>

EXPRESSION RÉGULIÈRES

Tags Action Shortcut Mnémo
Spécifier le début d'un mot \<
Exemple
\<pour\> recherche le mot 'pour' exactement, et exclus par exemple 'pourparler'
Spécifier la fin d'un mot \>
Spécifier de rechercher zéro ou plusieurs occurrences \*
Spécifier de rechercher une ou plusieurs occurrences \+
Spécifier de rechercher une ou zéro occurrences \=
Rechercher un caractère alphabétique \a
Rechercher un caractère non alphabétique \A
Spécifier de rechercher n’importe quel chiffre \d
Rechercher n’importe quelle lettre majuscule \u
[[:upper:]]		 upper
Note Plus rapide que de faire [A-Z].
Rechercher tout sauf des majuscules \U
Rechercher n’importe quelle lettre minuscule \l
[[:lower:]]		 lower
Note Plus rapide que [a-z]
Rechercher tout sauf des minuscules \L
Rechercher n’importe quel caractère hexadécimal (0-F) \x
Rechercher n’importe quel caractère non hexadécimal (0-F) \X
Spécifier de rechercher un nombre précis de caractères \{<nombre>}
Exemple
a\{5} => recherche exactement 5 "a"
Recherche le mininum de caractères \{-<de>, <à>}
Exemple
a\{-3,5} => recherche entre 3 et 5 "a" sur la ligne, mais renverra l’atom le plus court.
Grouper des caractères \(<caractères>\)
Faire références à un groupe de caractères défini entre parenthèses \<index parenthèses 1-start>
Exemple
dans a\([b-d]\)1\([0-5]\), "\1" faire référence à "[b-d]" et "\2" fait référence à "[0-5]".

PRESSE-PAPIER (REGISTRE)

Tags Action Shortcut Mnémo
Enregistrer dans un registre de a à z "<lettre><quoi> p.e. : "
=> copier la ligne dans 'c'
Insérer le contenu d’un registre (en mode normal) [NORMAL] "<lettre> paste
Insérer le contenu d’un registre [avant] (en mode command) [COMMAND] :<numéro ligne> put[!] <lettre registre>
Exemples
:6 put e => insert le contenu du registre « e » après la 6e ligne.
:6 put! e => insert le contenu du registre « e » AVANT la 6e ligne.
Insérer le contenu d’un registre en adaptant l’identation [NORMAL] "<lettre> paste
Insérer le contenu d’un registre (en mode insert) [INSERT] <registre> Registre
Exemple
= insert au curseur le registre "=
Insérer le contenu d’un registre sans indenter (en mode insert) [INSERT] <registre>
Exemple
a -> insert le registre "a"
Insérer le contenu d’un registre en laissant Vim gérer l’identation. [INSERT] <registre>
Exemple
r -> insert le registre "r" en gérant l’identation correctement.
Insérer le contenu de la dernière suppession [NORMAL] "1
Note Les autres suppressions se trouvent dans les registres de 2 à 9
Insérer le contenu de l’avant-dernière suppression [NORMAL] "2
Note Les autres suppressions se trouvent dans les registres de 3 à 9
Ajouter du texte dans un registre "<lettre registre><quoi>
Exemples
"A => Ajoute la ligne courante au registre « a »
"Z => Ajoute le mot au registre « z »
Afficher le contenu de tous les registres [NORMAL] :reg[isters]
Afficher le contenu de registres en particulier [NORMAL] :reg[isters] <lettre><lettre> etc.
Exemples
:registers az => affiche le contenu des registres "a et "z
:reg qsb affiche le contenu des registres "q, "s et "b
Exécuter le contenu d’un registre [après une certaine ligne] [COMMAND] :[line]@<registre>
Référence au registre global "
Référence au registre « poubelle » "_

COMMANDES

Tags Action Shortcut Mnémo
Passer en revue toutes les commandes entrées en cours de session [NORMAL] :
[NORMAL] :
Afficher tout l’historique des commandes entrées au cours de la session [NORMAL] q:
[NORMAL]
Note Définir l’option cmdwinheight (cwh) pour régler la hauteur de la fenêtre affichant la liste.
Quitter tout [sans sauver] [NORMAL] :qall[!] quit all
Quitter en enregistrant tout [NORMAL] zzz (dodo)
Exécuter une commande externe \:!<commande>
Répéter la dernière commande externe exécutée :!!
Annuler la dernière commande [NORMAL] undo
Annuler [COMMAND] :undo
Annuler toutes les modifications faites sur la ligne courante [NORMAL] Undo
Annuler les modifications annulées par U sur la ligne courante [NORMAL]
Annuler une annulation [NORMAL] redo
Désactiver tous les plugins en démarrant Vim $> vim -u NONE
Passer en mode insertion [COMMAND] :startinsert
Note Correspond à la touche en mode normal.
Demander confirmation avant l’exécution d’une commande [COMMAND] confirm <commande>
Exemple
:confirm :quit => si le fichier a été modifié, demande confirmation avant de quitter.
Définir une variable [COMMAND] :let <nom variable> = <valeur variable>
Valeurs avec <nom variable> :
Tout en capitales, peut être sauvée dans le viminfo si l’option contient « ! »
Si commence par capitale (tout doit être en minuscules ensuite), sera sauvée par la commande :mksession.
Tout en minuscule : perdure juste le temps de la session
$<name> => variable d’environnement
@<register> => text register
&<option> => le nom d’une option
b:<variable name> => variable locale au buffer
w:<variable name> => variable locale à la fenêtre
g:<variable name> => variable globale
v:<variable name> => variable interne à Vim (v:count, v:count1, v:errmsg, v:warningmsg, v:statusmsg, v:shell_error, v:this_session)
Exemples
:let mon_nom = "Phil"
:let mon_age = 53
Supprimer la définition d’une variable [COMMAND] :unlet <nom variable>
[Dé]Bloquer une variable [COMMAND] :[un]lockvar <nom variable>
[COMMAND] :lockv <nom variable>
[COMMAND] :unlo <nom variable>
Écrire un message en console sur une nouvelle ligne [COMMAND] :echo <texte>
Écrire un message en console au bout du texte (sans nouvelle ligne) [COMMAND] :echon <texte>
Note Dans l’exemple, la barre verticale permet de jouer plusieurs commandes.
Exemple
echo "aa" | echo "ab" => produit aaab sur une même ligne en console
Écrire un message en couleur en console [COMMAND] :echohl <type couleur> | echo "mon message coloré" | echohl None
Valeurs avec <type couleur> :
ErrorMsg
Note Pour voir les types de couleur, taper :hi[ghlight] en console. hl comme highlight.
Exemple
:echohl ErrorMsg | echo "Ceci est une erreur en rouge." | echohl None => Écrire "Ceci est une erreur en rouge." en rouge dans la console.
Écrire un message d’erreur [COMMAND] :echoe[rr] Comme echo erreur
Note Si employé dans un script ou une fonctoin, ce code ajoute la ligne dans l’historique des erreurs et ajoute un numéro de ligne.
Écrire un message notice [COMMAND] :echom[sg] echo message
Note Si employé dans un script ou une fonction, ajoute aux messages de suivi qu’on peut relire avec :messages.

COMMANDES PERSONNELLES

Tags Action Shortcut Mnémo
Créer une commande [COMMAND] :command <NomCommande> <code à exécuter>
Note Les commandes personnelles doivent commencer par une capitale.
Exemples
:command SuppEntete :1delete => quand on tape :SuppEntete, cela supprime la première ligne
:command <SID>Delete :1,delete => Définit la commande Delete, mais en lui collant un préfixe qui supprimera toute collision possible avec des fonctions ou commandes existantes.
Lister les commandes personnalisées [COMMAND] :command
Supprimer une commande personnalisée [COMMAND] :delcommand <NomCommande>
Supprimer toutes les commandes personnalisées [COMMAND] :comclear
Définir les arguments d’une commande [COMMAND] :command -nargs=<valeur> <NomCommande> <code utilisant les arguments>
Valeurs avec <valeur> :
0 => aucun argument
1 => un argument, 2, etc.
* => nombre indéterminé d’arguments
? => Zéro ou un argument
+ => Un ou plus arguments
Exemple 
" Soit la commande définie par :

:command -nargs=+ Dire :echo "<args>"

" Si l’on joue :

:Dire Bonjour tout le monde !

" Cela écrira en console :

Bonjour tout le monde !
Utiliser un rang de ligne comme argument [COMMAND] :command <-range> <Commande> <code à exécuter>
Valeurs avec <-range> :
-range => un rang est attendu. Défaut : la ligne courante
-range=% => rang attendu, par défaut, le fichier entier
-range=<count> => juste un numéro de ligne dont le numéro est <count>
Note Lorsqu’un rang est fourni, <line1> et <line2> fournissent les valeurs de ce rang.
commandes Passer des arguments à une fonction comme une liste [COMMAND] :command -narg=* MaCommande :call UneFonction(<f-args>)
Exemple 
" Quand on fera :

MaCommande un deux trois

" Ça correspondra à un appel :

UneFonction("un", "deux", "trois")

LIGNE DE COMMANDE ET LANGAGE DE SCRIPT

Tags Action Shortcut Mnémo
Statement IF [COMMAND] :if {condition} | <statement> | elseif | <statement> | else | <statement> | endif
Note Bien sûr, les « | » peuvent être remplacés par des retours à la ligne avec ajoute de « : » en début de ligne : 
:if <condition>
: <statement>
: <statement>
:endif
Exemple
if 4 > 5 | echo "C’est vrai" | else | echo "C’est faux" | endif
Exécuter une boucle WHILE [COMMAND] :while <condition> | <statement> | endwhile
[COMMAND] 
:while <condition>
: <statement>
: <statement>
:endwhile
Note On peut passer directement à la valeur suivante avec continue ou sortir de la boucle avec break.
Exécuter une boucle FOR [COMMAND] :for <condition> | <statement> | endfor
[COMMAND] 
:for <condition>
:  <statement>
:  <statement>
:endfor
Exemple 
:let liste=["a", "b", "c"]
:for lettre in liste
: echo lettre
:endfor
Évaluer une commande [COMMAND] :exe[cute] <commande>
Exemple 
:let ma_commande = "echo \"Salue le monde !\""
:execute ma_commande
=> écrit "Salue le monde !" en console.
Placer le code dans un bloc d’erreur [COMMAND] :try | <statement> | catch <exp régulière> | <statement> | finaly | <statement> | endtry
[COMMAND] 
:try
:  <une opération>
:catch /<exp régulière de test d’erreur>/
:  <statement en cas d’erreur>
:finally
: <à faire dans tous les cas>
:endtry
Note On lève une erreur à l’aide de :throw "<erreur>" dans le statement. On utile :finish pour finir le code du bloc try.
Exemple 
:try
: unemauvaisecommande
:catch /^E492/
: echo "Cette commande est inconue."
:endtry

INTERFACE

Tags Action Shortcut Mnémo
Afficher/masquer les numéros de ligne :set [no]number
Appliquer un thème particulier pour cette session [NORMAL] :colo[rscheme] <nom du thème sans .vim>
Exemples
Le thème doit se trouver dans ./.vim/colors/
:colorscheme Tomorrow
Définir un thème particulier dans .vimrc colo[rscheme] <nom du thème>
syntax on
Choisir le type de fond (clair ou sombre) [COMMAND] set background=<light|dark>
Note Il faut bien sûr que le thème courant possède ces deux versions. Essayer par exemple avec elrodeo
Définir l’apparence du texte [NORMAL] :hi[ghlight] <groupe> cterm=<aspect> ctermfg=<couleur police> ctermbg=<couleur fond>
[NORMAL] :hi[ghlight] <groupe> start=<>X stop=<>Y
Valeurs avec <groupe> :
Keyword : les mots-clés du langage
Comment : les commentaires
etc.
Note Pour une version plus avancée de l’utilisation, voir l’aide.
Exemples
:highlight Comment cterm=underline ctermfg=red ctermbg=blue => Tous les commentaires seront soulignés, en rouge sur fond bleu (horribles, quoi…)
:hi Keyword ctermfg=4
Définir la hauteur de la fenêtre affichant la liste des commandes [NORMAL] :set cmdwinheight=<nombre de lignes>
[NORMAL] :set cwh=<nombre lignes>		 cmd=Command, win=Window, height=hauteur
[Dés]Activer le folding [NORMAL] :set [no]foldenable
[NORMAL] (off), (on)
[NORMAL] (toggle)
folding Définir manuellement le folding du code courant [NORMAL] fold
folding Définir le folding à l’aide d’un string d’entrée et de sortie [COMMAND] :set foldmethod=marker; :set foldmarker=<entrée>,<sortie>
[COMMAND] :set fdm=marker; :set fdr=<in>,<out>
Note Ensuite, on peut ajouter un level après l’entrée et la sortie. Par exemple :
<1
Mon texte de niveau 1
<2
Le texte de niveau 2.Autre ligne dans le niveau 2
>2
>1
Exemple
:set foldmethod=marker; :set foldmarker=<,>
folding Définir la marque quand le folding est replié [COMMAND] :set foldtext=v:<valeur>
Valeurs avec valeur :
(rien) : +--- <x> lines folded
foldstart : le numéro de la première ligne
foldend : le numéro de la dernière ligne
foldlevel : niveau de folding
folddashes : un caractère défini (mais je ne sais pas comment)
folding Définir la largeur de la colonne de gauche [COMMAND] :set foldcolumn=<nombre de 0 (défaut) à 12>
[COMMAND] :fdc=<0-12>
folding Folder les x lignes suivantes par un nombre ou un rang [COMMAND] <nombre>
[COMMAND] :<first line>, <last line> fold
folding Supprimer le folding sous le curseur. [NORMAL] delete
Note Il suffit de se trouver dans le folding et d’exécuter cette combinaison.
folding Supprimer récursivement tous les folding sous le curseur. [NORMAL]
Toggler (ouvrir/fermer) le folding sous le curseur [NORMAL]
Toggler (ouvrir/fermer) tous les niveaux de folding sous le curseur [NORMAL]
folding Replier (collapse) le code courant [NORMAL]
[NORMAL] :<rang> foldc[lose]		 close
folding Déplier (open) le code courant [NORMAL]
[NORMAL] :<range> foldo[pen]		 open
folding Se déplacer au début du folding courant [NORMAL]
folding Se déplacer à la fin du folding courant [NORMAL] keyCrochetF
folding Se déplacer au folding suivant [NORMAL] keyZ
folding Se déplacer au folding précédente [NORMAL]
folding Exécuter une action sur tous les foldings ouverts [COMMAND] :% folddoopen <command>
Note On peut faire la même chose avec les foldings fermés à l’aide de folddoclosed (mais bon, c’est un peu risqué quand même).
Exemple
:% folddoopen s/Marion/Bébé/g -> Change tous les "Marion" par des "Bébé" dans les foldings ouverts
folding Définir ce qui peut ouvrir les foldings [NORMAL] :set foldo[pen]=<liste valeurs>
[NORMAL] :set fdo=<valeurs>
Note Consulter l’aide pour voir toutes les valeurs possibles.
Définir ce qui crée les foldings [NORMAL] :set foldmethod=<valeur>
[NORMAL] :set fdm=<valeur>
Valeurs avec <valeur> :
diff en fonction de l’opération checkant les différences
expr : folding créés par une l’expression définie par foldexpr (fde)
indent : folding créés par l’indentation
manual : folding créés manuellement
marker : folding créés par des markers
syntax : folding créés par la syntaxe (n’importe quel élément de syntaxe qui possède l’option fold)
Définir la ligne d’état [COMMAND] :set statusline
Note Voir l’aide pour toutes les possibilités : :help 'statusline'.

OPTIONS

Tags Action Shortcut Mnémo
Définir de lire le .vimrc dans le dossier courant [COMMAND] :set exrc
Note 1 L’option est désactivée par défaut, ce qui fait que c’est toujours le .vimrc placé à la racine du $HOME qui est lu.
Note 2 Jouer la commande :set secure avant pour empêcher l’exécution des autocommand, write et shell quand on met cette option pour un dossier inconnue.
Définir la valeur d'une option non booléenne [COMMAND] :set <option>=<valeur>
[COMMAND] :set <option>:<valeur>
Régler plusieurs valeurs d’options à la fois [COMMAND] :set <option>=<valeur> <autre option>=<valeur> <option booléenne> etc.
Régler les options pour un fichier [FILE] /* vim: set <option>=<valeur> : <opt>=<val> : <opt bool> : */
Note Cette ligne doit IMPÉRATIVEMENT être placée sur la PREMIÈRE LIGNE du fichier. C’est ce qu’on appelle la « modeline » (ligne de mode)
Définir le nombre de ligne pour la modeline [COMMAND] :set modelines=<nombre de lignes au début du fichier
Activer/désactiver le mode Modeline [COMMAND] :set [no]modeline
Note En mode « modeline », Vim lit les x premières lignes d’un fichier ouvert pour régler les options
[Dés]activer l’enroulement des lignes à l’affichage [NORMAL] :set [no]wrap
Note Avec nowrap, les lignes ne seront pas enroulées et s'étendront sur une seule ligne d'affichage.
[Dés]activer la correction autographique [NORMAL] :set [no]spell
Activer/désactiver l’option de la relecture automatique (après modification du fichier ailleurs) :set [no]autoread
Afficher l’état d'une option [COMMAND] :set <option>? ? interroger
Activer une option off/on [COMMAND] :set <option>
Désactiver une option :set no<option>
Régler une option sur sa valeur par défaut [COMMAND] :set <option>&
Régler toutes les options sur leur valeur par défaut [COMMAND] :set all&
Inverser la valeur d’une option [COMMAND] :set <option>!
[COMMAND] :set inv<option>
Exemple
:set wrap! => si l’« enroulage » avait été désactivé avec :set nowrap avant, il est remis avec cette commande.
Augmenter la valeur d’une option numérique [COMMAND] :set <option>+=<valeur numérique>
Diminuer la valeur d’une option numérique [COMMAND] :set <option>-=<valeur numérique>
Multiplier la valeur d’une option numérique [COMMAND] :set <option>^=<valeur numérique>
Ajouter une valeur à une option liste [COMMAND] :set <option>+=<valeur string>
Exemple
:set cinwords+=test => cinwords contient ["test"], :set cinwords+=end => cinwords = ["test","end"]
Retirer une valeur à une option liste [COMMAND] :set <option>-=<valeur>
Exemple
si cinwords a la valeur ["test", "end"] alors le code :set cinwords-=test la mettra à ["end"]
Activer[/désactiver] la confirmation au lieu de l’erreur [COMMAND] :set [no]confirm
Note Par exemple, en tant normal, lorsque l’on veut quitter Vim mais que le fichier courant a été modifié sans être enregistré, Vim provoque une erreur. Avec l’option confirm activée, Vim demande s’il faut sauver le fichier avant.
Augmenter le nombre de lignes pour l’affichage d’une commande [COMMAND] :set cmdheight=<nombre lignes>
Afficher[/masquer] le mode en bas à gauche de l’écran [COMMAND] :set [no]showmode
Afficher[/masquer] la commande en version réduite en bas à droite de l’écran [COMMAND] :set [no]showcmd
Activer[/désactiver] l’alerte visuelle (flash de l’écran) [COMMAND] :set [no]visualbell
Activer[/désactiver] l’alerte sonore [COMMAND] :set [no]errorbell
Définir l’ampleur du scroll avec :set scroll=<nombre de lignes>
Définir la hauteur minimum d’une fenêtre au split [COMMAND] :set winheight=<nombre lignes>
Définir la largeur minimum d’une fenêtre au split vertical [COMMAND] :set winwidth=<nombre colonnes>
Définir que le split [ne] doit [pas] faire deux parties égales [COMMAND] :set [no]equalalways

NERDTree

Tags Action Shortcut Mnémo
Ouvrir le NERDTree nerd
Régler le dossier courant en dossier racine [NORMAL] current

MODE LIGNE DE COMMANDE (EX)

Tags Action Shortcut Mnémo
Basculer en mode ligne de commande (ex, grand-père de vim, père de vi) gQ (, )
Basculer en mode normal depuis le mode ligne de commande [COMMAND] :visual
Basculer en mode « shell » (ligne de commande du Terminal) :shell
Note Taper «exit» pour revenir dans Vim.

FENÊTRES (non essentiels)

Tags Action Shortcut Mnémo
Activer la fenêtre inférieure [NORMAL] window, j = descendre
Activer la fenêtre du bas [NORMAL] window, bottom / bas
Activer la fenêtre supérieure [NORMAL] w = window, k = monter
Activer la fenêtre du haut [NORMAL] window, top
Activer la fenêtre précédente [NORMAL] ,
Note Attention, , ne passe pas à la suivante (next) mais crée un nouveau split.
Intervertir deux fenêtres [NORMAL]
Intervertir la fenêtre courante avec la suite (celle en dessous) [NORMAL]
Note S’il n’y a pas de fenêtre en dessous, intervertit avec la précédente.
Égaliser les dimensions des fenêtres = window, = égal
Modifier la taille des fenêtres +/- window
Interchanger la disposition des fenêtres / window, repositionne

CTRLP

Tags Action Shortcut Mnémo
Ouvrir CtrlP en mode de recherche "files" [NORMAL] :CtrlP
[NORMAL]
Ouvrir CtrlP MRU [NORMAL] :CtrlPMRU
MRU signifie Most Recently Used = les fichiers récemment utilisés
Définir chercher par path/chercher par filename (basculer)
Définir le mode de recherche par défaut à REGEXP [.vimrc] let g:ctrlp_regexp = 1
Définir mode de recherche par regexp / mode de recherche normal (bascule) reg expression
Définir le mode suivant (foward) ou précédent (backward) (?) Keyf
Keyb
Définir le dossier courant à la sélection et passer en mode find file puis
Définir le dossier courant @cd path/to/folder/
Exemple
On peut aussi ouvrir vim dans le dossier (à vérifier)
Définir dossier du fichier courant comme dossier courant @cd %:h
Vider le cache F5
Définir les fichiers/dossiers exclus des résultats Utiliser le wildignore de vim
Ou let g:ctrlp_custom_ignore = ''		 set wildignore+=...,...,...
Chercher des résultats dans l’historique et
Marquer/démarquer des fichiers à ouvrir Peut le marquer aussi pour le créer (et ses parents)
Ouvrir plusieurs fichiers marqués par -z Voir les valeurs l'option g:ctrlp_open_multiple_files
Ouvrir le fichier dans une nouvelle tab tab
Ouvrir le fichier dans un split horizontal

split
Déplacer la sélection vers le bas [INSERT] j comme le déplacement dans Vim
Déplacer la sélection vers le haut [INSERT] k comme le déplacement dans Vim
Note Je ne suis pas sûr du tout que ça fasse ça…
Déplacer le curseur au début du prompt a = première lettre alphabet.
Déplacer le curseur vers la gauche h comme le déplacement dans Vim
Déplacer le curseur vers la droite l comme le déplacement dans Vim
Déplacer le curseur à la fin du prompt end
Supprimer le mot précédent (dans le prompt) [NORMAL] word
Supprimer tout le texte de la console
Supprimer la sélection sans la mettre dans un registre quelconque [NORMAL] "_<motion>
Note Ce registre spécial s’appelle le « black hole », le trou noir. Il permet de ne pas mémoriser la suppression dans les registres de 1 à 9.
Exemple
"_ => Supprime la ligne, sans la conserver dans le registre "1
Sélectionner le prochain string dans l’historique next
Sélectionner le précédent string dans l’historique previous
Créer un fichier et tous ses dossiers parents
Quitter CtrlP

SIGNES

Tags Action Shortcut Mnémo
Définir un sign [NORMAL] :sign define <nom> text=<texte> texthl=<groupe>
Note Il y a d'autres paramètres possibles, voir l'aide
Placer un signe [NORMAL] :sign place <ID signe> line=<ligne> name=<nom du signe> file=<fichier>|buffer=<ID>
Exemple
:sign place 2 line=3 name=MonSigne file=courant.txt
Supprimer un signe [NORMAL] :sign unplace <ID sign>[ file=<fichier>|buffer=<id buffer>]
Supprimer tous les signes [NORMAL] :sign unplace *
Se rendre à un signe particulier [NORMAL] :sign jump <ID signe>[ file=<fichier>|buffer=<id buffer>]
Afficher la liste des signes [NORMAL] :sign list[ file=<fichier>|buffer=<id buf>]
Afficher les marques d'un signe en particulier [NORMAL] :sign line <nom du fichier>

CTAGS

Tags Action Shortcut Mnémo
Générer le repérage des tags/méthodes [$>] ctags -R
Aller à la définition d'une méthode ] (sur mac ?)
Aller à la définition d’une méthode par son nom :tag <nom de la méthode>
Revenir à la position de départ

FONCTIONS

Tags Action Shortcut Mnémo
Afficher la liste des fonctions [COMMAND] :function
Afficher le code d’une fonction en particulier [COMMAND] :function <FonctionName>
Résumé complet [COMMAND] 
" Déclaration d'une variable globale hors d'une fonction
var variableGlobale = 12

" Définition de la fonction (doit commencer par une capitale)
:function MaFonction(var1, var2, var3)

  " Référence aux arguments dans la fonction
  if a:var1 > a:var3

  else

  endif

  " Définition d'une variable locale varFonction et
  " Utilisation de la variable globale dans la fonction
  let varFonction = g:variableGlobale

  " Pour retourner une valeur
  :return varFonction
:endfunction " fin de la fonction

" Fonction « à rang » (range)
" Fonction s'interrompant à la première erreur (abort)
" Fonction à nombre d'arguments variables (19 en tout)
:function FonctionARangDeLignes(start,...) range abort

  " Nombre d'arguments
  let nombreArguments = a:0

  " Référence aux trois premiers arguments
  let primo  = a:start
  let deuxio = a:1
  let tercio = a:2


  " a:firstline est une référence au NUMÉRO de la première ligne du rang
  " a:lastline est une référence au NUMÉRO de la dernière ligne du rang
  let premiereLigne = a:firstline
  let derniereLigne = a:lastline

:endfunction
Invoquer une fonction sur chaque ligne du texte courant [COMMAND] :<rang> call <NomFonction>([<arguments>])
Définir une fonction [COMMAND] 
:function <Name>(<vars,...>)
  <code>
:endfunction
Note Le nom doit commencer par une capitale.
Référence à un argument de la fonction [COMMAND] a:<nom de l’argument>
Exemple 
:function Max(nombre1, nombre2)
: if a:nombre1 > a:nombre2
    ...
...
:endfunction
Définir un type de variable [COMMAND] var variable = ... définit une variable globable à l’extérieur d’une fonction, MAIS on doit y faire référence par g:variable à l’intérieur de la fonction.
[COMMAND] let variable = ..., à l’intérieur d’une fonction, définit une variable locale à la fonction
[COMMAND] g:variable = ... définit une variable globale.
Retourner une valeur calculée par la fonction [COMMAND] :return <valeur>

DIVERS

Tags Action Shortcut Mnémo
Afficher la valeur entre < et > d’une touche [INSERT] <touche>
Exemple
F2 => va afficher <F2>
history Afficher l’historique de toutes les actions [COMMAND] :history all
[COMMAND] :his a
history Afficher l’historique des commandes [COMMAND] :his[tory]
history Afficher l’historique d’un certain type d’élément [d’une ligne à une autre] [COMMAND] :his[tory] <type> [<from>, <to>]
Valeurs avec <type> :
a : tous les types
s : type recherche (avec le préfixe /)
c : type commande (avec le préfixe :)
i : type insert (avec le préfixe @, donnée tapées avec un :insert)
Exemples
:history c 1, 10 => affiche l’historique des commandes de la première à la dixième
his s 4, 5 => affiche l’historique des recherches de la 4e à la 5e
his a -5, => affiche les cinq dernières lignes de l’historique complet
history Définir le nombre de lignes de l’historique (:history) à conserver [NORMAL] :set hi[story]=<nombre lignes>
Exemple
:set hi=100 => 100 lignes d’historique seront conservées
Afficher les messages notice et erreurs [COMMAND] :mess[ages]
Rediriger les messages vers un fichier plutôt qu’en console [COMMAND] :redir > <path/to/file.ext>
Note Noter que ça ne fonctionne qu’une fois. Sinon il faut utiliser l’ajout avec >>
Exemple
:redir > ~/mon.log
Rediriger les messages en les ajoutant au fichier [COMMAND] :redir >> <path/to/file.ext>
Exemple
:redir >> ~/mon.log
Stopper la redirection [COMMAND]
Exécuter une commande en mode commande [COMMAND] :norm[al] <commande complète>
Note En « programmation », il est important de « finir » les commandes, par exemple avec <>
Exemples
:norm cwDone => efface le mot sous le cuseur (cw) et tape Done à la place
:normal! cwSA => efface le mot sous le curseur et tape « SA » sans exécuter de mapping (par exemple, ici, « SA » serait remplacé par « Société Anonyme »).
undo Afficher la liste des annulations possibles [NORMAL] :undolist
undo Revenir à une annulation précise [NORMAL] :undo <numéro annulation>
Note On obtient le numéro d'annulation à l'aide de :undolist
Afficher le nom du terminal courant [COMMAND] :set term?
Note C’est donc l’option term qui contient ce nom (mais je crois qu’elle ne se règle pas)
Régler le mode verbeux (verbose) [COMMAND] :set verbose=<valeur>
Note Pour les valeurs, voir l’aide (:help 'verbose')
Régler le mode silencieux [sans message d’erreur] [COMMAND] :set silent[!]
Exemples
:set silent => n’affiche que les messages d’erreur
:set silent! => n’affiche rien, pas même les messages d’erreur (i.e. mode sans erreur)