Premiers pas
Modes et mouvement de base
Vim est modal — les différents modes ont des usages différents. Esc revient au mode Normal depuis tout autre mode. Les touches hjkl gardent les mains sur la rangée de repos. w/b se déplacent par mot, 0/$ aux frontières de ligne, gg/G au début/fin de fichier, :N saute à la ligne N.
# Vim Modes
# Normal mode (Esc) - default, for navigation
# Insert mode (i) - for typing text
# Visual mode (v) - for selecting text
# Command mode (:) - for Ex commands
# Basic movement (Normal mode)
h # left
j # down
k # up
l # right
w # next word start
b # previous word start
0 # beginning of line
$ # end of line
gg # first line
G # last line
:42 # go to line 42Quitter et sauvegarder
ZZ et ZQ sont les moyens les plus rapides de quitter — pas besoin d'aller chercher les deux-points. :x n'écrit que si le fichier a changé (préserve le mtime), contrairement à :wq qui écrit toujours. :w! outrepasse les flags lecture seule si les permissions filesystem le permettent. Utilisez :qa! pour sortir de plusieurs buffers modifiés.
:w # write (save) file
:w! # force write (override read-only)
:q # quit
:q! # force quit (discard changes)
:wq # write and quit
:x # write only if changed, then quit
ZZ # same as :x (write if changed, quit)
ZQ # quit without saving (like :q!)
:w newfile.txt # save as new file
:sav newfile.txt # save as new file and switch to it
:wa # write all buffers
:xa # write all changed buffers and exit
:qa! # force quit all (discard everything)Système d'aide
L'aide de Vim est complète et hyperliée. Ctrl-] suit un tag (lien) et Ctrl-T revient en arrière. Notation d'aide : i_CTRL-N signifie Ctrl-N en mode insertion, 'number' (avec guillemets) une option. :helpgrep cherche dans tous les fichiers d'aide d'un coup — utilisez :cn/:cp pour naviguer les correspondances. K invoque man pour le mot-clé sous le curseur (configurable via 'keywordprg').
:help # main help
:help subject # help on subject (e.g. :help insert)
:help i_CTRL-N # help on Ctrl-N in insert mode
:help 'number' # help on the 'number' option (quotes)
:helpgrep pattern # search all help files for pattern
:cn / :cp # next/prev helpgrep match
K # man page for word under cursor (Normal mode)
Ctrl-] # jump to tag under cursor (follow link)
Ctrl-T # jump back from tag (pop tag stack)
:helptags ~/.vim/doc # regenerate help tags for a doc directoryMouvement par mots et caractères
Les mouvements minuscules (w/b/e) traitent la ponctuation comme séparateur de mots — utile pour le code. Les majuscules (W/B/E) ne traitent que les espaces comme séparateurs — utile pour la prose. e/E vont à la fin du mot suivant ; ge/gE à la fin du mot précédent (rarement utilisés mais pratiques).
# Word motions (punctuation-aware)
w # next word start
b # previous word start
e # end of next word
ge # end of previous word
# WORD motions (whitespace-only delimiters, uppercase)
W # next WORD start
B # previous WORD start
E # end of next WORD
gE # end of previous WORD
# Word boundaries:
# word: sequence of word-characters OR sequence of punctuation
# WORD: anything separated by whitespace
# Examples (cursor on 'a' in "foo.bar baz"):
# w -> 'bar' (punctuation splits words)
# W -> 'baz' (only whitespace splits WORDS)Mouvement par lignes
0 et $ vont au début/fin absolu de ligne (espaces inclus). ^ et g_ sautent les espaces de début/fin — généralement ce qu'on veut. Quand 'wrap' est actif, g0/g$ opèrent sur les lignes d'écran tandis que 0/$ opèrent sur les lignes logiques. | saute à un numéro de colonne précis.
0 # first column (absolute start)
^ # first non-blank character
$ # end of line (last character)
g_ # last non-blank character
g0 # start of screen line (with wrap)
g$ # end of screen line (with wrap)
gm # middle of screen line
gM # middle of text line
| # column N (e.g. 10| = column 10)
+ # first non-blank of next line
- # first non-blank of previous line
_ # first non-blank of current line [count down]Mouvement dans le fichier et l'écran
H/M/L sautent dans l'écran visible. Ctrl-d/u défilent d'une demi-page (moins désorientant que la pleine page Ctrl-f/b). zz/zt/zb défilent la ligne courante au milieu/haut/bas de l'écran sans déplacer le curseur — extrêmement utile pour garder le contexte pendant l'édition. N % saute à un pourcentage du fichier.
gg # go to first line
G # go to last line
Ngg / NG # go to line N (e.g. 50gg or 50G)
:N # go to line N (Ex command)
H # top of screen (High)
M # middle of screen
L # bottom of screen (Low)
N% # jump to N% of the file
Ctrl-f # scroll forward (full page)
Ctrl-b # scroll backward (full page)
Ctrl-d # scroll down (half page)
Ctrl-u # scroll up (half page)
zz # scroll current line to middle
zt # scroll current line to top
zb # scroll current line to bottomInsertion de texte
Insertion de base (i, I)
i/I insèrent avant le curseur / en début de ligne. a/A insèrent après le curseur / en fin de ligne. gi revient à la dernière position d'insertion (marque '^) — pratique quand on Esc pour faire quelque chose puis veut continuer à taper. gI va à la colonne absolue 1, en ignorant les espaces initiaux.
i # insert before cursor
I # insert at first non-blank (same as ^i)
gi # insert at last insert position (also sets mark)
gI # insert at column 1 (same as 0i)
a # insert after cursor
A # insert at end of line (same as $a)
# Examples:
# foo|bar + i -> foo|bar (cursor stays, type before)
# foo|bar + I -> |foobar (cursor at first non-blank)
# foo|bar + A -> foobar| (cursor at end)
# gi returns to where you last left insert mode —
# very useful after escaping to run a Normal-mode command.Ouvrir de nouvelles lignes (o, O)
o et O ouvrent une nouvelle ligne sous/au-dessus du curseur et entrent en mode insertion. C'est le moyen le plus rapide d'ajouter une ligne — pas besoin de positionner le curseur en fin de ligne. L'indentation se copie automatiquement des lignes voisines (contrôlé par 'autoindent').
o # open new line BELOW cursor, enter insert
O # open new line ABOVE cursor, enter insert
# Before (cursor on middle line):
# line one
# li|ne two
# line three
# After 'o':
# line one
# line two
# | <- new blank line, insert mode
# line three
# After 'O':
# line one
# | <- new blank line, insert mode
# line two
# line threeCommandes de changement (c, C, s, S)
c{motion} supprime la cible du mouvement et entre en mode insertion — la commande d'édition la plus flexible. C est c$ (changer jusqu'à la fin de ligne), S est cc (changer toute la ligne). s supprime un caractère et entre en insertion ; combinez avec des comptes comme 3s. ciw/caw utilisent des text objects (voir section dédiée).
cw / ce # change to end of word
cb # change backward to word start
c$ / C # change to end of line
cc / S # change entire line
c0 # change to beginning of line
c^ # change to first non-blank
ct, # change up to (but not including) next ','
cfx # change up to and including next 'x'
ciw # change inner word (no surrounding whitespace)
caw # change a word (with surrounding whitespace)
cap # change around paragraph
s # substitute: delete char under cursor, insert
S # substitute: delete entire line, insert (like cc)Mode remplacement (r, R, gr)
r remplace un seul caractère et retourne immédiatement au mode Normal (pas de changement de mode). R entre en mode Remplacement où la saisie écrase les caractères — Backspace les restaure, contrairement au mode Insertion qui supprime simplement. Utilisez gr/gR (remplacement virtuel) avec des tabulations — il préserve l'alignement des tabulations au lieu de décaler le texte.
r{x} # replace single char under cursor with x
gr{x} # virtual replace (doesn't shift tabs)
R # enter Replace mode (overwrite until Esc)
gR # virtual Replace mode (tabs stay aligned)
3r{x} # replace 3 chars with x (single char only)
# In Replace mode, typing overwrites existing text
# but Backspace restores the original characters.
# Tabs are preserved with virtual replace (gr/gR).
# Examples:
# abc|def + rx -> abc|xef (cursor advances)
# abc|def + R -> enter Replace mode
# type 'XYZ' -> abcXYZ|f
# Backspace -> abcXY|def (original restored)Insertions spéciales
:r !cmd insère la sortie d'une commande shell dans le buffer — génial pour coller une sortie de commande, des dates, des listes de fichiers. En mode insertion, Ctrl-r suivi d'un nom de registre insère ce registre ; Ctrl-r = évalue une expression Vimscript et insère le résultat. Ctrl-k insère un digraphe (caractère spécial) en tapant deux caractères ASCII.
:r file.txt # insert contents of file below cursor
:r !command # insert output of shell command
:0r !date # insert date at top of file
:r !ls -la # insert directory listing
# Insert with special registers
Ctrl-r = # expression register: evaluate, insert result
Ctrl-r " # insert unnamed register
Ctrl-r % # insert current filename
# Insert from current file path
:i! !pwd # insert pwd output (no autoindent)
# Non-ASCII / digraphs (in insert mode)
Ctrl-k {ch1}{ch2} # digraph: e.g. Ctrl-k e' produces é
:digraphs # list available digraphsRaccourcis du mode insertion
Ctrl-h/w/u agissent comme Backspace/Supprimer-mot/Supprimer-ligne dans le mode insertion. Ctrl-t/Ctrl-d ajustent l'indentation sans quitter l'insertion — inestimable pour le code. Ctrl-n/Ctrl-p complètent les mots-clés depuis buffers et tags. Ctrl-o exécute une seule commande Normal puis retourne à l'insertion (ex. Ctrl-o zz pour recentrer). Ctrl-g u casse la chaîne d'undo pour qu'une longue insertion s'annule par morceaux.
# In insert mode:
Ctrl-h # delete char before cursor (Backspace)
Ctrl-w # delete word before cursor
Ctrl-u # delete to start of line
Ctrl-t # indent current line (one shiftwidth)
Ctrl-d # dedent current line (one shiftwidth)
Ctrl-n # keyword completion (forward)
Ctrl-p # keyword completion (backward)
Ctrl-o # execute one Normal command, return to insert
Ctrl-r {reg} # insert register contents
Ctrl-a # insert text typed in last insert mode
Ctrl-@ # insert last text + Esc (like Ctrl-a then Esc)
Ctrl-g u # break undo sequence (start new undo block)
Ctrl-] # trigger abbreviation without insertingCommandes d'édition (supprimer/copier/coller)
Commandes de suppression
d{motion} est l'opérateur de suppression universel — combinez-le à tout mouvement. dd supprime toute la ligne. x est un raccourci de dl (supprimer un caractère). Le texte supprimé va dans le registre sans nom (et le registre 1). Utilisez d avec des text objects (ciw, dib) pour des éditions puissantes. J joint la ligne suivante à la courante avec une espace.
x # delete char under cursor (also 'dl')
X # delete char before cursor (also 'dh')
dd # delete current line
dw # delete to next word start
de # delete to end of word
d$ / D # delete to end of line
d0 # delete to beginning of line
d^ # delete to first non-blank
dgg # delete from cursor to first line
dG # delete from cursor to last line
J # join next line (removes leading whitespace, inserts space)
gJ # join next line without inserting space
3dd # delete 3 lines
dW # delete WORD (whitespace-separated)Yank (copier)
y{motion} copie du texte sans le supprimer. yy copie la ligne. Contrairement à d (qui a x comme raccourci), y n'a pas de raccourci mono-caractère — il faut un mouvement. Le yank met toujours à jour le registre 0, utile pour le distinguer des suppressions. Utilisez les text objects : ya( copie autour des parenthèses, yi" à l'intérieur des guillemets.
y # yank {motion} (no character shortcut)
yy / Y # yank current line
yw # yank to next word start
ye # yank to end of word
y$ # yank to end of line
y0 # yank to beginning of line
yG # yank to end of file
ygg # yank to beginning of file
5yy # yank 5 lines
ya( # yank around parentheses
yi" # yank inside double quotes
yt, # yank up to (not including) next comma
# Yanked text goes to:
# " (unnamed register)
# 0 (yank register, only updated by y)Put (coller)
p colle après le curseur (ou sous la ligne pour des données linéaires) ; P colle avant. gp/gP déplacent le curseur à la fin du texte collé — utile pour enchaîner des opérations. ]p/[p réindente les lignes collées pour matcher l'environnement. Le registre presse-papiers (+) partage avec le presse-papiers système si 'clipboard' est bien réglé.
p # paste after cursor (linewise: line below)
P # paste before cursor (linewise: line above)
gp # paste after, leave cursor on last pasted char
gP # paste before, leave cursor on last pasted char
]p # paste after, reindent to match
[p # paste before, reindent to match
"+p # paste from system clipboard
"*p # paste from primary selection (X11)
# Linewise vs charwise:
# yy + p -> pasted as a new line below
# y$ + p -> pasted after cursor on same line
# Counts: 3p pastes the register 3 times.Changer la casse
~ bascule un seul caractère et avance. g~/gu/gU sont des opérateurs qui marchent avec des mouvements ou text objects. En mode visuel, U/u/~ agissent sur la sélection. Utilisez gUiw pour passer le mot courant en majuscules, gUU pour toute la ligne. Non destructif — seule la casse change.
~ # toggle case of char under cursor (advances)
3~ # toggle case of next 3 chars
g~{motion} # toggle case of motion
gu{motion} # lowercase motion
gU{motion} # uppercase motion
g~~ # toggle case of current line
guu # lowercase current line
gUU # uppercase current line
g~~gg # toggle case to first line
# Visual mode:
# U # uppercase selection
# u # lowercase selection
# ~ # toggle case of selection
# Examples:
# hello + gUw -> HELLO
# HELLO + guw -> hello
# hello + g~w -> HELLOJoindre et scinder des lignes
J joint les lignes avec une seule espace ; gJ joint sans rien insérer. :join marche sur une plage. gq est l'opérateur de formatage — il replie les lignes à 'textwidth' (souvent 80), en respectant 'formatoptions'. Utilisez gqip pour reformater un paragraphe, gqq pour une ligne. Réglez 'textwidth=80' pour activer le repli automatique.
J # join next line with current (inserts space)
gJ # join next line without inserting space
3J # join next 3 lines into one
:[range]join # join lines in range (also :j)
:[range]join! # join without inserting space
# Splitting a line:
# In insert mode, press Enter (autoindent applies)
# In normal mode: r<Enter> replaces char with newline
# Break a long line at column 80 (with 'textwidth'):
gq{motion} # format motion text to 'textwidth'
gqq # format current line
gqip # format paragraph
gvgq # format visual selection
# Set text width:
:set textwidth=80Répéter et annuler
. répète le dernier changement — la touche la plus utile de Vim. u/Ctrl-r sont undo/redo. U annule tous les changements de la ligne courante. :earlier/:later peuvent voyager dans le temps par durée ou compte, même entre branches (Vim garde un arbre d'undo). Utilisez :undolist pour voir les branches. @: répète la dernière commande Ex, & le dernier substitut.
. # repeat last change (most powerful key in Vim)
u # undo
Ctrl-r # redo
U # undo all changes on current line
:Nu # undo N changes
:earlier 10m # revert to state 10 minutes ago
:later 5 # redo 5 changes
:undolist # show undo tree branches
# Repeat with counts:
5. # repeat last change 5 times
# Repeat Ex commands:
@: # repeat last :command
& # repeat last :s (substitute)
# Repeat macros/marks across files:
:& # repeat last substitute on current lineRecherche et substitution
Recherche de base
/ et ? cherchent en avant/arrière ; n/N répètent. * cherche le mot entier sous le curseur (frontières de mot), g* n'importe quelle sous-chaîne. :noh efface la surbrillance courante jusqu'à la prochaine recherche. Réglez 'hlsearch' pour surligner toutes les correspondances en persistant, 'incsearch' pour le matching incrémental à la frappe.
/pattern # search forward for pattern
?pattern # search backward
n # repeat search (same direction)
N # repeat search (opposite direction)
* # search forward for word under cursor
# # search backward for word under cursor
g* # search forward (loose, matches substring)
g# # search backward (loose)
# Search history:
# Press / then Up/Down to recall previous searches
# Clear search highlighting:
:nohlsearch # or :noh
# Toggle 'hlsearch' permanently:
:set hlsearch!Options de recherche
'ignorecase' + 'smartcase' est la combinaison recommandée : insensible à la casse sauf si votre motif contient une majuscule. \c/\C outrepasse la casse par recherche. \v active le mode « very magic » où beaucoup de caractères deviennent spéciaux sans échappement — une syntaxe regex plus propre. Les offsets de recherche (e, b) positionnent le curseur relativement à la correspondance.
:set ignorecase # case-insensitive search (ic)
:set smartcase # case-sensitive if pattern has uppercase
:set hlsearch # highlight all matches (hls)
:set incsearch # show match as you type (is)
:set wrapscan # wrap around end of file (ws)
:set gdefault # add 'g' flag to all :s by default
# Per-search case override:
/foo\c # case-insensitive search for foo
/foo\C # case-sensitive search for foo
# Use very-magic mode (less escaping):
/foo\v(.+)@<=(bar) # very magic regex
# Search offsets:
/foo/e # cursor on last char of match
/foo/e+2 # cursor 2 chars past match
/foo/b-1 # cursor 1 char before matchMotifs de recherche (regex)
La regex de Vim diffère de PCRE — les antislashs sont requis pour +, =, {, (, |. Utilisez le préfixe \v pour le mode « very magic » où ils deviennent spéciaux sans échappement (plus proche de PCRE). \< \> marquent les frontières de mots. \d/\w/\s sont des classes de caractères. Utilisez \(...\) pour les groupes de capture, \1/\2 pour les backreferences.
# Standard Vim regex (default magic mode)
. # any char
* # zero or more (preceding atom)
\+ # one or more
\= # zero or one (optional)
\{n,m} # between n and m
^ $ # start/end of line
\< \> # word boundaries
[abc] # char class (a, b, or c)
[^abc] # negated char class
\( \) # group
\1 \2 # backreference
\| # or
# Predefined classes:
\d \D # digit / non-digit
\w \W # word char / non-word
\s \S # whitespace / non-whitespace
# Very magic (\v prefix) — less escaping:
/\v\w+\s+\w+ # word, spaces, word (no backslashes needed)
/\v(%d+) # capture one-or-more digitsCommande de substitution
:[plage]s/motif/remplacement/flags est la commande de substitution. :% signifie tout le fichier. Sans flag 'g', seule la première correspondance par ligne est remplacée ; 'g' remplace tout. 'c' demande confirmation (y/n/a/q/l). Utilisez \v pour very-magic afin de simplifier la syntaxe de groupement. Les groupes de capture se référencent \1, \2 dans le remplacement.
:[range]s/old/new/[flags]
# Basic:
:s/old/new/ # replace first 'old' on current line
:s/old/new/g # replace all 'old' on current line
:%s/old/new/g # replace all in whole file
:%s/old/new/gc # confirm each replacement
:%s/old/new/gi # case-insensitive
# Range examples:
:5,10s/old/new/g # lines 5-10
:.,$s/old/new/g # current line to end
:'a,'bs/old/new/g # from mark a to mark b
:'<,'>s/old/new/g # visual selection
:1,$s/old/new/g # whole file (same as %)
# Replace with capture groups:
:%s/\(\w\+\),\(\w\+)/\2,\1/ # swap two comma-separated words
:%s/\v(\w+),(\w+)/\2,\1/ # same with very-magicFlags de substitution et remplacement spécial
Flags courants : g (tout), c (confirmer), i (insensible à la casse), n (compter seulement). & dans le remplacement insère le texte matché. \u/\U/\l/\L modifient la casse du remplacement. Utilisez \r pour insérer un retour à la ligne (\n est un octet nul dans le remplacement). Le flag 'n' est parfait pour compter les correspondances sans rien changer.
# Flags:
g # all occurrences on each line (not just first)
c # confirm each substitution
i # ignore case
I # don't ignore case
e # don't error if no match
p # print last substituted line
n # count matches, don't substitute
# Special chars in replacement:
& # the matched text
\0 # the matched text (same as &)
\1..\9 # capture groups
\u # next char uppercase
\U # rest of string uppercase (until \e or \E)
\l \L # lowercase (single / until \e)
\r # split into new line
\n # null byte (use \r for newline)
# Examples:
:%s/foo/&bar/g # foo -> foobar
:%s/\v(\w+)/\U\1/g # uppercase every word
:%s/, /,\r/g # split lines on ', '
:%s/old/new/gn # count matches onlyCommande globale (:g)
:g exécute une commande Ex sur chaque ligne matchant un motif — un puissant éditeur « global ». :v (ou :g!) tourne sur les lignes non matchantes. Combinez à n'importe quelle commande Ex : d (supprimer), m (déplacer), t (copier), s (substituer), normal (exécuter une commande normal-mode). Utile pour les opérations en lot sur des lignes étiquetées. L'ordre compte : :g traite de haut en bas par défaut.
:[range]g/pattern/cmd # run cmd on each matching line
:[range]g!/pattern/cmd # run cmd on NON-matching lines
:v/pattern/cmd # same as :g! (inverse)
# Common uses:
:g/^$/d # delete all blank lines
:g/TODO/d # delete all lines with TODO
:g/pattern/p # print all matching lines
:g/pattern/normal @a # run macro a on each matching line
:g/pattern/m0 # move matching lines to top (reverse order)
:g/pattern/t$ # copy matching lines to end
:g/pattern/s/old/new/g # substitute on matching lines only
# Combined with Ex range:
:g/^#/s/foo/bar/g # in lines starting with #, replace foo with bar
# Multiple commands per match:
:g/pattern/d|t0 # delete then copy (chained with |)Mode visuel
Types de mode visuel
v/V/Ctrl-v sélectionnent caractères/lignes/bloc. gv resélectionne la dernière sélection visuelle — pratique pour ré-appliquer une opération. o va à l'autre extrémité de la sélection (pour étendre dans les deux sens). En mode bloc, O va à l'autre coin de la même ligne.
v # charwise visual (select characters)
V # linewise visual (select whole lines)
Ctrl-v # blockwise visual (select rectangle)
gv # reselect last visual selection
# In visual mode:
o / O # move cursor to other end of selection (corner for block)
Esc / v # exit visual mode (toggle)
# Quick selections from normal mode:
vap # select around paragraph
vip # select inside paragraph
i" # then press v... actually ciw etc. work directly
# Switching between types:
# v then V -> linewise (extends to whole lines)
# V then v -> charwise
# Ctrl-v -> blockwiseOpérations visuelles
Une fois la sélection faite, d/c/y/x marchent comme attendu. = auto-indente (génial pour reformater du code). >/< indente/désindente d'un shiftwidth. ! pipe la sélection à travers une commande shell et la remplace par la sortie. Appuyer : en mode visuel pré-remplit '<,'> comme plage, donc :s/old/new/g ne tourne que sur la sélection.
# In visual mode, press:
d / x # delete selection
c / s # change selection (delete, enter insert)
y # yank (copy) selection
~ # toggle case of selection
u / U # lowercase / uppercase selection
> # indent selection
< # dedent selection
= # auto-indent selection (reformat)
!cmd # filter through external command
:r !cmd # (after yank) paste command output
# Replace entire selection with a char:
r{x} # replace every char with x
# Print line numbers of selection:
g Ctrl-g # count words/chars/lines in selection
# Search within selection (after selecting, type :):
# '<,'>s/old/new/g -- range auto-filledAstuces du bloc visuel
Le bloc visuel (Ctrl-v) est l'une des fonctionnalités les plus puissantes de Vim. I et A insèrent avant/après le bloc — le texte se réplique sur chaque ligne après Esc. C'est le moyen le plus simple d'ajouter un préfixe de commentaire à plusieurs lignes ou d'apposer un suffixe. c change tout le bloc ; r{x} remplace chaque caractère par x. Les éditions de bloc ne marchent proprement que sur des lignes de longueur similaire.
# Enter block visual: Ctrl-v
# Select a column rectangle, then:
I # insert BEFORE block (text typed appears in front)
# Type text, then Esc -> inserted on every line of block
A # insert AFTER block (text appears at end of each line)
# Esc propagates the insert to all lines
c # change block (delete, enter insert; Esc propagates)
r{x} # replace every char in block with x
# Common use cases:
# 1. Add a comment to a column of lines:
# Ctrl-v select first column, I, type '# ', Esc
# 2. Add semicolons at end of selected lines:
# Ctrl-v select end column, $A;, Esc
# 3. Delete a column:
# Ctrl-v select, d
# 4. Replace a column with same char:
# Ctrl-v select, r;Mode ligne visuelle
V sélectionne des lignes entières. Après V, les opérations courantes sont d/y/>/</= pour les manipuler. :m déplace la sélection (ex. :'<,'>m0 la déplace tout en haut). :t duplique. '< et '> sont des marques au début/fin de la dernière sélection visuelle — utiles dans les scripts. gv resélectionne la dernière plage visuelle.
V # enter linewise visual
5V # select 5 lines (current + 4 below)
ggVG # select entire file
:'<,'> # range referring to last visual selection
# After selecting lines (V), useful commands:
d # delete lines
y # yank lines (linewise)
> # indent lines
< # dedent lines
= # auto-indent lines
:m +2 # move selection down 2 lines
:m -3 # move selection up 3 lines
:t . # duplicate lines (copy below selection)
:g/^/m0 # reverse line order (whole file)
# Reselect last visual:
gv # reselect last visual selection
'< # mark: start of last visual
'> # mark: end of last visualVisuel avec text objects
Les text objects marchent aussi en mode visuel — ils étendent la sélection courante. vi( sélectionne à l'intérieur des parenthèses ; va( les inclut. Répéter un text object (vawaw) étend davantage. Souvent plus rapide que de positionner le curseur à la main. Combinez aux opérateurs : ciw change le mot intérieur peu importe la position du curseur dedans.
# In visual mode, text objects EXTEND the selection:
# After pressing v (charwise), type:
aw # extend selection to include next 'a word'
iw # extend selection to inner word
ab # around brackets ()
ib # inside brackets ()
aB # around braces {}
iB # inside braces {}
a" # around double-quoted string
i" # inside double-quoted string
ap # around paragraph
ip # inside paragraph
# Repeated text objects extend selection:
# vaw -> select word + trailing space
# vawaw -> extend to next word + space
# Switch between inner and around:
# vi( -> select inside parens
# va( -> extend to include the parensRecherche visuelle et numérotation
Appuyer : en mode visuel pré-remplit '<,'> comme plage — les substitutions ne tournent que sur la sélection. Pour chercher la sélection visuelle, utilisez y/ puis Ctrl-r " Entrée (coller le registre dans la recherche). g Ctrl-a en bloc visuel crée une séquence croissante — inestimable pour générer des listes numérotées (1, 2, 3, ...) depuis une colonne de nombres identiques.
# Search within visual selection:
# 1. Visually select (v/V/Ctrl-v)
# 2. Press : -> :'<,'> appears
# 3. Type s/old/new/g -> substitute only in selection
# Search for current visual selection (forward):
# In visual mode, type:
# \V then / (very-nomagic, escapes regex chars)
# Or use a plugin (e.g. vim-visual-star-search)
# Manual method:
# y/ then Ctrl-r " Enter -> search for selection
# Increment/decrement numbers (visual block):
# Select a column of numbers (Ctrl-v)
Ctrl-a # increment every number in selection by 1
Ctrl-x # decrement every number in selection by 1
g Ctrl-a # increment with running counter (1,2,3,...)
g Ctrl-x # decrement with running counter
# Example: turn 0,0,0,0 into 1,2,3,4:
# Ctrl-v select column, g Ctrl-aBuffers
Bases des buffers
Les buffers sont des fichiers en mémoire. :e ouvre un fichier dans un nouveau buffer. :ls liste tous les buffers avec leurs flags de statut (% = courant, # = alterné, + = modifié, h = caché). :b N bascule par numéro ; :b nom par préfixe unique. Ctrl-6 (ou :b#) bascule entre buffers courant et alterné — extrêmement courant.
:e file.txt # open file in new buffer (current window)
:enew # new empty buffer
:ls / :buffers # list all buffers
:b N # go to buffer N (by number from :ls)
:b name # go to buffer by name (unique prefix)
:bn # next buffer
:bp # previous buffer
:b# / Ctrl-6 # alternate buffer (last edited)
:ball # open all buffers in horizontal splits
:vertical ball # open all buffers in vertical splits
# Buffer list symbols:
# % current window's buffer
# # alternate buffer
# a active (loaded and visible)
# h hidden (loaded but not visible)
# - not modifiable
# = read-only
# + modifiedNavigation entre buffers
:bn/:bp cyclent à travers les buffers. Ctrl-6 bascule entre les deux plus récents — la façon la plus rapide d'aller-retour. Avec 'hidden' réglé, quitter un buffer modifié ne force pas la sauvegarde — Vim le cache. Utilisez :ls puis :b N si vous oubliez les numéros. Des plugins comme fzf.vim rendent la bascule de buffers floue bien plus rapide.
:bn / :bnext # next buffer (wraps around)
:bp / :bprev # previous buffer
:bf / :bfirst # first buffer
:bl / :blast # last buffer
:b# # alternate buffer (Ctrl-6)
:N b # go to buffer number N (e.g. 3b)
:b name<tab> # tab-complete buffer name
:ls then :b N # two-step navigation
# Faster navigation (set in vimrc):
:nmap <C-n> :bn<CR>
:nmap <C-p> :bp<CR>
# Jump to a buffer with fuzzy matching (with fzf.vim):
:Buffers # fuzzy-select from buffer list
# Hide current buffer without saving (if 'hidden' is set):
:hide # or :bn with 'set hidden'Opérations sur les buffers
:bd retire un buffer de la liste (le fichier se ferme). :bw efface aussi les marques et variables locales au buffer. :%bd | e# supprime tout sauf le buffer courant — un pattern de nettoyage courant. :bufdo exécute une commande Ex dans chaque buffer — puissant pour les substitutions globales, mais attention aux erreurs (utilisez ! pour ignorer, ou ajoutez le flag 'e' à :s).
:bd / :bdelete # delete current buffer
:bd N # delete buffer N
:bd name # delete buffer by name
:bw / :bwipeout # wipe buffer (also clears marks, vars)
:N,N bd # delete buffers in range
:%bd # delete all buffers
:%bd | e# # delete all but current
:bn! # force switch (don't save current)
:wall # write all buffers
:bufdo cmd # run cmd in every buffer
:bufdo! cmd # same but ignore errors
# Useful patterns:
:bufdo %s/old/new/ge # substitute in all buffers
:bufdo setlocal nowrap # apply setting to all buffers
# Save and quit current buffer:
:wq # write current and quit (closes window)Buffers cachés
Avec 'set hidden' (très recommandé), on peut quitter des buffers modifiés sans sauvegarder — Vim les garde en mémoire. Sans 'hidden', Vim bloque la bascule jusqu'à sauvegarde ou utilisation de ! pour jeter. :ls montre 'h' pour les buffers cachés et '+' s'ils sont modifiés. Ce réglage est essentiel pour une édition multi-fichiers productive.
:set hidden # allow switching from modified buffers
:set nohidden # force save/abandon when switching
# With 'hidden' set:
# :bn # switch even if current is modified (no save)
# :q # if buffer is modified, prompts to save
# :qa! # quit all without saving
# :wa # write all (hidden + visible)
# Buffer with changes still in memory:
:ls # shows 'h' flag for hidden, '+' for modified
# Recover list of hidden buffers:
:ls h # only hidden buffers
# Save a hidden buffer:
:w # save current (if visible)
:N w # save buffer N
:wall # save all buffers
# Common workflow with hidden:
# :e file1 -> make changes -> :e file2 -> :e file1 (changes preserved)Liste d'arguments
L'arglist est une liste séparée de la liste des buffers — c'est l'ensemble des fichiers passés en ligne de commande ou réglés avec :args. :n/:prev la parcourent. :argdo exécute une commande Ex dans chaque fichier de l'arglist — parfait pour le traitement en lot comme :argdo %s/foo/bar/ge | update. L'arglist est souvent plus ciblée que la liste des buffers.
# Open files in arglist:
vim file1.txt file2.txt # initial args
:args file1 file2 file3 # replace arglist
:argadd file4 # add to arglist
:arga *.py # add all Python files
:argdelete file2 # remove from arglist
# Navigate arglist:
:n / :next # next file in arglist
:prev / :Next # previous file
:first # first file
:last # last file
:rewind # rewind to first file
# Process all files:
:argdo %s/old/new/ge # substitute in every arg file
:argdo set ff=unix | w # convert line endings in all
# Show current arglist:
:args # show files (current marked with [ ])Gestion de la liste des buffers
:ls liste les buffers, :ls! inclut les non listés (supprimés mais mémorisés). Utilisez :sb pour ouvrir un buffer dans un split sans changer le buffer de la fenêtre courante. Pas d'undo intégré de « buffer récemment fermé », mais des plugins existent. :bufdo vimgrepadd suivi de :copen permet de chercher dans tous les buffers ouverts via la liste quickfix.
:ls # list all buffers
:ls! # list including unlisted buffers
:files # alias for :ls
# Move current buffer to a specific position:
:N b N # buffer number N
# Quickly inspect related files:
:b <tab> # tab-complete buffer names
:b #<tab> # buffers matching '#'
# Find buffer containing a pattern:
:vimgrep /pattern/ % # current buffer only
:bufdo vimgrepadd /pattern/ % # all buffers (then :copen)
# Open buffer in a specific window:
:sb N # open buffer N in horizontal split
:vertical sb N # open buffer N in vertical split
:tab split +b N # open buffer N in new tab
# Restore closed buffers:
# (No built-in, but plugins like vim-molten or
# vim-restore-buffers can help)Marques et sauts
Poser des marques
Les marques sont des positions nommées dans les fichiers. Les minuscules (a-z) sont locales au buffer ; les majuscules (A-Z) sont des marques de fichier qui persistent entre sessions Vim. Les marques numérotées (0-9) se posent automatiquement — 0 est la position à la dernière fermeture de Vim, 1-9 les fichiers récemment fermés. :marks les liste, :delm supprime.
m{a-zA-Z} # set mark at cursor position
ma # set mark 'a' (lowercase, buffer-local)
mA # set mark 'A' (uppercase, file mark)
m' # set the unnamed mark (jump before/after)
# Lowercase marks (a-z):
# Local to current buffer
# Lost when buffer is unloaded
# Uppercase marks (A-Z):
# File marks — preserved across sessions
# Work even after the file is closed
# Numbered marks (0-9):
# Set automatically by Vim
# 0 = position when Vim was last closed
# 1-9 = positions of last 9 closed files
# View marks:
:marks # list all marks
:marks a b c # specific marks
:delm! a # delete mark 'a' (force)Sauter vers des marques
` (backtick) saute à la position exacte (ligne + colonne) ; ' (apostrophe) au premier non-espace de la ligne marquée. `A ouvre le fichier contenant la marque A même s'il était fermé. `. saute là où vous avez changé du texte en dernier, `[ et `] bornent la dernière région copiée/supprimée, `< et `> bornent la dernière sélection visuelle.
\`{a-zA-Z} # jump to mark (line AND column)
'{a-zA-Z} # jump to mark (line only, column 1)
\`a # jump to mark 'a' (exact position)
'a # jump to line of mark 'a'
\`A # jump to file mark 'A' (opens file if closed)
\`. # jump to position of last change in this buffer
\`" # jump to position when file was last closed
\`[ # jump to start of last yanked/changed text
\`] # jump to end of last yanked/changed text
\`< # jump to start of last visual selection
\`> # jump to end of last visual selection
\`^ # jump to last insert position (also gi)
# Jump to next/prev mark in alphabetical order:
:[count]next # (no built-in, requires plugin)Liste de sauts
Vim garde une liste de sauts des mouvements significatifs du curseur. Ctrl-o/Ctrl-i reculent/avancent dedans. « Significatif » signifie des sauts (G, gg, recherche, sauts de marque, sauts de tag) — pas les mouvements ordinaires comme j/k/w. :jumps montre la liste. La liste de sauts est par fenêtre et persiste entre sessions via viminfo/shada.
Ctrl-o # jump BACK in jumplist (older positions)
Ctrl-i # jump FORWARD in jumplist (newer positions)
Tab # same as Ctrl-i
:ju # show jumplist (:jumps)
# What counts as a jump?
# - Movement commands: G, gg, H, M, L, %
# - Search: /, ?, n, N, *, #
# - Mark jumps: 'x, `x (NOT mm)
# - Buffer switch: Ctrl-6, :b, :e
# - Tag jumps: Ctrl-]
# NOT counted: j, k, w, b, h, l (regular motions)
# Max jumplist size: 100 entries by default
:set jumpoptions=stack # treat jumplist like a stack
# Clear jumplist:
:clearjumps # or :cljListe de changements
La liste de changements suit les positions d'édition (pas de navigation). g; saute à l'édition précédente, g, à la suivante. Utile pour remonter vos changements : « où est-ce que je travaillais ? ». :changes montre la liste. Contrairement à la liste de sauts, la liste de changements est par buffer. Combinez à `. pour le tout dernier changement du buffer courant.
g; # go to OLDER position of last change
g, # go to NEWER position of last change
:changes # list changelist
# Each entry shows:
# change number, line, column, text of change
# What counts as a change?
# - Any insertion, deletion, or substitution
# - Records the position BEFORE the change
# Differences from jumplist:
# - Changelist tracks EDITS, not movements
# - Per-buffer (not per-window)
# - Limited to 100 entries
# Combine with marks:
\`. # last change position in current buffer
g; # previous change position
# Common pattern: g;g;g; to walk back through editsMarques de fichier (A-Z)
Les marques majuscules (A-Z) sont des marques de fichier — elles retiennent le fichier ET la position, persistant entre sessions Vim (stockées dans viminfo). Poser mA dans foo.txt permet de revenir à cette position de n'importe où avec `A, même après redémarrage de Vim. Utilisez-les comme marque-pages pour les fichiers/positions importants d'un projet.
# Setting a file mark:
mA # set mark 'A' at cursor (in current file)
mB # set mark 'B' (in current file)
# Jumping to a file mark:
\`A # if file is open: jump to position
\`A # if file is closed: open it, then jump
'A # jump to first non-blank of mark's line
# File marks persist across Vim sessions:
# Stored in viminfo (or shada in Neovim)
# Restored on next Vim launch
# Use cases:
# 1. Bookmark a function: mA in function definition
# 2. Quick jump between files: `A, `B
# 3. Project navigation: set marks in important files
# Listing file marks:
:marks A-Z # show only file marks
# Deleting:
:delm A # delete file mark A (must be in its file)Marques spéciales intégrées
Vim pose des marques spéciales automatiquement. `. est le dernier changement, `[ et `] bornent la dernière région copiée/supprimée, `< et `> bornent la dernière sélection visuelle, `^ est là où le mode insertion s'est terminé en dernier (gi y saute et ré-entre en insertion). `" est la position à la dernière fermeture du fichier — utile pour reprendre le travail.
\`. # position of last change in current buffer
\`" # position when file was last exited
\`[ # start of last yanked/changed text
\`] # end of last yanked/changed text
\`< # start of last visual selection
\`> # end of last visual selection
\`^ # position where insert mode was last stopped
\`' # position before latest jump (where you came FROM)
# Common uses:
\`[\`] # operate on last yanked range: \`[v\`]U (uppercase it)
\`<\`> # re-select last visual: \`<v\`> or gv
# Re-select last visual selection:
gv # easier than \`<v\`>
# Re-select last pasted text:
\`]v\`[ # or use a mapping: nnoremap gp \`]v\`[
# Return to last insert position:
gi # jump to `^ and enter insert modeText objects
Objets mot et phrase
Les text objects permettent d'opérer sur des unités sémantiques. 'aw' (around word) inclut l'espace final — daw ferme le trou. 'iw' (inner word) laisse les espaces intacts — diw laisse un blanc. as/ap sont les versions phrase/paragraphe. Répéter un objet (dawaw) étend la sélection. Les plus utiles avec les opérateurs d/c/y/v.
# Operators (d/c/y/v) + text object:
aw # 'a word' - word + trailing whitespace
iw # 'inner word' - word only (no whitespace)
aW # 'a WORD' - WORD + trailing whitespace
iW # 'inner WORD' - WORD only
as # 'a sentence' - sentence + trailing space
is # 'inner sentence' - sentence only
ap # 'a paragraph' - paragraph + trailing blank line
ip # 'inner paragraph' - paragraph only
# Examples:
daw # delete word + trailing space (closes gap)
diw # delete word only (leaves whitespace)
cas # change sentence (with trailing space)
yap # yank paragraph (with trailing blank line)
gqip # format (wrap) inner paragraph
# Repeated: dawaw extends to next wordObjets crochets
Les objets crochets marchent sur (), [], {}, <>. a (around) inclut les crochets ; i (inner) les exclut. ci( change le contenu des parenthèses sans les retirer — parfait pour éditer les arguments de fonction. Marche sur la paire la plus interne quand imbriquée. at/it opèrent sur les tags HTML/XML (ex. cit change le contenu interne du tag).
# Brackets (any of ( [ { <):
ab / ib # around / inside ()
aB / iB # around / inside {} (also a{ / i{)
a( / i( # same as ab / ib
a[ / i[ # around / inside []
a{ / i{ # same as aB / iB
a< / i< # around / inside <>
# Examples:
ci( # change text inside ( ... )
daB # delete {...} block including braces
yi[ # yank text inside [...]
vaB # visually select around {...}
# Special: 'tag' objects (HTML/XML):
at / it # around / inside <tag>...</tag>
# Tip: works with mismatched brackets too:
# ci) on (foo bar) changes 'foo bar'
# Nested: ci( in ((a)(b)) changes innermostObjets guillemets
Les objets guillemets (a"/i", a'/i', a`/i`) opèrent sur les chaînes quotées. Le curseur n'a pas besoin d'être dans les guillemets — Vim trouve la paire la plus proche. ci" change le contenu d'une chaîne sans retirer les guillemets — inestimable pour éditer des littéraux de chaînes. Inclut les guillemets avec 'a', les exclut avec 'i'.
a" # around double-quoted string (includes quotes)
i" # inside double-quoted string (no quotes)
a' # around single-quoted string
i' # inside single-quoted string
a\` # around backtick-quoted string
i\` # inside backtick-quoted string
# Examples:
ci" # change text inside "..."
da" # delete "..." (including quotes)
yi' # yank text inside '...'
va\` # visually select around \`...\`
# Cursor can be ANYWHERE on the line — Vim finds the
# nearest quote pair containing or following the cursor.
# Special: with counts
3a" # around 3 consecutive quoted strings
# Tip: ci" when cursor is on the quote itself works tooObjets phrase et paragraphe
Les phrases finissent par . ! ? suivis d'espaces (ou d'une rupture de paragraphe). Les paragraphes sont des blocs séparés par des lignes vides. 'a' inclut l'espace final, 'i' l'exclut. Utiles avec les opérateurs : gqap reformate un paragraphe, >ip l'indente, das supprime une phrase. Les mouvements ( et ) sautent entre phrases.
# Sentence: ends with . ! ? followed by whitespace
as / is # around / inner sentence
# Paragraph: blocks of text separated by blank lines
ap / ip # around / inner paragraph
# Examples:
das # delete a sentence
cip # change inside paragraph
vap # select around paragraph (with trailing blank)
# Differences:
# 'a' (around): includes trailing whitespace/blank line
# 'i' (inner): no trailing whitespace
# Use cases:
# gqap # reformat (wrap) the paragraph
# >ap # indent the paragraph
# vip # select inside paragraph
# :'<,'>s/old/new/g # substitute in selected paragraph
# Sentence motion commands (not objects):
( # previous sentence start
) # next sentence startObjets tag et URL (avec plugins)
Les at/it intégrés opèrent sur les tags HTML/XML. cit change le contenu interne du tag, dat supprime tout le tag y compris l'ouverture/fermeture. Pour les tags imbriqués, it sélectionne le plus interne, puis vat étend vers l'extérieur. Les plugins ajoutent des objets : vim-textobj-url (au/iu), vim-indent-object (ai/ii pour les blocs de même indentation — excellent pour le code).
# Built-in tag object (HTML/XML):
at / it # around / inside <tag>...</tag>
# Examples:
cit # change inner tag text: <p>text</p> -> <p>|</p>
dat # delete entire tag: <p>text</p> -> (gone)
vit # visually select inner tag text
yat # yank entire tag including <tag>...</tag>
# For nested tags, 'it' selects the innermost:
# <div><p>text</p></div>
# cit on 'text' changes 'text' only
# vat extends selection outward
# URL objects (require a plugin like vim-textobj-url):
# au / iu # around / inside URL
# Indent objects (require vim-indent-object):
# ai / ii # around / inside same-indent block
# aI / iI # entire indentation level
# Common plugin combos:
# vai # select around indent block (great for code)Utiliser les text objects (recettes)
Les text objects se combinent à tout opérateur (d/c/y/v/>/</=) pour des éditions puissantes. ciw change un mot sans devoir positionner le curseur exactement. ci"/ci(/ci[ changent à l'intérieur des guillemets/crochets. gqip reformate les paragraphes. Maîtriser cela est la clé pour éditer à la vitesse de la pensée dans Vim.
# Common editing recipes using text objects:
# Word:
ciw # change word (regardless of cursor position in it)
daw # delete word + space (closes gap)
yiw # yank inner word (no whitespace)
# Quotes:
ci" # change inside "..."
ci'\` # change inside '...' or \`...\`
da" # delete the entire string (with quotes)
# Brackets:
ci( # change inside (...) -- great for args
daB # delete {...} block (function body)
ci[ # change inside [...]
# Sentences & paragraphs:
cas # change a sentence
dap # delete a paragraph
gqip # reformat paragraph
# HTML tags:
cit # change tag content
vat # select tag, then vat again to extend
# Combos with counts:
2daw # delete two words
c2aw # change two wordsRegistres
Bases des registres
Les registres sont les presse-papiers de Vim. "ayy copie une ligne dans le registre a, "ap colle depuis a. Il y a beaucoup de registres : nommés (a-z), d'ajout (A-Z), numérotés (1-9), et spéciaux (sans nom ", yank 0, presse-papiers +, etc.). :reg les liste. En mode insertion, Ctrl-r {registre} insère un registre. Une lettre majuscule AJOUTE à un registre.
# Registers store text. 10 named (a-z), 10 append (A-Z),
# 9 numbered (1-9), and several special ones.
"ay # yank into register 'a' (then motion: "ayy, "ayw)
"ap # paste from register 'a'
"ad # delete into register 'a' (e.g. "add)
"Ay # APPEND to register 'a' (uppercase = append)
# View all registers:
:reg # list all registers
:reg a b c # list specific registers
:reg + # show clipboard register
# Use a register with operators:
"aD # delete to end of line into 'a'
"byy # yank line into 'b'
"cp # paste register 'c'
# Insert mode: Ctrl-r + register
Ctrl-r a # insert contents of register 'a'
Ctrl-r = # expression register (compute, insert)
# Search from a register:
/ then Ctrl-r a # search register 'a' contentsRegistres nommés et numérotés
Les registres nommés (a-z) sont contrôlés par l'utilisateur ; A-Z ajoutent à a-z. Les registres numérotés (1-9) suivent automatiquement les dernières suppressions — 1 est le plus récent, chaque nouvelle suppression décale. Le registre 0 ne détient que le dernier YANK (les suppressions ne l'écrasent pas) — utile pour les workflows copier-puis-supprimer. "- détient les petites suppressions (sous-ligne).
# Named registers (a-z, A-Z):
"ayy # yank line into 'a'
"byiw # yank inner word into 'b'
"Ayy # append yanked line to 'a' (uppercase)
# Numbered registers (1-9) — auto-filled by deletes:
"1 # last delete (largest)
"2 # second-to-last delete
... # shift older with each new delete
"9 # oldest tracked delete
# Small delete register:
"- # stores deletes < 1 line (e.g. dw)
# Yank register (separate from deletes):
"0 # last YANK only (not affected by deletes)
# Examples:
"0p # paste last yank (won't paste a delete)
"1p # paste last delete
". # last inserted text (read-only)
"% # current file name (read-only)Registres spéciaux
Registres spéciaux : ". = dernier texte inséré, "% = fichier courant, "/ = dernière recherche, ": = dernière commande. "_ est le trou noir — écrire dedans jette le texte (utile pour des suppressions qu'on ne veut pas polluer les autres registres). "+ est le presse-papiers système, "* la sélection primaire X11. "= évalue une expression Vimscript et insère le résultat.
# Read-only registers:
". # last inserted text
"% # current file name
"# # alternate file name
": # last Ex command
"/ # last search pattern
# Read/write registers:
"0 # last yank (not overwritten by deletes)
"- # last small delete (less than one line)
"_ # black hole register (discard, like /dev/null)
"= # expression register (evaluate Vimscript)
# Clipboard / selection:
"+ # system clipboard (Ctrl-C / Ctrl-V)
"* # primary selection (X11 middle-click)
# Examples:
"_dd # delete line without saving to register
"+y # yank to system clipboard (then Ctrl-V elsewhere)
"*p # paste from X11 primary selection
# Expression register (in insert mode):
Ctrl-r =strftime('%Y-%m-%d')<CR>
# inserts today's date
# Black hole: "_ prevents updating other registers.Macros dans les registres
Les macros vivent dans les registres — enregistrer avec qa écrit les touches dans le registre a, @a les rejoue. Comme ce sont des registres, on peut les inspecter (:reg a), les éditer en collant/modifiant/recopiant, ou les sauvegarder dans le vimrc avec :let @a = '...'. Échappez les touches spéciales avec \<Esc> dans les littéraux de chaînes.
# Macros are stored in registers, just like yanked text.
# Record a macro into register 'a':
qa # start recording into 'a'
... # perform actions
q # stop recording
# Play back the macro:
@a # play macro 'a' once
@@ # play last macro again (the one just played)
5@a # play macro 'a' 5 times
:reg a # view the recorded keystrokes
# Edit a macro:
:let @a = "..." # set register 'a' directly
# Or: paste the register, edit, yank back:
"ap # paste macro keystrokes
# ... edit the text ...
"ayy # yank edited version back into 'a'
# Save a macro to vimrc:
:let @a = "0iHello \<Esc>" # escaped special keys
# Apply macro to a range:
:%normal @a # run macro 'a' on every lineAjout et trou noir
Les lettres de registre majuscules AJOUTENT : "Ayy ajoute au registre a (très utile pour accumuler du texte ou des macros multi-étapes). Le registre trou noir "_ jette tout ce qui y est écrit — les suppressions ne mettent pas à jour les registres numérotés/sans nom/de yank. Utilisez-le pour supprimer du texte sans écraser votre dernier yank.
# Append to a register (use UPPERCASE letter):
"ayy # yank line into 'a'
"Ayy # APPEND another line to 'a'
"Ayiw # APPEND a word to 'a'
# After: register 'a' contains both.
# Black hole register "_:
"_d # delete without affecting other registers
"_dd # delete line, doesn't update "1, "0, "-
"_c # change without saving deleted text
"_x # delete char, nothing saved
# Why use black hole?
# - Keep your yank register ("0) intact while deleting
# - Avoid polluting numbered registers
# Example: yank a line, then delete another (without
# losing the yank):
"ayy # yank into 'a'
"_dd # delete line WITHOUT touching 'a' or '0
"ap # paste the original yank
# When clipboard=unnamed, "_d still bypasses clipboard.Presse-papiers et sélection
"+ est le presse-papiers système (Ctrl-C/Ctrl-V dans les apps GUI), "* la sélection primaire X11 (coller au clic du milieu). Avec :set clipboard=unnamedplus, yanks et collages vont directement au presse-papiers système — plus besoin du préfixe "+. Sous Linux, il peut falloir xclip/xsel (X11) ou wl-clipboard (Wayland) installés.
# System clipboard register:
"+y # yank to system clipboard
"+p # paste from system clipboard
"+dd # delete line to clipboard
"+P # paste before cursor from clipboard
# X11 primary selection (Linux, middle-click):
"*y # yank to primary selection
"*p # paste from primary selection
# Make the system clipboard the default:
:set clipboard=unnamedplus # use '+ for unnamed register
:set clipboard=unnamed # use '* for unnamed register
# Then yank/paste go to clipboard automatically:
yy # yanks to system clipboard (with above setting)
p # pastes from system clipboard
# Check what's in the clipboard:
:reg + # show clipboard contents
# On Linux, install a clipboard tool if missing:
# xclip or xsel for X11
# wl-clipboard for WaylandMacros
Enregistrer des macros
q{lettre} démarre l'enregistrement dans un registre ; appuyez à nouveau q pour arrêter. Les touches enregistrées se rejouent avec @{lettre}. En enregistrant, utilisez des mouvements qui marchent de façon constante — préférez 0, ^, $, w, e à j/k qui dépendent de la colonne. Testez sur quelques lignes avant d'appliquer en masse.
q{a-z} # start recording into register {a-z}
... # perform actions (keystrokes recorded)
q # stop recording
# Example: wrap each word in quotes on a line:
qa # start recording into 'a'
0 # go to first column
i" # insert opening quote
Esc
e # go to end of word
a" # append closing quote
Esc
w # move to next word
q # stop recording
# Now @a will wrap one more word.
# Recording tips:
# - Use 0/^-positioned motions (not j/k)
# - Use commands that work regardless of line length
# - Test on a few lines before applying broadly
# View the recorded macro:
:reg a # see keystrokes in register 'a'Rejouer des macros
@a rejoue la macro une fois, @@ rejoue la dernière, N@a N fois. Pour appliquer une macro à beaucoup de lignes, sélectionnez-les en visuel et lancez :normal @a, ou :%normal @a pour tout le fichier. Les macros s'arrêtent en erreur (ex. quand une recherche échoue), donc 999@a traite en sécurité jusqu'à la fin du fichier. :g/motif/normal @a ne tourne que sur les lignes correspondantes.
@a # play macro 'a' once (in current buffer)
@@ # replay the LAST macro played
5@a # play macro 'a' 5 times
100@a # play 'a' up to 100 times (stops on error)
# Play across multiple lines:
# 1. Visually select lines (V)
# 2. :normal @a # play 'a' on each selected line
# Or:
:%normal @a # play on every line in file
:5,20normal @a # play on lines 5-20
:g/pattern/normal @a # play on lines matching pattern
# Recursive macros:
# If macro 'a' contains @a, it'll recurse.
# Add a 'j' at the end to move to next line.
# Common pattern: process all matching lines:
# qa0f:x...jq # record macro moving down 1 line
# :%s/pattern//gn # count matches
# 100@a # play up to 100 timesÉditer des macros
Comme les macros se stockent dans les registres, on peut les éditer. Collez le registre ("ap), modifiez le texte, puis re-copiez-le ("ay$ ou "ayy). Ou utilisez :let @a = '...' avec des échappements de touches (\<Esc>, \<CR>). Bien plus facile que de ré-enregistrer une macro complexe from scratch après une petite erreur.
# Macros are just text in registers — you can edit them.
# Method 1: paste, edit, yank back:
"ap # paste register 'a' into buffer
# ... edit the pasted text (modify keystrokes) ...
0"ay$ # yank the line back into 'a'
# Method 2: set the register directly with :let
:let @a = "0iHello \<Esc>"
# Note: special keys need \<Esc> notation in strings
# Method 3: edit in a scratch buffer:
:edit
"ap # paste macro
# edit
"ayy # yank back to 'a'
:bdelete
# Common edits:
# - Add 'j' at the end to advance to next line
# - Remove a step that you don't need
# - Replace a hard-coded search with a generic one
# Show the macro as keystrokes:
:reg a # view current 'a' contentsMacros récursives
Les macros récursives s'appellent elles-mêmes jusqu'à une erreur — typiquement quand une recherche échoue. CRUCIAL : videz le registre d'abord (let @a = '') avant d'enregistrer, sinon le premier appel @a dans la macro rejoue les VIEUX contenus. La macro s'auto-termine quand la recherche qui échoue arrête la récursion. Génial pour les motifs globaux de chercher-remplacer.
# A macro can call itself, enabling recursion.
# Example: change every 'foo' to 'bar' in a column:
# (search-based macro)
# Steps to set up recursive macro 'a':
# 1. Clear register 'a':
:let @a = ''
# 2. Start recording:
qa
# 3. Search for 'foo':
/foo<CR>
# 4. Replace with 'bar' (ciwbar<Esc>):
ciwbar<Esc>
# 5. Call itself:
@a
# 6. Stop recording:
q
# Now @a runs until search fails (no more 'foo').
# The recursion stops automatically on the first error
# (when /foo finds nothing).
# Tip: clear the register first, otherwise the FIRST
# call also replays the old contents of 'a'.
# Run:
@a # processes all 'foo' in fileMacros avec comptes
N@a rejoue la macro N fois — mais elle s'arrête tôt à toute erreur, donc 999@a traite en sécurité jusqu'à la fin du fichier. :bufdo normal @a exécute la macro dans chaque buffer, :argdo dans chaque fichier de l'arglist. :g/motif/normal @a ne la fait tourner que sur les lignes correspondantes. Les comptes DANS une macro (ex. 5j) se répètent par rejeu, pas par macro.
# Apply a count to a macro:
5@a # play macro 'a' 5 times
N@a # play up to N times (stops on error)
# Useful: large count to process until end-of-file
999@a # play 'a' up to 999 times (errors stop it)
# Macros with counts INSIDE:
# If your macro starts with '5j', each play jumps 5 lines
# Combine with visual selection (block):
# Ctrl-v to select, then :normal @a
# plays 'a' on each line in the block
# Process every Nth line:
:let i = 0
:g/^/if i % 3 == 0 | normal @a | endif
# (plays 'a' on every 3rd line)
# Apply with a delay (avoid blocking):
# No built-in, but plugins can defer
# Repeat across buffers:
:bufdo normal @a # play 'a' in every buffer
:argdo normal @a # play 'a' in every arg fileMacros entre fichiers et lignes
:[plage]normal @a exécute une macro sur chaque ligne de la plage — le moyen le plus courant d'appliquer une macro à beaucoup de lignes. Terminez votre macro par 'j' pour que chaque itération avance à la ligne suivante. :bufdo/:argdo l'exécutent entre buffers/fichiers. Ajoutez | update pour sauvegarder chaque fichier modifié. Utilisez ! pour continuer malgré les erreurs (ex. :bufdo!).
# Apply a macro to every line in a range:
:[range]normal @a
:%normal @a # whole file
:5,20normal @a # lines 5-20
:'<,'>normal @a # visual selection
:g/pattern/normal @a # only matching lines
# Apply across buffers:
:bufdo normal @a # every buffer
:argdo normal @a # every arglist file
# Save modified buffers after macro run:
:argdo normal @a | update # save each that changed
# Best practice: include 'j' (move down) at end of macro
# so it advances to the next line for :normal usage.
# Example macro for processing CSV rows:
# qa 0f,dt,j q # cut field at comma, move down
# :%normal @a # apply to every line
# Abort on error vs. continue:
:bufdo! normal @a # continue even if a buffer errors
# Debug: play macro step-by-step (no built-in, but
# :set lazyredraw off + slow key timing helps).Pliage (folding)
Méthodes de pliage
foldmethod contrôle comment les plis se créent. 'manual' permet de créer des plis avec zf. 'indent' plie automatiquement par indentation (génial pour le code). 'syntax' utilise les règles de syntaxe (conscient du langage). 'marker' utilise {{{ }}} dans le texte du fichier. 'expr' pour une logique custom. Les plis manuels se perdent à la fermeture du fichier sauf :mkview pour les sauvegarder.
:set foldmethod=manual # fold by hand (zf)
:set foldmethod=indent # fold by indent level
:set foldmethod=expr # fold by 'foldexpr'
:set foldmethod=syntax # fold by syntax rules
:set foldmethod=marker # fold by {{{ }}} markers
:set foldmethod=diff # fold unchanged text in diff
# Recommended defaults:
:set foldmethod=indent # great for code
:set foldlevel=2 # show first 2 levels
# Per-method notes:
# manual - zf to create, zd to delete
# indent - automatic, based on shiftwidth
# syntax - automatic, requires syntax file support
# marker - persistent (saved in file as {{{ }}})
# expr - custom logic via 'foldexpr'
# Persistent manual folds across sessions:
:mkview # save folds (and other view state)
:loadview # restore them
# Or set:
:set viewoptions=folds # what :mkview savesPliage manuel
En mode manuel, zf crée un pli (ex. zf3j plie les 3 lignes suivantes). zd supprime un pli, zD récursivement, zE élimine tous les plis de la fenêtre. Mode visuel + zf plie la sélection. Avec foldmethod=marker, placez des marqueurs de pliage en triples accolades (ouvrante et fermante) dans les commentaires pour créer des plis persistants stockés dans le fichier — utile pour partager la structure de plis en gestion de version.
# Manual fold commands (foldmethod=manual):
zf{motion} # create fold over motion (e.g. zf3j)
zF # create fold over current line(s)
zd # delete fold at cursor
zD # delete fold recursively (nested)
zE # eliminate ALL folds in window
zj / zk # move to next/prev fold start
[z / ]z # move to fold start/end
# Select then fold (visual):
V zf # visually select lines, then fold
# Create fold for a range:
:5,20fold # fold lines 5-20
# Fold using a marker (manual mode):
# Place markers in the file (with foldmethod=marker):
function Foo() " {{{
echo "hi"
endfunction " }}}
# When foldmethod=marker, the {{{ }}} create persistent
# folds stored in the file text itself.Commandes d'ouverture/fermeture de plis
zo/zc ouvrent/ferment un pli ; za bascule. zO/zC/zA agissent récursivement sur les plis imbriqués. zr/zm ajustent le niveau de pli globalement (un niveau à la fois). zR ouvre tout, zM ferme tout — des moyens rapides de réinitialiser. zj/zk sautent entre plis, [z/]z au début/fin du pli courant.
zo # open fold (one level)
zc # close fold (one level)
za # toggle fold (open <-> closed)
zO # open fold recursively (all levels)
zC # close fold recursively (all levels)
zA # toggle fold recursively
zr # reduce fold level by 1 (open one level everywhere)
zm # increase fold level by 1 (close one level everywhere)
zR # open ALL folds (reduce to level 0)
zM # close ALL folds (fold everything)
# Navigation in/around folds:
zj # next fold start (down)
zk # previous fold end (up)
[z # start of current open fold
]z # end of current open fold
# Move with folds intact (don't open):
# Use j/k normally — they may skip closed folds
# Set 'foldopen' to control what opens foldsNavigation et édition des plis
j/k peuvent sauter les plis fermés selon 'foldopen'. zj/zk naviguent entre les frontières de plis. yy/dd sur une ligne pliée opèrent sur TOUTES les lignes pliées comme unité (linéaire). Taper dans un pli fermé l'ouvre. Configurez 'foldopen' pour contrôler quels mouvements ouvrent les plis (ex. retirer 'search' pour garder les plis fermés en cherchant).
# Fold-related motions:
zj # next fold start (move down)
zk # previous fold end (move up)
[z # start of current open fold
]z # end of current open fold
# What opens a fold when triggered?
:set foldopen=block,hor,mark,percent,quickfix,
search,tag,undo
# Defaults open folds on most motions.
# To make j/k NOT open folds:
:set foldopen-=block
# Editing a closed fold:
# Typing inside a closed fold opens it.
# 'o' or 'O' on a fold line opens a new line.
# Search inside closed folds:
# Default behavior depends on 'foldopen'.
# :set foldopen-=search # don't open on search
# Yank/paste on folded lines:
# yy yanks ALL lines in the fold (linewise)
# dd deletes ALL lines in the fold
# Paste over a fold:
# p with a linewise register replaces the folded regionOptions de pliage
foldlevel contrôle la profondeur à laquelle les plis restent ouverts (plus haut = plus ouvert). foldlevelstart=99 démarre tout ouvert. foldcolumn montre une barre latérale avec les indicateurs d'état des plis. foldminlines prévient les plis minuscules. Pour persister les plis entre sessions, :mkview sur BufWinLeave et :loadview sur BufWinEnter — un pattern autocmd courant.
:set foldmethod=indent # folding method
:set foldlevel=2 # show folds deeper than this
:set foldlevelstart=99 # start with all folds open
:set foldminlines=3 # min lines to form a fold
:set foldcolumn=4 # 4-char column showing fold state
:set foldenable # enable folding (default on)
:set foldclose=all # auto-close folds when cursor leaves
:set foldopen=block,hor,mark,percent,quickfix,search,tag,undo
:set foldtext=foldtext() # text to show on a closed fold
:set fillchars=fold:\ , # chars for fold display
# Common combo for code:
:set foldmethod=indent
:set foldlevelstart=10
:set foldnestmax=10 # max nesting depth
# Custom fold text:
:set foldtext=MyFoldText()
function MyFoldText()
return '+++ ' . (v:foldend - v:foldstart + 1) . ' lines +++'
endfunction
# Persistent folds across sessions:
:set viewoptions=folds,cursor
:autocmd BufWinLeave * mkview
:autocmd BufWinEnter * silent loadviewPlis imbriqués et niveau de pli
Les plis s'imbriquent hiérarchiquement. 'foldlevel' détermine la profondeur la plus profonde restée ouverte — foldlevel=0 ferme tout, 99 ouvre tout. zr/zm ajustent de 1, zR/zM sont les extrêmes. 'foldnestmax' plafonne la profondeur d'imbrication pour éviter les plis déchaînés dans du code profondément imbriqué. Des fonctions foldtext custom contrôlent ce qui s'affiche sur un pli fermé.
# Folds can nest. 'foldlevel' controls which are open:
:set foldlevel=0 # all folds closed
:set foldlevel=1 # only top-level open
:set foldlevel=99 # all open
# Display current fold level:
:echo &foldlevel
# Increase/decrease by 1:
zr # reduce (open one level everywhere)
zm # more (close one level everywhere)
zR # open ALL folds (set foldlevel to 99)
zM # close ALL folds (set foldlevel to 0)
# Limit nesting:
:set foldnestmax=10
# Each indent level adds a fold level.
# Useful for deeply-nested code:
# function outer() {
# function inner() { <- foldlevel 2
# function deep() { <- foldlevel 3
# }
# }
# }
# Custom foldtext for nested folds:
:set foldtext=NeatFoldText()
function! NeatFoldText()
let line = getline(v:foldstart)
let n = v:foldend - v:foldstart + 1
return line . ' (' . n . ' lines)'
endfunctionFenêtres scindées
Scinder des fenêtres
:split/:vsplit divisent la fenêtre courante — les deux montrent le même buffer par défaut (les changements se synchronisent). :split fichier ouvre un fichier dans un nouveau split. :new/:vnew créent des buffers vides. Ctrl-w s/v sont les raccourcis clavier. Un préfixe numérique règle la taille de la nouvelle fenêtre (:10split crée une fenêtre de 10 lignes).
:split / :sp # horizontal split (current file)
:vsplit / :vs # vertical split (current file)
:split file.txt # split + open file
:vsplit file.txt # vsplit + open file
:new # horizontal split with empty buffer
:vnew # vertical split with empty buffer
:5split / :5vsplit # split with 5 rows/cols
# Quick splits (Normal mode):
Ctrl-w s # split horizontally (same as :split)
Ctrl-w v # split vertically (same as :vsplit)
Ctrl-w n # new horizontal split (empty)
Ctrl-w q # close window (same as :q)
# Split with size hints:
:10split file.txt # split with height 10
:vert 30split file # vertical split with width 30
# Reopen current file in a new split:
Ctrl-w s # same buffer, two views (sync scroll optional)Navigation entre fenêtres
Ctrl-w suivi de h/j/k/l navigue entre fenêtres (mnémonique : hjkl comme le mouvement). Ctrl-w w cycle vers la fenêtre suivante. Pour la vitesse, beaucoup mappent Ctrl-h/j/k/l directement à la navigation de fenêtres. Ctrl-w p retourne à la fenêtre précédemment utilisée — utile quand on rebondit entre deux fenêtres.
Ctrl-w h # left window
Ctrl-w j # below window
Ctrl-w k # above window
Ctrl-w l # right window
Ctrl-w w # cycle to next window (wraps)
Ctrl-w W # cycle to previous window
Ctrl-w t # top-left window
Ctrl-w b # bottom-right window
Ctrl-w p # previous (last accessed) window
# Faster (with mapping):
:nmap <C-h> <C-w>h
:nmap <C-j> <C-w>j
:nmap <C-k> <C-w>k
:nmap <C-l> <C-w>l
# In terminal mode:
Ctrl-w N # exit terminal mode (to Normal)
Ctrl-w h/j/k/l # navigate (after exiting terminal mode)
# List windows in current tab:
:ls # also shows windows' buffersRedimensionner les fenêtres
Ctrl-w +/-/</> ajustent la taille de 1 ; préfixez d'un compte (10 Ctrl-w +) pour de plus grands pas. Ctrl-w _ maximise la hauteur, Ctrl-w | la largeur. Ctrl-w = égalise toutes les fenêtres. Pour la précision, utilisez :resize N (hauteur) et :vertical resize N (largeur). Avec 'mouse=a', on peut tirer les lignes de statut et séparateurs directement.
Ctrl-w = # equalize all window sizes
Ctrl-w + # increase height by 1
Ctrl-w - # decrease height by 1
Ctrl-w > # increase width by 1
Ctrl-w < # decrease width by 1
Ctrl-w _ # maximize height (current window)
Ctrl-w | # maximize width (current window)
10 Ctrl-w + # increase height by 10
# Ex commands for precise resize:
:resize 20 # set height to 20 (horizontal split)
:resize +5 # increase height by 5
:resize -5 # decrease height by 5
:vertical resize 80 # set width to 80 (vertical split)
:vertical resize +10 # increase width by 10
# Mouse: drag the status line / vertical separator
# (with :set mouse=a)
# Auto-resize on split:
:set equalalways # default: auto-equalize on split/close
:set noequalalways # don't auto-resizeDéplacer les fenêtres
Ctrl-w H/J/K/L déplacent la fenêtre courante aux bords extrêmes (majuscule = plein écran de ce côté). Ctrl-w r/R pivotent les fenêtres dans la disposition. Ctrl-w x échange avec la fenêtre suivante. Ctrl-w T déplace une fenêtre vers un nouvel onglet. Une astuce sympa : Ctrl-w K/H convertit aussi entre orientations horizontale et verticale.
Ctrl-w H # move current window to far LEFT (full height)
Ctrl-w J # move current window to BOTTOM (full width)
Ctrl-w K # move current window to TOP (full width)
Ctrl-w L # move current window to far RIGHT (full height)
Ctrl-w r # rotate windows DOWN/RIGHT
Ctrl-w R # rotate windows UP/LEFT
Ctrl-w x # exchange current window with next
Ctrl-w T # move current window to a NEW tab page
# Move split orientation:
Ctrl-w K # if vertical, become horizontal (and move to top)
Ctrl-w H # if horizontal, become vertical (and move to left)
# Example: convert a vertical split to horizontal:
:vsplit # creates vertical split
Ctrl-w H # moves it to the left, becoming horizontal
# Reopen current buffer in a new tab:
Ctrl-w T # current window moves to a new tabArranger les fenêtres
Ctrl-w = égalise les tailles de fenêtres. :ball ouvre une fenêtre par buffer — utile pour tout voir d'un coup. Ctrl-w r/R pivotent les fenêtres dans la disposition. Pour sauvegarder et restaurer une disposition complète de fenêtres (buffers, plis, etc.), utilisez :mksession et :source. Chaque onglet maintient sa propre disposition de fenêtres.
# Equalize window sizes:
Ctrl-w = # equalize height and width
# Stack layouts:
# Vertical splits side by side, horizontal splits stacked
# Example setup:
# :vsplit -> | win1 | win2 |
# :split -> | win1 | win3 |
# | | win2 |
# Cycle through layouts (with plugins like golden-ratio,
# or use built-in rotation):
Ctrl-w r # rotate down/right
Ctrl-w R # rotate up/left
# Distribute buffers across windows:
:ball # one window per buffer (horizontal)
:vertical ball # one window per buffer (vertical)
# Layouts persist within a tab page.
# Save current layout to a session:
:mksession mylayout.vim
# Restore:
:source mylayout.vim
# Tab page = a collection of windows
:tabnew # new tab with one windowFermer des fenêtres
:q ferme une fenêtre (et quitte Vim si c'est la dernière). :close (ou Ctrl-w c) ferme une fenêtre mais pas la toute dernière. :only (Ctrl-w o) ferme toutes les autres fenêtres. Avec 'hidden' réglé, fermer une fenêtre avec un buffer modifié le cache au lieu de forcer une décision de sauvegarde. :only! force la fermeture des autres même modifiés.
:q / :quit # close current window (errors if last)
:q! # close without saving
:wq # save and close
:close / Ctrl-w c # close window (won't close last)
:only / Ctrl-w o # close all OTHER windows
:hide # hide current buffer in window (close window)
# Save and close splits:
:xa # save all and exit (close all windows)
:wqa # same as :xa
# Closing a window with modified buffer:
# - :q prompts: "Save changes?"
# - :q! discards
# - :wq saves and closes
# - :hide (with 'hidden' set) keeps buffer in memory
# Close every window except the current:
:only # or Ctrl-w o
# Errors if other windows have unsaved changes:
:only! # force-close other windows
# When you close the last window, Vim exits.
# To prevent accidental exit:
:q! on last window still exits Vim.Onglets
Créer des onglets
:tabnew/:tabedit créent un nouvel onglet. vim -p fichier1 fichier2 ouvre chaque fichier dans son onglet au démarrage. Chaque onglet contient une ou plusieurs fenêtres — un onglet est une disposition, pas un seul fichier. Ctrl-w T déplace la fenêtre courante vers un nouvel onglet. Les onglets sont parfaits pour séparer des contextes de travail sans lien (ex. un onglet par zone de projet).
:tabnew # new tab with empty buffer
:tabedit file.txt # new tab opening file
:tab split # new tab with current buffer in a split
:tabfind file.txt # new tab, find file in 'path'
# Open multiple files in tabs at startup:
vim -p file1.txt file2.txt file3.txt
# From inside Vim, open files in tabs:
:args *.py | argdo tabe %
# Or one-by-one:
:tabe file1.txt
:tabe file2.txt
# Keyboard shortcut (common mapping):
:nmap <C-t> :tabnew<CR>
# Open current buffer in a new tab (move window):
# Ctrl-w T (move current window to a new tab page)
# Each tab page has its own window layout
# (multiple splits/windows per tab allowed)Naviguer entre onglets
gt/gT basculent d'onglet (mode Normal). Ngt saute directement à l'onglet N (indexé à partir de 1). :tabs liste tous les onglets et leurs fenêtres. Courant de mapper Ctrl-Tab/Ctrl-Shift-Tab ou <leader>1/2/3 pour une bascule rapide. Les onglets bouclent par défaut. Chaque onglet maintient sa propre disposition de fenêtres (splits, etc.).
:tabnext / :tabn # next tab
:tabprevious / :tabp # previous tab
:tabfirst / :tabr # first tab
:tablast / :tabl # last tab
gt # next tab (Normal mode)
gT # previous tab
3gt # go to tab 3
:tabn 3 # go to tab 3 (Ex command)
# Common mappings (Vim default):
:nmap <C-Tab> :tabnext<CR>
:nmap <C-S-Tab> :tabprevious<CR>
# Or use leader keys:
:nmap <leader>1 1gt
:nmap <leader>2 2gt
:nmap <leader>3 3gt
# Cycle behavior:
# gt at last tab wraps to first
# gT at first tab wraps to last
# To disable wrap:
:set tabpagemax=50 # max tabs (not wrap-related)
# Show all tabs:
:tabs # list tabs with their windowsOpérations sur les onglets
:tabc ferme l'onglet courant ; :tabo tous les autres. :tabm N déplace l'onglet courant à la position N (0 = premier). :tabdo exécute une commande Ex dans chaque onglet — utile pour les opérations globales à travers des espaces de travail séparés par onglets. Fermer un onglet ferme toutes ses fenêtres ; les buffers modifiés se préservent si 'hidden' est réglé.
:tabclose / :tabc # close current tab
:tabclose! / :tabc! # force close (discard changes)
:tabonly / :tabo # close all OTHER tabs
:tabonly! / :tabo! # force close others
# Reorder tabs:
:tabmove / :tabm 0 # move current tab to position 0 (first)
:tabm # move to last position
:tabm 2 # move to position 2
:tabm +1 # move right by 1
:tabm -1 # move left by 1
# Quick keyboard reordering (no default, common mapping):
:nmap <leader>tm :tabmove<Space>
# Run a command in every tab:
:tabdo cmd # run cmd in every tab page
# Example:
:tabdo %s/old/new/ge # substitute in every tab's first window
# Each tab can hold multiple windows/splits.
# 'Tabclose' closes all windows in the tab.Disposition des onglets et multi-fenêtres
Chaque onglet maintient une disposition de fenêtres indépendante (splits, tailles, positions). On peut avoir plusieurs fenêtres par onglet. Ctrl-w T déplace une fenêtre vers son propre nouvel onglet. :set showtabline=2 montre toujours la barre d'onglets. Les onglets servent au mieux de séparateurs d'espaces de travail (ex. un onglet par zone de projet), chacun avec sa disposition.
# Each tab page has its own window layout.
# Create a tab with a 3-window layout:
:tabnew # new tab
:vsplit # split vertically (2 windows)
:split # split horizontally (3 windows)
# Now tab has: [win1] [win2]
# [win3]
# Add a buffer to current tab:
:e file.txt # replaces current window's buffer
# Move a window to its own tab:
Ctrl-w T # window becomes a new tab page
# Show tab line (always):
:set showtabline=2 # 0=never, 1=multi-tab, 2=always
# Tab page-local options:
:setlocal ... # option applies only to current tab's windows
:tabdo setlocal ... # apply across all tabs
# Tab label customization (status line):
:set guitablabel=%t # show filename in GUI tab label
# Common use case: one tab per project area:
# Tab 1: source files
# Tab 2: tests
# Tab 3: docs
# Each with its own split layout.Options et étiquettes d'onglets
showtabline contrôle la barre d'onglets (0=jamais, 1=seulement avec plusieurs onglets, 2=toujours). On peut entièrement personnaliser la tabline avec une fonction retournant la chaîne de format — utile pour montrer le statut modifié, les noms de buffers, les numéros d'onglets. guitablabel/guitabtooltip personnalisent le Vim GUI. Les onglets se numérotent à partir de 1.
:set showtabline=2 # always show tab bar (0=never, 1=auto)
:set tabpagemax=50 # max tabs creatable
:set hidden # allow switching tabs with unsaved changes
# Custom tab labels (terminal Vim):
:set tabline=%!MyTabLine()
function! MyTabLine()
let s = ''
for i in range(tabpagenr('$'))
let n = i + 1
let s .= '%' . n . 'T'
let s .= (n == tabpagenr() ? '%#TabLineSel#' : '%#TabLine#')
let s .= ' [' . n . '] '
let buflist = tabpagebuflist(n)
let bufname = bufname(buflist[0])
let s .= empty(bufname) ? '[No Name]' : fnamemodify(bufname, ':t')
let s .= ' '
endfor
let s .= '%T%#TabLineFill#'
return s
endfunction
# GUI tab labels:
:set guitablabel=%t # show filename
:set guitabtooltip=%f # show full path on hover
# Quickly switch with number:
:nmap <leader>t :tabs<CR>Commandes de pages d'onglets
:tabs liste les onglets et leurs fenêtres. :tabdo exécute une commande Ex dans chaque onglet. :tab ball ouvre chaque buffer dans son propre onglet. <C-w>gf ouvre le fichier sous le curseur dans un nouvel onglet. Utilisez les onglets pour grouper les fichiers liés (un onglet par fonctionnalité/zone). Pour les opérations inter-onglets, :tabdo est le cheval de bataille — associez à windo pour les onglets multi-fenêtres.
:tabs # list all tabs and their windows
:tabdo cmd # run cmd in every tab
:tab ball # open each buffer in its own tab
:tab help subject # open help in a new tab
:tab split # split current window into new tab
# Quickly duplicate a tab's layout:
# (no built-in, but possible with sessions)
# Or manually: create a new tab, re-open buffers
# Open file under cursor in a new tab:
:nmap gf :tabe <cfile><CR>
# (or use the built-in <C-w>gf)
# Common workflow:
# 1. Group related files in tabs
# 2. Use gt/gT to switch
# 3. Use :tabdo for cross-tab operations
# Save all tabs' buffers:
:tabdo windo w # write every window in every tab
# (or simpler)
:wall # write all buffers (across all tabs)
# Close all tabs but keep buffers:
# (no single command — use :tabo + :b then :bd)Configuration (.vimrc)
Bases du vimrc
$MYVIMRC est le chemin de votre fichier vimrc — :edit $MYVIMRC l'ouvre, :source $MYVIMRC le recharge après édition. Le runtimepath contrôle où Vim cherche les fichiers de syntaxe, plugins, etc. Utilisez :verbose set option? pour voir où une option a été réglée en dernier — inestimable pour déboguer des plugins en conflit.
# vimrc location:
# Unix: ~/.vimrc (or ~/.vim/vimrc)
# Windows: ~/_vimrc (or ~/vimfiles/vimrc)
# Neovim: ~/.config/nvim/init.vim
# Reload vimrc after editing:
:source $MYVIMRC # or :so %
# Edit vimrc quickly:
:edit $MYVIMRC # $MYVIMRC = path to your vimrc
# Runtime path (where Vim looks for scripts):
:set runtimepath?
# Add a custom path:
:set runtimepath+=~/.vim/custom
# Conditional config (only in terminal Vim):
if !has('gui_running')
set mouse=a
endif
# Per-filetype settings (in vimrc or ftplugin/):
:autocmd FileType python setlocal expandtab shiftwidth=4
# Check where an option was set:
:verbose set tabstop?Réglages de base
Ce sont des réglages de confort courants. relativenumber + number affiche la numérotation hybride — numéros de lignes relatifs au curseur pour des sauts faciles, avec l'absolu sur la ligne courante. showmatch fait clignoter les crochets correspondants. wildmenu améliore la complétion des :commandes avec un menu. scrolloff garde le contexte visible autour du curseur — n'éditez jamais au bord de l'écran.
set nocompatible # Vim mode (not Vi)
set number # show line numbers
set relativenumber # relative line numbers (great for jumps)
set cursorline # highlight current line
set cursorcolumn # highlight current column
set showcmd # show partial commands in status
set showmode # show current mode (insert, visual...)
set showmatch # highlight matching brackets
set wildmenu # better command-line completion
set wildmode=longest:full,full # completion style
set laststatus=2 # always show status line
set ruler # show cursor position
set backspace=indent,eol,start # backspace through everything
set encoding=utf-8 # default encoding
set scrolloff=5 # keep 5 lines above/below cursor
set sidescrolloff=5 # keep 5 cols left/right of cursor
set mouse=a # enable mouse (all modes)Indentation
tabstop contrôle combien de colonnes un caractère de tabulation affiche. shiftwidth est la quantité d'indentation utilisée par <<, >> et autoindent. softtabstop fait que Backspace retire le bon nombre de colonnes même quand expandtab est désactivé. expandtab convertit les tabulations en espaces — recommandé pour la cohérence. :retab convertit les tabulations/espaces existants après changement des réglages.
set autoindent # copy indent from previous line
set smartindent # smart auto-indent for code (basic)
set cindent # C-style indenting (more language-aware)
set expandtab # use spaces instead of tabs
set tabstop=4 # tab key inserts 4-column tabs visually
set shiftwidth=4 # indent/outdent amount (<<, >>, autoindent)
set softtabstop=4 # backspace removes 4 cols even with tabs
set shiftround # round indent to multiple of shiftwidth
set smarttab # tab key respects shiftwidth at line start
# Toggle tabs vs spaces:
:set expandtab! # toggle
:retab # convert existing tabs<->spaces
# Filetype-specific indent:
:filetype plugin indent on
# Then in ~/.vim/ftplugin/python.vim:
# setlocal expandtab shiftwidth=4
# Quick indent/dedent in Normal mode:
>> # indent current line
<< # dedent current line
5>> # indent 5 linesRéglages de recherche
ignorecase + smartcase est la combinaison recommandée : insensible à la casse sauf si votre motif a une majuscule. hlsearch surligne toutes les correspondances ; incsearch montre les correspondances incrémentalement à la frappe. Mapping courant : <leader>h bascule hlsearch, ou :noh efface la surbrillance courante. Vim 8.2+ peut montrer le compte de recherche via shortmess.
set ignorecase # case-insensitive search
set smartcase # case-sensitive if pattern has uppercase
set hlsearch # highlight all matches (hls)
set incsearch # show match as you type (is)
set wrapscan # wrap search around end of file (ws)
# Toggle search highlight:
:nmap <leader>h :set hlsearch!<CR>
# Or clear current highlight:
:nmap <leader>nh :nohlsearch<CR>
# Show search count (Vim 8.2+):
:set shortmess-=S
:set shortmess+=S # search stats in command line
# Search in visual selection:
:vmap * y/\V<C-R>"<CR>
# Use very-magic mode by default (advanced):
# No built-in, but a search mapping can prepend \v
# Improved '*' (don't jump on first press):
:nmap * *N
# Disable highlighting until next search:
:nohlsearchRéglages d'affichage
wrap + linebreak replient les longues lignes aux frontières de mots (pas au milieu d'un mot) pour la lisibilité. list + listchars révèlent tabulations, espaces finaux et espaces insécables. colorcolumn marque une colonne (ex. 80 pour les limites de longueur de ligne). termguicolors active la vraie couleur 24 bits dans les terminaux modernes. splitright/splitbelow contrôlent où apparaissent les nouveaux splits.
set wrap # wrap long lines
set linebreak # wrap at word boundaries (not mid-word)
set textwidth=80 # auto-wrap at 80 chars when typing
set showbreak=+++ # marker for wrapped lines
set list # show invisible chars
set listchars=tab:>-,trail:.,extends:>,precedes:<
set fillchars=fold:-,vert:\| # chars for folds/vsplits
set colorcolumn=80 # highlight column 80
set signcolumn=yes # always show sign column (LSP)
set conceallevel=0 # don't conceal chars
set splitright # new vsplit on the right
set splitbelow # new split below
set termguicolors # 24-bit color (if terminal supports)
set background=dark # or 'light' — adjusts color scheme
# Color scheme:
:colorscheme desert
# Or with a plugin (e.g. vim-colors-solarized):
:colorscheme solarizedMapper les touches
Utilisez TOUJOURS les variantes *noremap (nnoremap, vnoremap, etc.) pour vos mappings personnels — ils ne récursent pas, évitant les comportements inattendus. <leader> est une touche de préfixe personnalisable (défaut antislash ; beaucoup la règlent sur virgule ou espace). <CR> est Entrée, <Esc> l'échappement, <C-x> Ctrl-X. Mappez des raccourcis leader pour les commandes courantes comme sauvegarder/quitter.
# Map families:
:map # normal, visual, select, operator-pending
:nmap # normal mode only
:imap # insert mode only
:vmap # visual + select mode
:xmap # visual mode only
:smap # select mode only
:omap # operator-pending mode only
:cmap # command-line mode only
:tmap # terminal mode only
# Non-recursive (RECOMMENDED):
:nnoremap # normal mode, non-recursive
:vnoremap # visual mode, non-recursive
:inoremap # insert mode, non-recursive
:cnoremap # command-line mode, non-recursive
# Examples:
nnoremap <leader>w :w<CR> # save with leader-w
nnoremap <leader>q :q<CR> # quit
inoremap jk <Esc> # Esc with jk
nnoremap <C-h> <C-w>h # window nav
# Leader key (default is \):
:let mapleader = ','
:let maplocalleader = '\\'
# Special keys:
# <CR> <Esc> <Tab> <Space> <C-x> <A-x> <M-x> <F1>-<F12>
# <Up> <Down> <Left> <Right> <leader> <localleader>Plugins (vim-plug)
Bases de vim-plug
vim-plug est le gestionnaire de plugins moderne le plus populaire. Déclarez les plugins entre call plug#begin et plug#end. Chaque ligne Plug spécifie un repo GitHub (utilisateur/repo). Après ajout des plugins, :source $MYVIMRC puis :PlugInstall les télécharge. On peut épingler à un tag, une branche ou un commit pour la stabilité. Les plugins s'installent dans le répertoire 'plugged'.
# Installation (Unix):
# curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
# https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
# In vimrc:
call plug#begin('~/.vim/plugged')
Plug 'junegunn/fzf.vim' " GitHub repo: user/repo
Plug 'tpope/vim-surround' " another plugin
Plug 'morhetz/gruvbox' " colorscheme
Plug 'preservim/nerdtree' " file explorer
call plug#end()
# After editing vimrc:
:source $MYVIMRC # or restart Vim
:PlugInstall # install all declared plugins
# Plugin directory structure:
# ~/.vim/plugged/<plugin-name>/
# Pin to a specific commit/tag/branch:
Plug 'tpope/vim-fugitive', { 'tag': 'v3.0' }
Plug 'user/repo', { 'branch': 'dev' }
Plug 'user/repo', { 'commit': 'abc123' }Commandes de gestion des plugins
:PlugInstall installe les nouveaux plugins, :PlugUpdate met tout à jour, :PlugClean retire les non listés, :PlugStatus montre leur état. Le hook 'do' exécute une commande après installation — utile pour les plugins nécessitant une build ou l'installation de binaires. Les options 'on'/'for' activent le chargement paresseux (charger seulement quand une commande/filetype le déclenche) — améliore le temps de démarrage.
:PlugInstall # install newly added plugins
:PlugUpdate # update all plugins
:PlugClean # remove plugins no longer in vimrc
:PlugStatus # show plugin status (loaded, errored)
:PlugUpgrade # update vim-plug itself
:PlugDiff # review changes from last update
:PlugSnapshot # generate a snapshot of plugin versions
# Post-install hooks:
Plug 'user/repo', { 'do': ':GoInstallBinaries' }
Plug 'user/repo', { 'do': './install.sh' }
Plug 'user/repo', { 'do': 'npm install' }
# Lazy loading (load only when needed):
Plug 'user/repo', { 'on': 'CommandName' } " on command
Plug 'user/repo', { 'for': 'python' } " for filetype
Plug 'user/repo', { 'on': ['Cmd1', 'Cmd2'] }
# Frozen plugin (don't update):
Plug 'user/repo', { 'frozen': 1 }
# Disable a plugin temporarily:
# (no built-in, but comment out the Plug line and :PlugClean)Plugins essentiels courants
Essentiels courants : fzf pour la recherche floue de fichiers/buffers/texte (bien plus rapide que :find), vim-surround pour éditer guillemets/crochets/tags autour du texte, vim-fugitive pour l'intégration Git, vim-commentary pour commenter vite (opérateur gc), NERDTree pour un explorateur de fichiers latéral, vim-airline pour une ligne de statut plus jolie, et un bon colorscheme comme gruvbox.
" Fuzzy finder (requires fzf binary):
Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
Plug 'junegunn/fzf.vim'
" :Files :GFiles :Buffers :Rg
" Surround (cs/ds/ys for surroundings):
Plug 'tpope/vim-surround'
" cs"' change " to '
" ds" delete surrounding "
" ysiw) surround word with ()
" Fugitive (Git integration):
Plug 'tpope/vim-fugitive'
" :G :Gstatus :Gcommit :Gpush
" Commentary (gc to toggle comments):
Plug 'tpope/vim-commentary'
" gcc comment line
" gc{motion} comment motion
" NERDTree (file explorer sidebar):
Plug 'preservim/nerdtree'
" :NERDTree :NERDTreeToggle
" Airline (status line):
Plug 'vim-airline/vim-airline'
" Gruvbox (colorscheme):
Plug 'morhetz/gruvbox'Configuration des plugins
Utilisez 'on'/'for' pour charger les plugins paresseusement — ils ne se chargent qu'au déclenchement, améliorant le démarrage. La config spécifique aux plugins utilise typiquement des variables g:nomplugin_var réglées dans le vimrc, OU des fichiers dans ~/.vim/after/plugin/. Le hook 'do' tourne après install/update pour les étapes de build. Régler g:loaded_nomplugin=1 dans le vimrc empêche un plugin de se charger du tout.
" Lazy load on command:
Plug 'tpope/vim-fugitive', { 'on': 'Git' }
" Lazy load on filetype:
Plug 'fatih/vim-go', { 'for': 'go' }
" Multiple triggers:
Plug 'junegunn/fzf.vim', { 'on': ['Files', 'Buffers', 'Rg'] }
" Post-install hook:
Plug 'dense-analysis/ale', { 'do': 'npm install' }
" Configuration AFTER plugin loads:
Plug 'preservim/nerdtree'
let g:NERDTreeShowHidden = 1
let g:NERDTreeWinSize = 30
nmap <leader>n :NERDTreeToggle<CR>
" Configuration in AFTER/plugin-name.vim:
" (alternative to setting g: vars in vimrc)
" ~/.vim/after/plugin/nerdtree.vim:
" let g:NERDTreeShowHidden = 1
" Disable plugin entirely:
let g:loaded_nerdtree = 1 " prevent loadingChargement des plugins et runtime
Vim source les fichiers plugin/*.vim au démarrage dans l'ordre des répertoires, puis after/plugin/*.vim en dernier (pour les surcharges). :scriptnames liste tout ce qui a été sourcé — inestimable pour déboguer. :verbose map <touche> montre où un mapping a été défini ; :verbose set option? pareil pour les options. Les fichiers autoload/ se chargent paresseusement quand leurs fonctions sont appelées la première fois.
" Plugin loading sequence:
" 1. Vim starts, reads vimrc
" 2. plug#begin / plug#end registers plugins
" 3. Runtime path is updated to include plugin dirs
" 4. plugin/*.vim files are sourced (in directory order)
" 5. after/plugin/*.vim files are sourced last
" Check if a plugin is loaded:
:echo exists('g:loaded_fugitive')
:scriptnames # list all sourced scripts in order
" Manually source a plugin:
:source ~/.vim/plugged/foo/plugin/foo.vim
" Find where a mapping was defined:
:verbose map <leader>w
" Find where an option was set:
:verbose set formatprg?
" Plugin runtime files:
" plugin/ - loaded at startup
" ftplugin/ - loaded for specific filetypes
" syntax/ - syntax highlighting
" indent/ - indentation rules
" autoload/ - lazily-loaded functions
" after/ - sourced last (overrides)
" Helptags for plugin docs:
:Helptags (vim-plug generates these on install)Autres gestionnaires de plugins
Au-delà de vim-plug : Vundle (API similaire, moins riche), Pathogen (le plus simple — ajoute juste des répertoires bundle au runtimepath), Dein.vim (rapide, axé chargement paresseux), et les packages intégrés de Vim 8+ (pas besoin de gestionnaire — déposez les plugins dans pack/<nom>/start/). Pour les utilisateurs Neovim, Packer (basé Lua) est populaire. Les packages intégrés sont parfaits pour les minimalistes.
" 1. Vundle (older, similar to vim-plug):
" set rtp+=~/.vim/bundle/Vundle.vim
" call vundle#begin()
" Plugin 'tpope/vim-surround'
" call vundle#end()
" 2. Pathogen (just adds dirs to runtimepath):
" Execute:
" git clone https://github.com/tpope/vim-pathogen ~/.vim/bundle
" In vimrc:
" execute pathogen#infect()
" Then clone plugins into ~/.vim/bundle/
" 3. Dein.vim (modern, lazy-loading focused):
" set runtimepath+=~/.cache/dein/repos/github.com/Shougo/dein.vim
" if dein#load_state('~/.cache/dein')
" call dein#begin('~/.cache/dein')
" call dein#add('tpope/vim-surround')
" call dein#end()
" call dein#save_state()
" endif
" 4. Vim 8+ built-in packages (NO plugin manager needed):
" Place plugins in:
" ~/.vim/pack/<name>/start/<plugin>/ " loaded at startup
" ~/.vim/pack/<name>/opt/<plugin>/ " loaded on demand
" Load an opt plugin: :packadd <plugin>
" 5. Packer (Neovim Lua):
" require('packer').startup(function()
" use 'tpope/vim-surround'
" end)Mouvement avancé
Recherche de caractères (f/F/t/T)
f/F trouvent le caractère suivant/précédent sur la ligne courante (le curseur atterrit dessus) ; t/T se déplacent jusqu'avant/après. ; répète le dernier f/F/t/T dans le même sens, , dans le sens opposé. Combinez aux opérateurs : dt, supprime jusqu'à (sans inclure) la virgule suivante, df. jusqu'à la période suivante. Rapide et précis pour la navigation en ligne.
f{x} # find next char 'x' on line (cursor ON x)
F{x} # find previous char 'x' (cursor ON x)
t{x} # till next char 'x' (cursor BEFORE x)
T{x} # till previous char 'x' (cursor AFTER x)
; # repeat last f/F/t/T (same direction)
, # repeat last f/F/t/T (opposite direction)
# Examples (cursor on 'a' in "hello world abc"):
# fw -> cursor on 'w' (world)
# tw -> cursor on space before 'w'
# Fo -> cursor on 'o' (hello) - backwards
# ; -> next 'w'... or next match of last
# Combined with operators:
dt, # delete up to (not including) next ','
df. # delete up to AND including next '.'
ct; # change up to next ';'
yt: # yank up to next ':'
# Find on a long line (no built-in multi-line f):
# Use :s or search for multi-line patterns.
# Set 'hlsearch' to highlight f/F/t/T targets:
:set hlsearch " doesn't highlight f, but / does.Mouvement par phrases et paragraphes
( et ) se déplacent par phrase (les phrases finissent par . ! ? plus un espace) ; { et } par paragraphe (séparés par lignes vides). Pour les lignes repliées, gj/gk/g0/g$ opèrent sur les lignes d'écran visuelles tandis que j/k/0/$ opèrent sur les lignes logiques — essentiel quand 'wrap' est actif. Combinez ( ) { } aux opérateurs : das supprime une phrase, yap copie un paragraphe.
( # previous sentence start
) # next sentence start
{ # previous paragraph start (blank-line delimited)
} # next paragraph start
# Sentence boundaries: ends with . ! ? followed by
# whitespace or end of paragraph.
# Paragraph: block of lines separated by blank lines.
# Examples:
# Hello world. This is a sentence.
# ^ ^ ^
# ( ) ( moves to sentence starts
# Combine with operators:
das # delete a sentence
cis # change inside sentence
yap # yank a paragraph
dip # delete inside paragraph
# Move by visual line (with 'wrap' on):
gj # down one screen line (wrap-aware)
gk # up one screen line
g0 # start of screen line
g$ # end of screen line
g_ # last non-blank of screen line
# These respect wrapping where j/k don't.Apparier les paires (%)
% saute entre crochets correspondants (défaut : (), [], {}). Ça marche aussi sur #if/#endif et /* */ si 'matchpairs' est réglé appropriément. Combinez aux opérateurs : d% supprime du curseur jusqu'à la correspondance, v% la sélectionne. [( [{ ]) ]} sautent aux crochets non appariés — utile pour trouver le bloc de fonction/classe englobant.
% # jump to matching bracket: ( ) [ ] { }
# also works on #if/#endif, /* */ with matching pairs
# In Normal mode:
% # if cursor on (, jumps to matching )
% # if cursor on ), jumps to matching (
# Combine with operators:
d% # delete from cursor to matching bracket
c% # change from cursor to matching bracket
y% # yank from cursor to matching bracket
v% # visually select from cursor to matching bracket
# Extend matching to other pairs:
:set matchpairs+=<:>
:set matchpairs+=«:»
# Default: (:),[:],{:}
# Move to enclosing bracket:
# [( # back to unmatched (
# ]) # forward to unmatched )
# [{ # back to unmatched {
# ]} # forward to unmatched }
# [} / ]{ similar for braces
# Example: jump to outer function's opening brace:
[{ " previous unmatched {Mouvement d'écran
H/M/L sautent au haut/milieu/bas de l'écran visible. Ctrl-f/b défilent des pages pleines ; Ctrl-d/u des demi-pages (moins désorientant) ; Ctrl-e/y d'une ligne sans déplacer le curseur. zz/zt/zb repositionnent la ligne du curseur au milieu/haut/bas de l'écran — essentiel pour garder le contexte. 'scrolloff' garantit que le curseur n'atteint jamais le bord de l'écran.
H # top of screen (High) — first non-blank
M # middle of screen
L # bottom of screen (Low) — first non-blank
N H # Nth line from top (e.g. 5H = 5 lines from top)
N L # Nth line from bottom
# Scrolling:
Ctrl-f # forward (down) full screen
Ctrl-b # backward (up) full screen
Ctrl-d # down half screen
Ctrl-u # up half screen
Ctrl-e # scroll down 1 line (cursor stays)
Ctrl-y # scroll up 1 line (cursor stays)
# Reposition cursor on screen:
zz # cursor line to middle of screen
zt # cursor line to top of screen
zb # cursor line to bottom of screen
z. # cursor to middle, first non-blank
z+ # cursor to bottom, scroll up (like zb but accepts count)
# Keep cursor off edges:
:set scrolloff=5 # always 5 lines above/below cursor
:set sidescrolloff=5 # 5 cols left/right of cursorScrollbind et synchronisation
:set scrollbind synchronise le défilement entre fenêtres — réglez-le dans chaque fenêtre à synchroniser. :vimdiff ouvre deux fichiers en mode diff avec scrollbind activé, les différences surlignées en syntaxe, et [c/]c pour naviguer les hunks. do (diff obtain) tire les changements de l'autre fenêtre, dp (diff put) les pousse. Génial pour comparer des versions d'un fichier.
# Bind windows to scroll together:
:set scrollbind # current window syncs scroll
:set syncbind # force immediate sync
:scrollbind # same as :set scrollbind
# In each window you want synced:
# :set scrollbind
# Unbind:
:set noscrollbind
# Common use: diff two files side by side
:vimdiff file1 file2 # opens both, scrollbound, diff highlighted
:diffthis # mark current window as a diff
:diffoff # turn off diff mode for current window
:diffupdate # refresh diff highlighting
# Vertical diff split:
:vert diffsplit file2.txt
# In diff mode:
[c # previous diff hunk
]c # next diff hunk
do # diff obtain (pull from other window)
dp # diff put (push to other window)
# Bind but at different starting positions:
# Set scrollbind AFTER scrolling to desired positions.Aller à des positions
Beaucoup de façons de positionner le curseur : :N pour la ligne N, N % pour le pourcentage, `.`/`"`/[`]/`</`> pour les marques spéciales (dernier changement, dernière sortie, dernier yank, dernière sélection visuelle). Ctrl-o/Ctrl-i naviguent la liste de sauts. `" restaure la position à la dernière fermeture du fichier — combiné à un réglage viminfo, cela persiste entre sessions.
:N # go to line N (e.g. :42)
Ng / N G # go to line N (e.g. 42G or 42gg)
gg # first line
G # last line
N% # go to N% of file (e.g. 50% = middle)
:-N # N lines before current (e.g. :-5)
:+N # N lines after current (e.g. :+10)
# Marks and jumps:
\`. # position of last change in this buffer
\`" # position when file was last closed
\`[ # start of last yanked/changed region
\`] # end of last yanked/changed region
\`< # start of last visual selection
\`> # end of last visual selection
\`^ # last insert position (gi goes here + insert)
# Recent jumps:
Ctrl-o # back in jumplist
Ctrl-i # forward in jumplist
\`' # position before last jump (where you came from)
# File position on save:
:set viminfo^=% # remember buffer positions across sessions
# Cursor hold (no movement for 'updatetime' ms):
# CursorHold event triggers (advanced)Mode ligne de commande
Commandes par plages
Les plages spécifient quelles lignes une commande affecte. :% est tout le fichier (1,$). . est la ligne courante, $ la dernière. '<,'> est la dernière sélection visuelle (auto-rempli quand on appuie : en visuel). 'a,'b va de la marque a à la marque b. On peut aussi utiliser des motifs de recherche comme frontières de plage : :/foo/,/bar/d supprime de la ligne matchant foo à celle matchant bar.
# Range syntax: :{start},{end}command
# Range forms:
:% # whole file (1,$)
:1,10 # lines 1-10
:.,$ # current line to end of file
:1,. # first line to current
:'a,'b # from mark a to mark b
:'<,'> # last visual selection
:. # current line only
:N # line N only
:.,+5 # current line + 5 below
:.,-2 # current line - 2 above
# Examples:
:1,10d # delete lines 1-10
:%s/old/new/g # substitute whole file
:'<,'>s/old/new/g # substitute visual selection
:.,$j # join from current to end into one line
:5,10y a # yank lines 5-10 into register a
:g/pattern/m$ # move matching lines to end of file
# Search-based range:
:/start/,/end/d # delete from 'start' to 'end' patternsCommandes de fichiers
:w sauvegarde, :e ouvre un nouveau fichier, :r insère le contenu d'un autre fichier (ou la sortie d'une commande shell via :r !cmd). :saveas sauvegarde et bascule vers le nouveau fichier. :e! recharge le fichier en jetant les changements. ++enc/++ff spécifient encodage/fins de ligne explicitement — utile pour convertir des fichiers. :browse e ouvre un dialogue de fichiers GUI (dans le Vim GUI).
:w / :write # save current file
:w file.txt # save as new file
:w! file.txt # overwrite existing file
:w >> file.txt # append to file
:saveas / :sav file # save as new file and switch to it
:e / :edit file # open file (replace current buffer)
:e! # reload current file (discard changes)
:e # # edit alternate file
:r / :read file # insert file below cursor
:r !command # insert command output below cursor
:0r !date # insert date at top of file
# Multiple files:
:wa / :wall # write all buffers
:xa / :xall # write all and quit
:qa! # quit all without saving
# Browse file system:
:browse e # GUI file open dialog
:Explore # Netrw file browser
# File encoding:
:w ++enc=utf-8 # save as UTF-8
:e ++enc=latin1 file # open with specific encoding
# File format (line endings):
:w ++ff=unix # save as Unix line endingsCommandes de buffers et fenêtres
Toutes les opérations multi-buffers/fenêtres/onglets ont des formes en commande Ex. :b bascule les buffers, :sp/:vs scindent les fenêtres, :tabnew crée des onglets. La famille :*do (bufdo, argdo, tabdo, windo, cdo) exécute une commande sur beaucoup de cibles — extrêmement puissant pour les opérations en lot. :ls montre les buffers ; :tabs les onglets ; :args l'arglist.
# Buffer commands:
:b N / :buffer N # switch to buffer N
:b name # switch by name (tab-completes)
:bd / :bdelete # delete buffer
:bw / :bwipeout # wipe buffer (clears marks)
:ls / :buffers # list buffers
:bn / :bp # next / previous buffer
:b# # alternate buffer
# Window commands:
:sp / :split # horizontal split
:vs / :vsplit # vertical split
:new # split with empty buffer
:close # close window
:only # close all other windows
:qa / :qa! # quit all windows
# Tab page commands:
:tabnew # new tab
:tabe file # new tab with file
:tabc # close tab
:tabo # close other tabs
:tabs # list tabs
:tabn / :tabp # next / previous tab
# Argument list commands:
:args # show arg list
:n / :next # next arg file
:prev # previous arg file
:argdo cmd # run cmd on each arg fileRégler les options
:set bascule les options booléennes avec !, règle les valeurs avec =, ajoute/retire avec +=/-=, et réinitialise aux défauts avec &. :set option? montre la valeur courante. :setlocal règle une valeur locale au buffer/fenêtre (n'affecte pas les autres buffers). :set sans arguments liste toutes les options changées ; :set all montre tout. Tab complète les noms d'options.
:set option # turn boolean option on
:set nooption # turn boolean option off
:set option! # toggle boolean
:set option? # show current value
:set option=value # set value
:set option+=value # append to value
:set option-=value # remove from value
:set option& # reset to default
:set all # show all options
:set # show changed options
# Local vs global:
:setlocal option # buffer/window-local only
:setglobal option # global value
# Examples:
:set number # show line numbers
:set nonumber # hide line numbers
:set number! # toggle
:set tabstop=4 # set tabstop to 4
:set formatoptions+=r # add 'r' to formatoptions
:set ignorecase& # reset ignorecase to default
# View all set options:
:set # shows only non-default values
# Find option with substring:
:set ic<tab> # tab-complete (ignorecase)Commandes de mapping
Utilisez les variantes *noremap pour vos mappings personnels — ils ne récursent pas, prévenant les comportements inattendus. <leader> est un préfixe personnalisable (défaut antislash ; beaucoup le règlent sur espace ou virgule). <buffer> rend un mapping local au buffer courant. Les touches spéciales utilisent la <notation> comme <CR>, <Esc>, <C-x> (Ctrl-X), <A-x> (Alt-X).
:map <key> <action> # generic map (most modes)
:nmap <key> <action> # normal mode
:imap <key> <action> # insert mode
:vmap <key> <action> # visual mode
:xmap <key> <action> # visual mode only
:smap <key> <action> # select mode
:omap <key> <action> # operator-pending mode
:cmap <key> <action> # command-line mode
:tmap <key> <action> # terminal mode
# Non-recursive (RECOMMENDED for personal mappings):
:nnoremap <key> <action> # normal mode
:vnoremap <key> <action> # visual mode
:inoremap <key> <action> # insert mode
:onoremap <key> <action> # operator-pending
:cnoremap <key> <action> # command-line
:tnoremap <key> <action> # terminal
# Buffer-local mappings:
:nnoremap <buffer> <key> <action>
# Clear a mapping:
:nunmap <key> # or :nmapclear (clears all normal maps)
# Special keys in mappings:
# <CR> <Esc> <Tab> <Space> <BS> <C-x> <A-x> <M-x>
# <F1>-<F12> <Up> <Down> <Left> <Right>
# <leader> <localleader> <C-r> <C-w>
:let mapleader = ' '
:let maplocalleader = '\\'Commandes Ex utiles
:!cmd exécute une commande shell ; :r !cmd insère sa sortie dans le buffer. :sort trie les lignes (u=unique, n=numérique, !=inverse). :retab convertit entre tabulations et espaces. :normal exécute des touches normal-mode comme Ex — ajoutez ! pour ignorer les mappings custom. :%!cmd pipe tout le fichier à travers une commande externe et le remplace par la sortie.
:!command # run shell command
:r !command # insert command output below cursor
:!! # repeat last :! command
:sh # open a shell (exit to return)
:terminal / :term # open terminal in a window
:read file # insert file contents below cursor
:sort # sort selected lines (visual mode)
:sort u # sort and remove duplicates
:sort n # numeric sort
:sort! # reverse sort
:retab # convert tabs to spaces (and vice versa)
:retab! # also convert in strings
:normal {cmds} # run normal-mode commands
:normal! {cmds} # ignore mappings (use raw keys)
# Execute Ex commands from a register:
:@a # run Ex commands in register 'a'
:@@ # repeat last :@
# Range + command examples:
:5,20s/old/new/g # substitute in lines 5-20
:%!sort # pipe whole file through sort
:'<,'>!column -t # format visual selection as columns
# Help:
:help :command # help on a specific commandBases du Vimscript
Variables
Vimscript utilise let pour l'affectation et unlet pour supprimer. Les variables ont des portées indiquées par préfixes : g: (global), b: (buffer), w: (fenêtre), t: (onglet), s: (script), l: (local à la fonction), v: (intégré). const crée des valeurs immuables (Vim 8+). exists() vérifie si une variable est définie. Vim 8.2+ supporte l'interpolation de chaînes avec $"...{expr}...".
let var = value # assignment
let var = "hello" # string
let var = 42 # number
let var = 3.14 # float
let var = [1, 2, 3] # list
let var = {"key": "val"} # dictionary
unlet var # delete a variable
# Variable scopes (prefix with letter + colon):
let g:global_var = 1 # global (everywhere)
let b:buffer_var = 1 # buffer-local
let w:window_var = 1 # window-local
let t:tab_var = 1 # tab-local
let s:script_var = 1 # script-local (this file only)
let l:local_var = 1 # function-local
let v:count # built-in Vim variable
# Constants (Vim 8+):
const PI = 3.14159
let g:CONFIG = #{name: "vim"} # locked dictionary
# Check if a variable exists:
if exists('var')
if exists('g:plugin_var')
# String interpolation (Vim 8.2+):
let name = "World"
echo $"Hello, {name}!"Fonctions
function! Nom(args) ... endfunction définit une fonction — le ! permet la redéfinition. a: accède aux arguments ; a:000 est la liste des arguments variadiques. Les arguments par défaut (Vim 8+) utilisent =valeur. Les lambdas (Vim 8+) sont {args -> expr}. function('Nom') retourne une funcref transmissible. Utilisez :call pour invoquer une fonction pour ses effets de bord.
# Define a function:
function! MyFunc(arg1, arg2)
echo a:arg1 . ' ' . a:arg2
return a:arg1 + a:arg2
endfunction
# The ! in function! overrides an existing function
# (without ! Vim errors if function already exists).
# Call a function:
call MyFunc("hello", "world")
let result = MyFunc(1, 2)
# Variadic arguments (...):
function! Sum(...)
let total = 0
for i in a:000
let total += i
endfor
return total
endfunction
# Default arguments (Vim 8+):
function! Greet(name, greeting="Hello")
echo a:greeting . ', ' . a:name
endfunction
# Lambda / anonymous functions (Vim 8+):
let Square = {x -> x * x}
echo Square(5) " 25
# Function as a value:
let Fn = function('MyFunc')
echo Fn(1, 2)Conditionnels et boucles
if/elseif/else/endif pour les conditionnels. for boucle sur une liste (range(N) génère 0..N-1), et peut déballer des paires [clé, val] depuis items(). while/endwhile pour les boucles conditionnelles. break/continue marchent comme attendu. Vérifications de condition courantes : has() pour les fonctionnalités, exists() pour les variables/commandes, filereadable() pour les fichiers, empty() pour les valeurs vides, type() pour comparer des types.
# Conditionals:
if x > 10
echo "big"
elseif x > 5
echo "medium"
else
echo "small"
endif
# Ternary:
let result = (x > 0) ? "positive" : "non-positive"
# Loops:
for i in range(5) # 0,1,2,3,4
echo i
endfor
for [key, val] in items({'a': 1, 'b': 2})
echo key . '=' . val
endfor
while x > 0
let x -= 1
endwhile
# Loop control:
break # exit loop
continue # skip to next iteration
# Match-related conditionals:
if has('python3') # feature check
if exists(':Command') # command exists
if filereadable('file') # file is readable
if empty(var) # variable is empty
if type(var) == type([]) # type checkChaînes
. concatène les chaînes. Vim 8.2+ ajoute l'interpolation $"...{expr}...". len/strlen donnent la longueur en octets ; strcharlen le compte de caractères (important pour le multioctet). split/join convertissent entre chaînes et listes. substitute() est la commande :s programmatique. matchstr() extrait une correspondance regex. =~ est l'opérateur de matching regex.
# String concatenation:
let s = "Hello" . " " . "World"
# String interpolation (Vim 8.2+):
let name = "Vim"
echo $"Welcome to {name}!"
# Common functions:
len("hello") # 5
strlen("hello") # 5 (byte length)
strcharlen("hello") # 5 (char length)
tolower("HELLO") # "hello"
toupper("hello") # "HELLO"
strpart("hello", 1, 3) # "ell" (substring)
matchstr("foo123bar", '\d\+') # "123"
substitute("foo", 'o', '0', 'g') # "f00"
split("a,b,c", ',') # ['a', 'b', 'c']
join(['a', 'b', 'c'], '-') # "a-b-c"
trim(" hello ") # "hello"
# printf-style formatting:
printf("%d + %d = %d", 1, 2, 3) # "1 + 2 = 3"
printf("%05.2f", 3.14159) # "03.14"
# Regex matching:
if "hello" =~ '^h'
echo "starts with h"
endifListes et dictionnaires
Les listes sont ordonnées (comme des tableaux) ; les dictionnaires des maps clé-valeur. Le slicing de liste utilise [début:fin]. add/insert/remove modifient les listes en place. sort/reverse mutent aussi. Pour les dicts, l'accès .clé et ["clé"] marchent tous deux ; keys()/values()/items() retournent des listes. has_key() vérifie l'appartenance. #{...} (Vim 8+) est un littéral de dict plus propre qui n'exige pas de quoter les clés.
# Lists (like arrays):
let nums = [1, 2, 3, 4, 5]
echo nums[0] # 1 (first)
echo nums[-1] # 5 (last)
echo nums[1:3] # [2, 3, 4] (slice)
# List operations:
call add(nums, 6) # append 6
call insert(nums, 0, 0) # insert 0 at index 0
call remove(nums, 0) # remove index 0
echo len(nums) # length
call sort(nums) # sort in place
call reverse(nums) # reverse in place
call extend(nums, [7, 8]) # concatenate
# Iterate:
for n in nums
echo n
endfor
# Dictionaries (like hash maps / objects):
let d = {"name": "Vim", "version": 9}
echo d.name # "Vim"
echo d["version"] # 9
let d.lang = "Vimscript" # add a key
call remove(d, "version") # remove a key
echo keys(d) # ['name', 'lang']
echo values(d) # ['Vim', 'Vimscript']
echo items(d) # [['name', 'Vim'], ['lang', 'Vimscript']]
echo has_key(d, "name") # 1 (true)
# Dictionary literal (Vim 8+, cleaner):
let d2 = #{key: "value", count: 42}Autocmds et commandes custom
autocmd exécute du code sur des événements Vim (BufRead, BufWritePre, FileType, VimEnter, CursorMoved, etc.). Enveloppez toujours les autocmds dans un augroup avec autocmd! pour effacer les vieilles définitions au rechargement — prévient les duplications. Les commandes custom utilisent :command! -nargs=N -range -bang Nom action. <args>, <line1>, <line2>, <bang> accèdent à la saisie de l'utilisateur dans la définition de commande.
# Autocmds: run code on events
:autocmd BufWritePre *.md :%s/\s\+$//e " trim trailing whitespace
# Group autocmds (recommended - prevents duplicates on reload):
augroup markdown_settings
autocmd!
autocmd BufRead,BufNewFile *.md setlocal spell
autocmd FileType markdown setlocal textwidth=80
autocmd BufWritePre *.md :%s/\s\+$//e
augroup END
# Common events:
# BufReadPost - after loading a file
# BufWritePre - before saving
# BufWritePost - after saving
# FileType - when filetype is set
# VimEnter - after Vim startup
# CursorMoved - cursor moved in normal mode
# InsertEnter - entering insert mode
# Custom Ex commands:
command! -nargs=1 Grep !grep <args> %
command! -range Sum echo <line1> + <line2>
command! -bang Q quit<bang>
# Use them:
:Grep pattern
:Sum
# Show all autocmds:
:autocmd
# Show autocmds for a specific event:
:autocmd BufWritePreSnippets Vim associés
Copy-paste ready code for common tasks.
Buffer, Window et Tab
Éditer plusieurs fichiers avec buffers, splits et tabs.
Rechercher et Remplacer
Rechercher du texte avec /, remplacer avec :s, utiliser regex et plages.
Registres (Multi-Presse-papiers)
Stocker yank/delete dans des registres nommés et coller depuis eux.
Marks (Marque-pages)
Sauter à des positions dans ou entre fichiers avec marks.
Macros (Enregistrer des Keystrokes)
Enregistrer des séquences de touches et les rejouer pour automatiser les éditions répétitives.
Folding (Plier le Code)
Masquer des régions de code avec folding pour se concentrer sur la structure.
Gestionnaires de Plugins et Écosystème
Installer, configurer et découvrir des plugins avec vim-plug / packer / lazy.
LSP, Complétion et Diagnostics
Obtenir des features d'IDE via LSP (autocomplétion, go-to-definition, diagnostics).
Was this helpful?