vi est un éditeur de texte présent d’office sur la majorité des UNIX. Vim (Vi IMproved) est son clone moderne libre GNU/Linux, avec une compatibilité descendante complète. C’est un éditeur très puissant qui a trop de commandes pour pouvoir toutes les énoncer ici. L’objet de ce document est donc de rassembler quelques unes des commandes les plus utiles à l’apprenti geeck voulant s’initier simplement et rapidement à Vim.

Survivre la première fois

Entrer dans Vim, à l’invite de commande, tapez
```
vim <file>
```
Écrire (insérer) du texte, tapez
```
i
```
Arrêter la saisie et repasser en mode normal, tapez
```
<Esc>
```
Enregistrer les modifications
```
:w
```
Quitter Vim
```
:q
```
ou sans tenir compte des dernières modifications
```
:q!
```

B.A. BA

Vim dispose de trois modes :

le mode normal ou commande (par défaut) ;
le mode insertion, signalé par -- INSERT -- en bas de la fenêtre ;
le mode visuel, signalé par -- VISUAL {,LINE,BLOCK}--.

Le passage d’un mode à l’autre est résumé par :

    +---------+  i,I,a,A,o,O,r,R,s,S  +----------+
    | Normal  +---------->------------+  Insert  |
    | mode    |                       |  mode    |
    |         +----------<------------+          |         
    +-+---+---+        <Esc>          +----------+
      |   |
      |   |
      |   |
      |   |
  v,V V   ^ <Esc>
      |   |
      |   |
      |   |
      |   |
    +-+---+----+
    |  Visual  |
    | mode     |
    +----------+

Mode normal

Commencer l’insertion de texte

i       " au niveau du curseur
I       " au début de la ligne
a       " après le curseur
A       " à la fin de la ligne
o       " sur une nouvelle ligne sous la courante
O       " sur une nouvelle ligne au-dessus de la courante

Enregistrer, quitter

:w      " enregister le fichier
:q      " fermer le fichier (la fenêtre si plusieurs)
:q!     " fermer le fichier et abandonner les changements
ZQ
:qa     " fermer tous les fichiers/fenêtres/onglets/buffers
:x      " enregistrer et fermer le fichier
:wq
ZZ
:xa     " enregistrer et fermer tous les fichiers

Enregistrer les modifications
```
:up(date)
```
c’est-à-dire modifier le timestamp du fichier que s’il a effectivement été modifié, contrairement à :w(rite). Il peut être commode de définir dans votre .vimrc le raccourci :
```
map :w :up
```

Écrire dans un fichier file

:wq! {file}         " tout le fichier, puis quitter
:{range}w {file}    " la sélection
:{range}w >> file   " ajouter la sélection au fichier

Attention,

:{range}w

sauvegarde l’intrevalle dans le fichier courant.

Enregistrer en tant qu’administrateur
```
:w !sudo tee "%" 
```

Éditer un fichier

:e          " le fichier courant (recharger)
:e!         " le fichier courant, sans tenir compte des modifs
:e {file}   " le fichier file

Insérer

:r file     " insère le fichier file sous le curseur
:r! cmd     " insère le résultat le commande cmd sous le curseur

Ouvrir un fichier
```
:o file " ouvrir file
```
Enregistrer dans un fichier
```
:saveas file 
```

Mode insertion

Écrire du texte…
Quitter, repasser en mode normal
```
<Esc>
```

Complétion

<C-n>       " complète le mot avant le curseur
<C-p>       " complète le mot après le curseur
<C-x><C-l>  " complète la ligne

Complétion à partir d’un dictionnaire

<C-x><C-k>

:set dictionary=/usr/share/dict/french

Indentation

<C-t>       " indente la ligne
<C-d>       " dédente la ligne

Suppressions

<C-w>       " supprime le mot avant le curseur
<C-u>       " supprime le texte de la ligne courante

Insérer une espace insécable

<C-k> <space> <space>
<C-k> <Shift+N> <Shift+S>

Insérer le point médian d’écriture inclusive
```
<C-k> . M
```
Digraphes
```
<C-k> c1 c2
```
tapper :digraphs pour voir la liste complète.

Mode visuel

Le mode visuel permet de sélectionner des objets.

objets textes :

 l       " lettre
 w       " mot
 s       " phrase
 p       " paragraphe

mode de sélection :
```
i       " inside
a       " around
```

Passer en mode visuel

