Utilisation de vi

February 9, 2026 • 1008 words • 5 min

Qu’est-ce que vi

vi est un éditeur de texte en mode terminal présent par défaut sur pratiquement tous les systèmes Unix et Linux. Il a été créé en 1976 par Bill Joy. Aujourd’hui, la plupart des distributions embarquent en réalité vim (Vi IMproved), une version améliorée et rétrocompatible.

vi fonctionne avec un système de modes :

Mode normal : mode par défaut, pour naviguer et manipuler le texte
Mode insertion : pour saisir du texte (touche i, a, o, etc.)
Mode commande : pour exécuter des commandes (touche :)
Mode visuel : pour sélectionner du texte (touche v)

On revient toujours au mode normal avec la touche Esc.

vi vs nano : il n’y a pas de débat

On entend souvent parler de la “guerre” entre vi et nano. Soyons honnêtes : il n’y a pas vraiment de match.

nano est un éditeur simple, accessible, qui fait le travail pour modifier vite fait un fichier de conf. C’est le Bloc-notes du terminal. C’est bien pour débuter, c’est bien pour dépanner, et c’est à peu près tout.

vi, en revanche :

Est disponible (presque) partout. Conteneur minimal, serveur durci, système embarqué : vi est généralement là. nano, pas forcément. Quelques exceptions existent (NixOS par exemple ne l’inclut pas par défaut), mais dans l’immense majorité des cas, on peut compter sur sa présence.
Propose un langage d’édition composable. Là où nano repose sur des raccourcis Ctrl+lettre à mémoriser un par un, vi fonctionne par combinaison : d (delete) + w (word) = supprimer un mot, c (change) + $ (fin de ligne) = modifier jusqu’à la fin de la ligne. Une fois la logique comprise, on n’a plus besoin de retenir des raccourcis.
Est extensible. Avec vim, on accède aux macros, à la complétion, au split, aux plugins, etc.
Rend plus rapide une fois la courbe d’apprentissage passée. Et elle est moins raide qu’on le dit.

Le seul argument en faveur de nano est sa facilité d’accès. Mais un admin qui passe ses journées dans un terminal a tout intérêt à investir quelques heures dans vi. Le retour sur investissement est immédiat.

Commandes essentielles

Commande	Action
`h` `j` `k` `l`	Gauche, bas, haut, droite
`w`	Mot suivant
`b`	Mot précédent
`0`	Début de ligne
`$`	Fin de ligne
`gg`	Début du fichier
`G`	Fin du fichier
`:n`	Aller à la ligne n (ex: `:42`)
`Ctrl+f`	Descendre d’un écran
`Ctrl+b`	Monter d’un écran
`Ctrl+d`	Descendre d’un demi-écran
`Ctrl+u`	Monter d’un demi-écran

Passer en mode insertion

Commande	Action
`i`	Insérer avant le curseur
`I`	Insérer en début de ligne
`a`	Insérer après le curseur
`A`	Insérer en fin de ligne
`o`	Nouvelle ligne en dessous
`O`	Nouvelle ligne au-dessus

Édition

Commande	Action
`x`	Supprimer le caractère sous le curseur
`dd`	Supprimer la ligne
`5dd`	Supprimer 5 lignes
`dw`	Supprimer jusqu’au mot suivant
`d$`	Supprimer jusqu’à la fin de la ligne
`C`	Supprimer jusqu’à la fin de la ligne et passer en insertion
`yy`	Copier la ligne
`5yy`	Copier 5 lignes
`p`	Coller après le curseur
`P`	Coller avant le curseur
`u`	Annuler
`Ctrl+r`	Rétablir
`.`	Répéter la dernière action

Fichiers et commandes externes

Commande	Action
`:r fichier`	Insérer le contenu d’un fichier sous le curseur
`:n fichier`	Ouvrir un autre fichier
`:!commande`	Exécuter une commande shell (ex: `:!ls /tmp`)

Marques (bookmarks)

Les marques permettent de poser des repères dans le fichier pour y revenir rapidement ou pour définir des zones de texte.

Commande	Action
`ml`	Poser la marque `l` à la position du curseur
`'l`	Aller à la ligne de la marque `l`
`l	Aller à la position exacte de la marque `l`
`y'l`	Copier de la position actuelle jusqu’à la marque `l`
`d'l`	Supprimer de la position actuelle jusqu’à la marque `l`

On peut utiliser n’importe quelle lettre minuscule (a-z) comme marque locale au fichier. Exemple concret : on pose une marque l en haut d’un bloc avec ml, on descend à la fin du bloc, puis y'l copie tout le bloc. Il suffit ensuite de p pour le coller.

Recherche et remplacement

Commande	Action
`/motif`	Rechercher vers le bas
`?motif`	Rechercher vers le haut
`n`	Occurrence suivante
`N`	Occurrence précédente
`:%s/ancien/nouveau/g`	Remplacer toutes les occurrences dans le fichier
`:s/ancien/nouveau/g`	Remplacer sur la ligne courante
`:%s/ancien/nouveau/gc`	Remplacer avec confirmation

Sauvegarder et quitter

Commande	Action
`:w`	Sauvegarder
`:q`	Quitter
`:wq`	Sauvegarder et quitter
`:q!`	Quitter sans sauvegarder
`:x`	Sauvegarder et quitter (équivalent à `:wq`)
`ZZ`	Sauvegarder et quitter (mode normal)

Fenêtres et onglets

Commande	Action
`:split fichier`	Diviser horizontalement
`:vsplit fichier`	Diviser verticalement
`Ctrl+w` puis `w`	Basculer entre les fenêtres
`Ctrl+w` puis `q`	Fermer la fenêtre
`:tabnew fichier`	Ouvrir un onglet
`gt`	Onglet suivant
`gT`	Onglet précédent

Les macros

Les macros permettent d’enregistrer une séquence de commandes et de la rejouer autant de fois que nécessaire. C’est l’une des fonctionnalités les plus puissantes de vi pour les tâches répétitives.

Enregistrer une macro

En mode normal, appuyer sur q suivi d’une lettre (le registre) : par exemple qa pour enregistrer dans le registre a
Effectuer les actions souhaitées
Appuyer sur q pour arrêter l’enregistrement

Rejouer une macro

@a        → jouer la macro du registre a
5@a       → jouer la macro 5 fois
@@        → rejouer la dernière macro exécutée

Exemple pratique

On a un fichier avec une liste de serveurs et on veut ajouter le suffixe .internal.local à chaque ligne :

web01
web02
db01
db02

On se place sur la première ligne et on enregistre :

qa          → début de l'enregistrement dans le registre a
A           → aller en fin de ligne et passer en insertion
.internal.local → taper le suffixe
Esc         → retour en mode normal
j           → descendre d'une ligne
q           → fin de l'enregistrement

On joue ensuite la macro sur les lignes restantes :

3@a         → appliquer la macro 3 fois (pour les 3 lignes restantes)

Résultat :

web01.internal.local
web02.internal.local
db01.internal.local
db02.internal.local

Voir le contenu d’une macro

Pour afficher ce qui est enregistré dans un registre :

:reg a

Astuce

Il est possible de sauvegarder ses macros les plus utiles dans son fichier ~/.vimrc :

let @a = 'A.internal.local\<Esc>j'