v       " sélection par caractère, indiquée par `-- VISUAL --`
V       " sélection par ligne, indiquée par `-- VISUAL LINE --`
<C-v>   " sélection par colonnes, indiquée par `-- VISUAL BLOCK --`

Sélectionner

aw      " un mot
as      " une phrase
ap      " un paragraphe

ab      " un bloc ()
aB      " un bloc {}

a{      " le texte dans un bloc {}, avec les acolades
i{      " le texte dans un bloc {}, sans les acolades
        " adaptable avec (), [], "", ''...

Échanger la position du curseur avec le début de sélection

o       " selection par caractère
O       " sélection par bloc

Indenter
```
>       " indenter
<       " dédenter
```
Insérer du texte sur plusieurs lignes, après sélection d’un visual block, taper
```
I
```
saisir le texte puis
```
<Esc><Esc>
```

Mode commande, opérateurs, actions

Déplacements

Se repositionner

'.      " sur la dernière ligne éditée
g;      " à l'exacte position de la dernière édition

Se déplacer (en plus des flèches)

  k              
h   l          
  j

Se déplacer dans le fichier

gg      " aller au début du fichier
G       " aller à la fin du fichier
nG      " aller à la ligne n
:n      " idem
n%      " aller à n % du fichier

Se déplacer sur l’écran

H       " positionner le curseur en haut de l'écran
M       " positionner le curseur au milieu de l'écran
L       " positionner le curseur en bas de l'écran

nH      " positionner le curseur à n lignes du haut de l'écran
nL      " positionner le curseur à n lignes du bas de l'écran

<C-f>   " faire défiler un écran en avant
<C-b>   " revenir d'un écran en arrière
<C-d>   " faire défiler 1/2 écran
<C-u>   " faire défiler 1/2 écran en arrière

<C-e>   " faire défiler l'écran d'une ligne (sans toucher le curseur)
<C-y>   " idem mais en arrière

Recentrer l’écran, en mettant la ligne courante

zt      " en haut de l'écran
zz      " au milieu de l'écran
zb      " en bas de l'écran

Se déplacer par sauts de

{       " paragraphe précédent
}       " paragraphe suivant
(       " phrase précédente
)       " phrase suivante
%       " autre parenthèse, acolade, crochet...
        " voir `:h matchpairs`

Se déplacer dans un bloc

[{      " aller au début du bloc { }
]}      " aller à la fin du bloc { }
        " fonctionne aussi avec les parenthèses

Se déplacer de ligne en ligne

+       " premier caractère non blanc ligne suivante
-       " premier caractère non blanc ligne précédente
n_      " premier caractère non blanc, (n-1) lignes suivantes

Se déplacer sur une ligne

0       " début de ligne
^       " première lettre de la ligne
$       " dernière lettre de la ligne
g_      " dernier caractère non blanc de la ligne
gm      " milieu de ligne
n|      " colonne n

Se déplacer de mot en mot

w       " aller au début du prochain mot
W       " aller au début du prochain mot séparé par une espace
b       " aller au début du mot précédent (B avec espace)
e       " aller à la fin du prochain mot (E avec espace)
ge      " aller à la fin du mot précédent (gE avec espace)

Aller directement à la lettre voulue

f{char} " aller au prochain caractère, e.g. `fH` va sur le `H`
F{char} " aller au précédent caractère
t{char} " aller juste avant le prochain caractère
T{char} " aller juste après le précédent caractère
;       " occurence suivante
,       " occurence précédente (sens opposé)

Marques

m{char}     " poser une marque dans le fichier [a-z, A-Z]
'{char}     " aller au début de la ligne de la marque
`{char}     " aller exactement à la marque

:marks      " afficher la liste des marques
:delm {char}" supprimer la marque
:delm!      " supprimer toutes les marques

`[          " aller au début du texte précédant manipulé
`]          " aller à la fin du texte précédant manipulé

Sauts

:jumps  " afficher la liste des sauts
n^O     " aller au n-ième saut précédent
n^I     " aller au n-ième saut

Actions

Le format d’une commande en mode normal est :

[number] [selection] operator motion

où :

number

entier associé au nombre de fois qu’il faut répéter la commande

selection

sélection sur laquelle agir

a,b     " lignes a à b
'<,'>   " lignes sélectionnées

operator

tout opérateur Vim valide

d       " supprimer (delete)
y       " copier (yank)
p       " coller (put)
r       " remplacer (replace)
c       " changer (change)

motion

tout mouvement ou sélection d’objets textes sur lequel doit agir la commande.

On appelle action la combinaison d’un opérateur et d’un mouvement.

Quelques exemples d’actions :

d$      " efface jusqu'à la fin de la ligne
yb      " copie jusqu'au début du mot précedent
dd      " efface la ligne
yy      " copie la ligne
dt,     " efface jusqu'à la prochaine virgule
yG      " copie jusqu'à la fin du fichier

en précisant le nombre de fois :

5dj     " efface les 5 prochaines lignes
42yw    " copie les 42 prochains mots

Annuler, répéter

.       " répète la dernière commande
u       " annule la dernière commande
U       " restaure la ligne
<C-R>   " annule l'annulation

Quelques actions sont utilisées suffisamment fréquemment pour avoir un raccourci :

x     d1   " supprimer le caractère sous le curseur
X     dh   " supprimer le caractère précédent celui sous le curseur
D     d$   " supprimer la fin de la ligne
C     c$   " changer la fin de la ligne
s     c1   " changer un caractère
S     cc   " changer la ligne entière

Registres

Vim dispose d’un mécanisme de registres que l’on peut ségréger en trois catégories :

les registres affectés, dont les noms sont une lettre entre a et z ;
les registres sans nom contenant le texte des dernières copies ou suppressions :

actions registres

y[motion] " et 0

d[motion] " et 1

Les derniers changements ou suppressions sont stockés dans la pile de registres 1 à 9 (1 le dernier contenu).

actions	registres
`y[motion]`	`"` et `0`
`d[motion]`	`"` et `1`

les registres « système »

 %       " le nom du fichier édité (incluant le chemin)
 #       " le nom alternatif du fichier édité
 /       " la dernière recherche
 :       " la dernière commande
 .       " le dernier texte inséré
 -       " le dernier contenu supprimé (de moins d'une ligne)

Voir les registres
```
:reg
```
ou seulement le contenu du registre a
```
:reg a
:<C-r>a
```
Définir le contenu du registre a
```
let @a = 'content'
```
Affecter une sélection au registre a
```
v<selection>"ay
```
Ajouter la sélection au registre a
```
v<selection>"Ay
```
avec une majuscule !

Coller le contenu du registre a

<C-r>"ap    " après le curseur
<C-r>"aP    " avant le curseur

Utiliser le contenu du registre a pour la prochaine action
```
"a
```
ou dans une commande
```
<C-r>a
```

Édition

Copier (yank)

y[motion]
yy      " la ligne courante (ou Y)
yi{     " le texte dans un bloc {}
        " adaptable avec (), [], "", ''...

Coller (’put)

p       " colle avant le curseur
P       " colle après le curseur
gp      " comme p avec curseur à la fin
gP      " comme P avec curseur à la fin
]p      " comme p avec ajustement de l'identation
[p      " comme P avec ajustement de l'identation

Couper, supprimer (delete)

d[motion]
dd      " la ligne courante
D       " la fin de la ligne
d$      " idem
di{     " le texte dans un bloc {}
        " adaptable avec (), [], "", ''...
x       " le carctère sous le curseur
X       " le caractère précédent le curseur

Le contenu n’est pas réelement supprimé mais stocké dans la pile de registres "n, n=1..9.

Remplacer

r{char} " la lettre sous le curseur par {char}

Remplacer (passage en mode insertion)

R       " le texte à partir du curseur
C       " la fin de ligne à partir du curseur (après suppression)
c$      " idem
cc      " remplacer la ligne courante
S       " idem

ciw     " le mot sous le curseur
cw      " la fin du mot à partir du curseur

ci{     " changer le texte dans un bloc {}
        " adaptable avec (), [], "", ''...

s       " supprimer le caractère et substituer le texte

Rechercher, remplacer

Rechercher

Rechercher le motif pattern

/pattern    " en avant
?pattern    " en arrière
n ou /      " occurence suivante (sens de la recherche)
N ou ?      " occurence précédente
:g/ppattern/#
            " afficher les lignes (pop up)

Rechercher les autres occurrences du mot sous le curseur

*       " en avant
#       " en arrière
[I      " afficher les lignes (pop up)
g*      " idem * avec correspondance partielle
g#      " idem # avec correspondance partielle

Rechercher

/fred|joe/      " fred OU joe
/.*fred&.*joe/  " fred ET joe
/<fred>/        " exactement fred (donc pas alfred ou frederick)

Options de recherche

:set ignorecase " insensible à la casse
:set smartcase  " utilise la casse « intelligemment »
:set incsearch  " afficher les occurences à mesure
:set hlsearch   " afficher les résultats en sur-brillance

Expressions rationnelles

Une expression rationnelle est une manière compacte de représenter une chaîne de caractères (voir vimregex).

Expression	Signification
`.`	Tout caractère (sauf `newline`)
`\`	Caractère d’échappement (interprétation littérale du caractère suivant)
`^`	Début de ligne
`$`	Fin de ligne
`\<`	Début de mot
`\>`	Fin de mot
`\n`	Fin de ligne
`\r`	Retour chariot
`\t`	Tabulation
	Classes de caractères
`\c`,`\C`	Ignore la casse, ou pas
`\s`, `\S`	Espace, ou pas
`\d`, `\D`	Nombre, ou pas
`\w`, `\W`	Mot, ou pas
`\a`, `\A`	Une lettre ou un chiffre, ou pas
`\x`, `\O`	Nombre hexadécimal, octal
`\l`, `\L`	une lettre en minuscule, ou pas
`\u`, `\U`	une lettre en majuscule, ou pas
	Ensembles
`[abc]`	Un des caractères spécifiés
`[a-dh]`	Une lettre de a à d ou h
`[0-57]`	0, 1, 2, 3, 4, 5 ou 7
`[a-d5-8-]`	a, b, c, d, 5, 6, 7, 8 ou -
`[012^]`	0, 1, 2 ou ^
`[^abc]`	Un caractère ne figurant pas dans la liste
`[^0-9]`	Tout sauf un chiffre
`[^a-zA-Z]`	Tout sauf une lettre
	Quantificateurs
`r*`	Aucune ou plusieurs instances de l’expression `r`
`r\+`	Au moins une instance de l’expression `r`
`r\?`	Aucune ou une instance de l’expression `r`
`\{n}`	Exactement n fois l’élément précédent
`\{n,m}`	Entre n et m fois l’élément précédent
`\{n,}`	n fois ou plus l’élément précédent
`\{,m}`	m fois au plus l’élément précédent
`r1\\|r2`	Instance de l’expression `r1` ou `r2`
`$...$`	Groupe
	Références
`\&`, `\0`	tout le motif
`\n`	le n-ième groupe (n>=1)
`\r`	couper la ligne en 2 à ce point
`\u`	le caractère suivant en majuscule
`\l`	le caractère suivant en minuscule

Remplacer

Remplacer l’expression exp1 par exp2

:(range)s/exp1/exp2/    " la première occurence de chaque ligne
:(range)s/exp1/exp2/g   " toutes les occurences

:(range)s/exp1/exp2/c   " confirmer chaque changement
:(range)s/exp1/exp2/i   " ignorer la casse

Remplacer l’expression exp1 par exp2 entre les lignes a et b
```
:a,bs/exp1/exp2/g 
```
Remplacer l’expression exp1 par exp2 dans tout le fichier
```
:%s/exp1/exp2/g
```
Remplacer l’expression exp1 par exp2 dans la sélection visuelle
```
:%s/\%Vexp1/exp2/g
```

Supprimer

:(range)g/exp/d         " supprimer toutes les occurences de `exp`
:(range)v/exp/d         " supprimer toutes les lignes sans `exp`
:(range)g!/exp/d        " idem

Supprimer toutes les lignes vides
```
:%g/^\s*$/d
```
Fusionnner les lignes vides
```
:%s/\s\+$//e
:%s/\n\{3,}/\r\r/e
```
où le drapeau e demande de ne pas afficher d’erreur si le motif n’est pas trouvé.
Notez que l’on peut aussi joindre les lignes consécutives entre deux lignes non vides :
```
:v/\S/,/\S/-j
```

Commandes externes

Exécuter une commande externe
```
:! <commande>
```
Lire le contenu d’un fichier
```
:r {file}
```
et l’inclure dans le fichier courant à partir de la position du curseur.
Insérer le résultat d’une commande externe
```
:r! <command>
```
Insérer les lignes a à b d’un fichier
```
:put = readfile('/path/to/file')[a:b]
```
Changer de répertoire
```
:cd <path>
```
Aller dans le répertoire du fichier édité
```
:cd %:h
```
Compiler le fichier courant si c’est un fichier *.tex
```
:!pdflatex %
```
Ouvrir la man page du mot sous le curseur
```
K
```

Outils d’édition

Coller le contenu du presse-papier
```
i <c-shift-v> <esc>
```
ou tel quel (sans indentation automatique)
```
:set paste
i <c-shift-v> <esc>
:set nopaste
```

Macros

Enregistrer une macro dans le registre a
```
qa
```
puis arrêter l’enregistrement
```
q
```
Exécuter la macro a
```
@a
```
Exécuter de nouveau la dernière macro exécutée
```
@@
```

Lignes

Joindre les lignes courante et suivante

J       " avec une espace
gJ      " sans espace

Aligner les lignes

:<selection>le n    " à la colonne n
:<selection>ce n    " centrées sur n colonnes
:<selection>ri n    " à droite sur n colonnes

Compresser plusieurs lignes vides en une seule
```
:%s/^\n\+/\r/
```
Supprimer les espaces en fin de ligne
```
:%s/\s\+$//g
```
Reformater le texte sélectionné
```
gwip
```
qui produit un résultat similaire à
```
:!fmt
```
Remonter la ligne courante au dessus de la précédente
```
:m -2
```

Indentation

==      " indenter automatiquement la ligne courante
gg=G    " ré-indenter tout le fichier (avec `set indent on`)
ggVG=   " formattage automatique du fichier

Remplacer les tabulations par la valeur fixée en tw
```
:retab
```

Caractères, casses

Changer la casse de caractères

~       " change la casse du caractère sous le curseur
guu     " convertit la ligne en minuscules
gUU     " convertit la ligne en majuscules

gUi{    " convertit en majuscules le bloc dans {}

Mettre en majuscule la première lettre de chaque phrase
```
:%s/[.!?]\_s\+\a/\U&\E/g
```
Inverser le caractère sous le curseur et le suivant
```
xp
```
Afficher les codes ASCII, hex et octal du caractère sous le curseur
```
ga
```

Nombres

{In,Dé}crémenter le premier nombre sous ou après le curseur
```
<C-a>   " incremente
<C-x>   " décremente
```

Trier

Trier la sélection selon le premier entier de chaque ligne
```
:'<,'>sort n
```
ou selon le premier nombre réel
```
:'<,'>sort f
```

Motifs

Ajouter une paire à reconnaître (ici < >)
```
:set matchpairs+=<:>
```

Orthographe, grammaire

Correcteur

:setlocal spell spelllang=fr

puis

]s      " move to the next mispelled word
[s      " move to the previous mispelled word
zg      " add a word to the dictionary
zug     " undo the addition of a word to the dictionary
z=      " view spelling suggestions for a mispelled word

Formats de fichiers

Format de fichier

:e ++ff=unix    " fileformat {unix|mac|dos}

Changer les fins de lignes CRLF (win) pour LF (unix) (vu ici)

:update             " enregistrer les changements
:e ++ff=dos         " éditer avec le format DOS ('fileformats' est ignoré)
:setlocal ff=unix   " utiliser les fins de ligne LF avec ce buffer
:w                  " enregistrer

à mettre en raccourci dans votre .vimrc :

nmap :LF :update<CR>:e ++ff=dos<CR>:setlocal ff=unix<CR>:w<CR>

Caractère unicode, ou pas (à voir)
```
/\%uXXXX
```
ou en mode insertion
```
<C-v>UXXXX<esc>
```

Émojis

Insérer un smiley de caractère Unicode U+1F60A (en mode insertion) :
```
<C-v>U1F60A<esc>
```
Voir la liste des émojis sur unicode.org ou dans mon mémo émojis.

Statistiques

Compter le nombre d’occurrences d’un mot dans le fichier
```
:%s/<word>//gn
```

Productivité

Afficher les numéros de lignes
```
:set nu
:set number
```
ou les enlever
```
:set nonu
```

Historique

Afficher l’historique des commandes
```
q:
```
Afficher l’historique des recherches
```
q/
```
Afficher les fichiers récemment édités
```
:browse oldfiles
```

Multi-fenêtres

Ouvrir 2 fichiers cote-à-cote
```
vim -O file1 file2
```
ou dessus-dessous
```
vim -o file1 file2
```

Découper l’écran en 2 fenêtres

<C-w> v     " verticalement
:split
<C-w> s     " horizontalement
:vsplit

Passer d’une fenêtre à l’autre

<C-w> w         " sens horaire
<C-w> <right>   " à droite
<C-w> <C-l>
<C-w> <left>    " à gauche
<C-w> <C-h>
...

Ouvrir une nouvelle fenêtre au-dessus
```
<C-w> n
```

Changer le mode de découpage de la fenêtre

<C-w> K     " de vertical à horizontal
<C-w> H     " de horizontal à vertical

Modifier l’affichage de la fenêtre

<C-w> =     " égaliser les tailles
<C-w> |     " maximiser la courante en découpage vertical
<C-w> _     " maximiser la courante en découpage horizontal
<C-w> +     " augmenter la hauteur
<C-w> -     " diminuer la hauteur
<C-w> >     " augmenter la largeur
<C-w> <     " diminuer la largeur

Fixer la taille d’une fenêtre

:resize 40              " à 40 lignes
:vectical resize 80     " à 80 caractères

:resize +5              " +5 lignes
:vertical res -5        " -5 caractères

Permuter les fenêtres

<C-w> r     " rotation
<C-w> x     " permutation avec la suivante

Fermer une fenêtre
```
<C-w> q
```

Onglets

Ouvrir un nouvel onglet
```
:tabedit
```

Naviguer entre les onglets

gt          " onglet suivant
gT          " onglet précédent
{i}gt       " onglet i

Lister les onglets
```
:tabs
```

Explorateur de fichiers

Ouvrir un explorateur de fichiers

:e .        " dans le répertoire courant
:e <C-d>    " pour afficher le contenu du répertoire

Ouvrir une nouvelle fenêtre pour explorer les fichiers du dossier
```
:Vex    " découpage vertical
:Sex    " découpage horizontal
```
Changer le répertoire pour celui du fichier édité
```
:lcd %:p:h
```
Éditer le fichier sous le curseur
```
gf
```
ou dans un nouvel onglet (buffer)
```
<C-w> gf
```

Pliages

Activer les pliages par reconnaissance syntaxique

:set foldmethod=syntax

puis naviguer plus rapidement

zo      " ouvrir un pli
zc      " fermer un pli
zr      " ouvrir un niveau de plis supplémentaire
zm      " fermer un niveau de plis supplémentaire
zR      " ouvrir tous les niveaux de plis
zM      " fermer tous les niveaux de plis

Se déplacer dans le pli courant

[z      " aller au début du pli
]z      " aller à la fin du pli

Se déplacer de pli en pli

zj      " début du pli suivant
zk      " fin du pli précédent

Buffers

Créer un nouveau buffer
```
:enew
:ene
```
Afficher la liste des buffers
```
:ls
```
Ouvrir le buffer n
```
:b n
```
Supprimer un buffer
```
:bd
```
Supprimer tous les buffers
```
:%bd
```

Naviguer entre les buffers

:bn     " buffer suivant (next)
:bp     " buffer précédent (previous)
:bf     " premier buffer (first)
:bl     " dernier buffer (last)

Onglets

Ouvrir un nouvel onglet
```
:tabnew
```
Ouvrir un fichier file dans un nouvel onglet
```
:tabnew file
```

Naviguer entre les onglets

gt      " onglet suivant
:tabn
gT      " onglet précédent
:tabp
#gt     " aller à l'onglet numéro #

Déplacer l’onglet en position n (relative donc 0 pour le premier)
```
:tabmove n
```
Fermer un onglet
```
:tabc
:tabclose
```
Fermer tous les onglets sauf celui en cours d’édition
```
:tabo
:tabonly
```
Exécuter une même commande command sur tous les onglets
```
:tabdo command
```

Comparaison de fichiers

Comparer le fichier courant avec le fichier otherfile
```
:vert diffsplit otherfile
```
si vous ne spécifiez pas vert, le split sera horizontal (beaucoup moins pratique). Ajoutez à votre .vimrc :
```
set diffopt=vertical
```

Configuration

Modelines
```
vim: set tw=72 ts=4 sw=4 nu:
```
Recharger son fichier de configuration
```
:so $MYVIMRC
```
ou
```
:source ~/.vimrc
```

Aide

Voir l’aide associée au mot-clé keyword
```
:h keyword
:help keyword
```

Survivre la première fois

B.A. BA

Mode normal

Mode insertion

Mode visuel

Mode commande, opérateurs, actions

Déplacements

Actions

Registres

Édition

Rechercher, remplacer

Rechercher

Expressions rationnelles

Remplacer

Commandes externes

Outils d’édition

Macros

Lignes

Indentation

Caractères, casses

Nombres

Trier

Motifs

Orthographe, grammaire

Formats de fichiers

Émojis

Statistiques

Productivité

Historique

Multi-fenêtres

Onglets

Explorateur de fichiers

Pliages

Buffers

Onglets

Comparaison de fichiers

Configuration

Aide

Références