Approfondimento · Linux
vi e Vim
vi è l’editor di testo che si trova su
qualunque sistema Unix, spesso addirittura in un’installazione
minima senza desktop. Vim ne è l’evoluzione compatibile:
stesse dita, molte più funzioni. La difficoltà non
è la sintassi dei comandi, ma il modello mentale: si passa la
maggior parte del tempo in normal mode, dove i tasti sono
comandi, e si entra in insert mode solo per scrivere. Questa
pagina parte da quel modello e arriva a macro, registri, regex,
finestre, configurazione e recupero dopo un crash, con i comandi
separati per famiglia dove serve.
In breve. Impara prima la grammatica
operatore + movimento, poi i text object, poi la
sostituzione con le regex. Il resto — plugin, colori,
configurazioni altrui — viene dopo e vale molto meno. Se sai
già usare vi, Vim è lo stesso editor con
:help migliore.
Per il resto dell’ambiente Linux, la panoramica della sezione fa da mappa; per l’installazione di un sistema da zero c’è Installazione da riga di comando, e per ciò che sta sotto l’editor c’è Il kernel e la sua gestione. Qui si presume una shell già funzionante.
Scrivi cosa vuoi fare: la ricerca guarda descrizioni, comandi e titoli delle sezioni.
Da vi a Vim a Neovim
vi nasce nel 1976 a Berkeley, scritto da Bill Joy insieme
all’editor di righe ex. L’idea era semplice e
rivoluzionaria: invece di impartire comandi riga per riga, si vede il
file intero e si naviga con pochi tasti. vi è
entrato nello standard POSIX e per decenni è stato l’unico
editor garantito su una macchina Unix appena installata.
Vim — Vi IMproved — comincia nel 1988 come
“Vi IMitation” su Amiga, ad opera di Bram Moolenaar; la
prima versione pubblica arriva nel 1991. Aggiunge undo su più
livelli, finestre, syntax highlighting, completamento, scripting e una
quantità enorme di comandi. È software libero distribuito
con licenza compatibile GPL e charityware: l’autore
chiedeva di donare a una causa umanitaria. Bram è morto il 3
agosto 2023; il progetto è portato avanti da un gruppo di
maintainer e la versione stabile attuale è Vim
9.2, secondo vim.org a novembre 2026. La 9.0,
nel 2022, ha introdotto Vim9 script; la 9.1, all’inizio del 2024,
ha consolidato il linguaggio e corretto una lunga serie di problemi.
Neovim nasce nel 2014 come fork di Vim, con un obiettivo diverso: non riscrivere l’editor, ma rifarne l’architettura. Il core è più piccolo, il terminale e i job sono asincroni, l’API è pensata per essere pilotata da altri processi e la configurazione può essere scritta in Lua. La stabile attuale è 0.12.6, uscita il 9 ottobre 2026. LSP e Treesitter sono integrati, non plugin esterni.
| Aspetto | vi (POSIX) | Vim 9.2 | Neovim 0.12.6 |
|---|---|---|---|
| Origine | Bill Joy, 1976 | Bram Moolenaar, 1991 | Fork di Vim, 2014 |
| Scripting | Comandi ex | Vim script e Vim9 script | Lua e Vim script |
| Undo persistente | No | Sì, con undofile |
Sì, con undofile |
| LSP | No | Via plugin | Integrato in vim.lsp |
| Treesitter | No | Via plugin | Integrato |
| Terminale integrato | No | :terminal |
:terminal |
Su molte distribuzioni vi non è il vi storico: il
comando è un alternative che punta a vim.basic o a
vim.tiny, e Vim avviato con il nome vi parte
in modalità compatibile se non trova una configurazione. Il
risultato pratico è che alcuni comandi Vim non ci sono o si
comportano diversamente. Per capire cosa si sta usando:
vi --version
readlink -f "$(command -v vi)"
vim --version | head -n 5
command -v vimtutor && vimtutor
vimtutor è il modo più rapido per imparare le
basi: trenta minuti di esercizi guidati, in italiano se il locale
è configurato. :help apre il manuale completo;
:help index elenca tutti i comandi, :helpgrep
cerca dentro la documentazione.
Le modalità
Vim è un editor modale: lo stesso tasto produce effetti diversi a seconda della modalità. Non è un dettaglio estetico, è il motivo per cui si possono concatenare comandi senza premere Ctrl o Alt. Le modalità che contano davvero sono cinque, più due di servizio.
| Modalità | Come entrarci | Come uscirne | A cosa serve |
|---|---|---|---|
| Normal | Esc da quasi tutto |
— | Muoversi, cancellare, copiare, eseguire comandi |
| Insert | i a I A o O |
Esc |
Scrivere testo |
| Visual | v V Ctrl-V |
Esc |
Selezionare per caratteri, righe o blocchi |
| Select | gh gH gCtrl-H |
Esc |
Selezione che viene sostituita digitando |
| Replace | R gR |
Esc |
Sovrascrivere senza spostare il resto |
| Command-line | : / ? ! |
Enter o Esc |
Comandi ex, ricerca, filtri |
| Operator-pending | Dopo un operatore come d |
Movimento o Esc |
Attendere l’oggetto su cui agire |
| Terminal | :terminal |
Ctrl-\ Ctrl-N |
Shell dentro una finestra Vim |
Esc è la via di fuga universale. Ctrl-[
fa la stessa cosa ed è comodo sulle tastiere senza Esc vicino.
Ctrl-C interrompe, ma non equivale a Esc: non
chiude correttamente l’inserimento e può saltare
l’autocompletamento o le abbreviazioni. In insert mode,
Ctrl-O esegue un comando normal e torna a
scrivere; Ctrl-R seguito da un registro ne inserisce il
contenuto.
Due opzioni aiutano a capire cosa sta succedendo:
:set showmode mostra la modalità corrente,
:set showcmd mostra i comandi parziali in basso a destra.
La sequenza Esc e poi un comando è quasi sempre
meglio di premere tasti a caso: se il cursore si sposta da solo, si
è ancora in normal mode; se scrive, si è in insert.
Muoversi nel testo
I movimenti sono la metà del linguaggio di Vim. Quasi tutti
accettano un prefisso numerico: 5j scende di cinque righe,
3w avanza di tre parole. Il movimento non è solo
navigazione: è ciò che dà un bersaglio agli
operatori.
| Tasti | Movimento | Nota |
|---|---|---|
h j k l |
Sinistra, giù, su, destra | Il movimento di base; j/k restano nella colonna |
w b e |
Parola avanti, indietro, fine parola | W B E trattano la punteggiatura come parte della parola |
0 ^ $ |
Inizio riga, primo carattere non blank, fine riga | g_ va all’ultimo carattere non blank |
gg G |
Prima riga, ultima riga | 42G va alla riga 42; :42 fa lo stesso |
{ } |
Paragrafo indietro, avanti | Riconosce blocchi separati da righe vuote |
( ) |
Frase indietro, avanti | Utile per prosa, meno per codice |
% |
Parentesi o tag corrispondente | Funziona con () [] {} e, se configurato, con tag HTML |
f t F T |
Al carattere, prima del carattere, all’indietro | ; ripete, , ripete in senso inverso |
H M L |
Inizio, centro, fine dello schermo | Solo righe visibili |
Ctrl-D Ctrl-U |
Mezza pagina giù, su | Ctrl-F/Ctrl-B scorrono di una pagina intera |
zz zt zb |
Riga corrente al centro, in alto, in basso | Non spostano il cursore, solo la vista |
gj gk |
Riga visiva giù, su | Necessari quando wrap è attivo |
Per saltare da una parte all’altra del file si usano i
jump: Ctrl-O torna indietro nella cronologia dei
salti, Ctrl-I va avanti, :jumps mostra la
lista. g; e g, percorrono invece le posizioni
in cui il file è stato modificato. Sono movimenti da imparare
presto: dopo una ricerca o un G si torna al punto di
partenza senza rileggere il file.
Con :set relativenumber le righe mostrano la distanza dal
cursore invece del numero assoluto: 12j si legge a colpo
d’occhio. :set number relativenumber combina numero
assoluto sulla riga corrente e relativo sulle altre.
Operatori, text object e ripetizione
La grammatica è [conteggio] operatore [conteggio]
movimento. d cancella, c cambia,
y copia, > e < indentano,
= riallinea, g~ inverte il caso,
gu e gU rendono minuscolo e maiuscolo,
gq formatta, ! filtra attraverso un comando
esterno. Il movimento dice quanto.
| Comando | Effetto |
|---|---|
dw | Cancella fino all’inizio della parola successiva |
d$ oppure D | Cancella fino a fine riga |
dd | Cancella la riga intera |
cc | Sostituisce la riga intera, lasciando il cursore in insert |
yy | Copia la riga intera |
p P | Incolla dopo, prima; gp lascia il cursore dopo il testo incollato |
x X | Cancella il carattere sotto, prima del cursore |
s S | Cancella carattere o riga ed entra in insert |
r R | Sostituisce un carattere, o entra in replace mode |
J gJ | Unisce la riga sotto, con o senza spazio |
~ | Inverte il caso del carattere e avanza |
u | Annulla l’ultima modifica |
Ctrl-R | Ripristina la modifica annullata |
. | Ripete l’ultima modifica |
> < | Indenta o riduce l’indentazione |
= | Riallinea l’indentazione del codice |
gq | Formatta il testo alla larghezza impostata |
I text object sono la parte che rende Vim diverso da un
editor qualsiasi. Non indicano una distanza, indicano una struttura:
iw è la parola corrente, i"
è il contenuto tra virgolette, ip è il
paragrafo. La i sta per inner, la
a per around e include delimitatori o spazi.
| Oggetto | Significato | Esempio |
|---|---|---|
iw aw | Parola, parola con spazio | ciw cambia la parola sotto il cursore |
iW aW | Parola larga, con punteggiatura | daW cancella anche la punteggiatura |
is as | Frase | yis copia la frase |
ip ap | Paragrafo | >ip indenta il paragrafo |
i( a( | Dentro o intorno a parentesi tonde | ci( cambia l’argomento di una funzione |
i[ a[ | Parentesi quadre | da[ elimina l’indice |
i{ a{ | Parentesi graffe | yi{ copia il corpo di un blocco |
i< a< | Parentesi angolari | ci< cambia un tag |
i" a" | Virgolette doppie | ci" cambia una stringa |
i' a' | Virgolette singole | di' elimina il contenuto |
it at | Tag HTML/XML | cit cambia il testo dentro un tag |
Il punto . ripete l’ultima modifica, non l’ultimo
comando: è il moltiplicatore più potente di Vim.
ciw + testo + Esc, poi . sulla
parola successiva, è un’operazione che in altri editor
richiede mouse e menu. u annulla, Ctrl-R
ripristina; U annulla tutte le modifiche dell’ultima
riga toccata, non dell’intero file. Per una cronologia a tempo,
:earlier 10m e :later 10m.
# Cancella le righe vuote finali di un file
:g/^\s*$/d
# Indenta un blocco selezionato di quattro colonne
:>
# Formatta una selezione a 80 colonne
:'<,'>gq
# Unisci le righe da 10 a 20
:10,20j
Visual mode e blocchi
v seleziona per caratteri, V per righe,
Ctrl-V per blocchi rettangolari. La selezione è
inclusiva e il cursore può essere spostato con gli stessi
movimenti della normal mode. o e O spostano
il cursore all’altro capo della selezione; gv
riapre l’ultima selezione.
In visual block I inserisce all’inizio di ogni riga
del blocco, A alla fine, c cambia il blocco,
r sostituisce ogni carattere con uno solo, $
estende fino a fine riga. La modifica viene applicata a tutte le righe
solo quando si preme Esc: fino a quel momento si vede
l’anteprima. Su Windows, Ctrl-V può essere
intercettato dal terminale come incolla; in quel caso si usa
Ctrl-Q.
# Aggiungere un prefisso a un blocco di righe
Ctrl-V, seleziona le righe, I, scrivi il prefisso, Esc
# Rinumerare una colonna di numeri
Ctrl-V, seleziona la colonna, g Ctrl-A
# Sostituire ogni carattere di un blocco con #
Ctrl-V, seleziona, r#
# Eseguire un comando normal su ogni riga selezionata
:'<,'>normal @q
g Ctrl-A incrementa i numeri selezionati di uno per riga,
g Ctrl-X li decrementa; è il modo più rapido
per creare una sequenza. Con :set virtualedit=block il
cursore può oltrepassare la fine della riga, utile per
selezionare colonne irregolari.
La select mode (gh, gH,
gCtrl-H) è una variante della visual in cui il
primo carattere digitato sostituisce la selezione, come in un editor
grafico. È comoda per chi arriva da altri programmi, ma rompe
l’abitudine operatore-movimento: molti la disattivano con
:set selectmode=.
Registri e clipboard
Ogni cancellazione e ogni copia finisce in un registro. I registri
sono contenitori nominati e si richiamano con "
davanti al nome: "ayy copia la riga nel registro
a, "ap la incolla. Le lettere maiuscole
accodano invece di sovrascrivere.
| Registro | Contenuto |
|---|---|
" | Unnamed: l’ultima copia o cancellazione |
0 | Ultima copia (y), non toccata dalle cancellazioni |
1–9 | Cronologia delle cancellazioni, dalla più recente |
- | Ultima cancellazione piccola, entro una riga |
a–z | Registri nominati, uno per lettera |
A–Z | Append al registro minuscolo corrispondente |
_ | Black hole: cancella senza salvare nulla |
+ * | Clipboard di sistema e selezione primaria X11 |
% # | Nome del file corrente e file alternativo |
. : / | Ultimo testo inserito, ultimo comando ex, ultima ricerca |
= | Registro espressione, si usa con Ctrl-R = |
:registers (abbreviazione :reg) mostra il
contenuto di tutti i registri. "_dd cancella una riga
senza sporcare il registro unnamed, utile quando si vuole incollare
qualcosa copiato prima. "0p incolla l’ultima
copia anche dopo diverse cancellazioni.
La clipboard di sistema è un capitolo a parte. Vim deve essere
compilato con +clipboard; si verifica con
:echo has('clipboard'), che restituisce 1 se
disponibile. Su Debian/Ubuntu il pacchetto vim base spesso
non ce l’ha: serve vim-gtk3 o vim-nox.
Su Neovim la clipboard passa da un provider esterno: xclip
o xsel su X11, wl-clipboard su Wayland. Per
usare la clipboard come registro predefinito:
" Copia/incolla espliciti
"+yy
"+p
"*p
" Impostare la clipboard predefinita
:set clipboard=unnamedplus
" Verificare il supporto
:echo has('clipboard')
:checkhealth
Su Windows e macOS + e * coincidono. Su
Linux la selezione primaria (*) è quella che si
ottiene evidenziando testo col mouse, mentre + è
la clipboard vera e propria con Ctrl-C/Ctrl-V.
unnamedplus fa usare + come registro
predefinito; unnamed usa *.
Ricerca, regex e sostituzione
/pattern cerca in avanti, ?pattern indietro,
n ripete nella stessa direzione, N in quella
opposta. * cerca la parola sotto il cursore con confini di
parola, # lo fa all’indietro, g* e
g# senza confini. Le opzioni che cambiano
l’esperienza sono tre:
:set incsearch " mostra il match mentre si digita
:set hlsearch " evidenzia tutti i match
:set ignorecase " ricerca senza distinzione di maiuscole
:set smartcase " ...ma se il pattern ha una maiuscola, la rispetta
:nohlsearch " spegne l'evidenziazione corrente
:set wrapscan " la ricerca riparte dall'inizio del file
| Comando | Effetto |
|---|---|
/pattern ?pattern | Cerca in avanti o all’indietro |
n N | Ripete la ricerca nella stessa direzione o in quella opposta |
* # | Cerca la parola sotto il cursore, avanti o indietro |
:nohlsearch | Spegne l’evidenziazione dei risultati |
:%s/vecchio/nuovo/g | Sostituisce tutte le occorrenze nel file |
:%s/vecchio/nuovo/gc | Sostituisce chiedendo conferma per ogni occorrenza |
:g/pattern/cmd | Esegue un comando sulle righe che corrispondono |
:v/pattern/d | Cancella le righe che non corrispondono |
Le regex di Vim non sono PCRE. La sintassi predefinita è
“magic”: ., *, [],
^ e $ sono speciali, mentre
\( \) \| \+
\? hanno bisogno della barra rovesciata. I livelli
\v, \m, \M, \V
cambiano quante barre servono.
| Livello | Significato | Esempio |
|---|---|---|
\v | Very magic: quasi tutto è speciale, sintassi simile a PCRE | /\v(foo|bar)+ |
\m | Magic, il default | /\(foo\|bar\)\+ |
\M | Nomagic: solo ^ e $ sono speciali | /\Mfoo.bar |
\V | Very nomagic: solo la barra rovesciata è speciale | /\Vfoo.bar |
I costrutti che tornano utili tutti i giorni:
\zs e \ze delimitano l’inizio e la fine
della parte che conta, \c e \C forzano
l’ignoranza o il rispetto del caso, \< e
\> sono i confini di parola, \d
\s \w sono le classi consuete e
\@=, \@!, \@<=,
\@<! sono lookahead e lookbehind. Per cercare
letteralmente una stringa con punti e parentesi, \V evita
di scappare tutto.
La sostituzione si costruisce con
:[intervallo]s/pattern/sostituzione/[flag]. Senza
intervallo agisce sulla riga corrente; % significa tutto
il file, '<,'> la selezione visual,
10,20 un intervallo di righe, /inizio/,/fine/
un intervallo delimitato da pattern. I flag principali sono
g (tutte le occorrenze sulla riga), c
(conferma interattiva), e (nessun errore se non trova),
i e I (caso).
" Sostituzione globale con conferma
:%s/vecchio/nuovo/gc
" Rimuovere spazi e tab a fine riga
:%s/[ \t]\+$//e
" Cambiare solo la prima occorrenza per riga
:%s/foo/bar/
" Usare un delimitatore diverso da /
:%s#/usr/local#/opt#g
" Gruppi e riferimenti all'indietro
:%s/\(\w\+\)\s\+\(\w\+\)/\2 \1/g
" Maiuscolo sulla prima lettera di ogni parola
:%s/\w\+/\u&/g
" Sostituzione con espressione
:%s/\d\+/\=submatch(0) + 1/g
" Cancellare le righe che contengono DEBUG
:g/DEBUG/d
" Tenere solo le righe che contengono TODO
:v/TODO/d
" Eseguire una macro su tutte le righe che corrispondono
:g/^Item/normal @q
& nella sostituzione rappresenta l’intero match,
\1–\9 i gruppi, ~ la
sostituzione precedente. \u e \l cambiano il
caso del carattere successivo, \U e \L fino a
\E. \r spezza la riga. \=
introduce un’espressione: submatch(0) è il
testo trovato, submatch(1) il primo gruppo.
Un flusso che vale la pena imparare è quello con gn:
dopo una ricerca, cgn cambia l’occorrenza successiva
e . ripete la modifica sulla successiva ancora. È
più preciso di :%s quando si vuole controllare
caso per caso senza il prompt di conferma. Attenzione a
:set gdefault: inverte il significato di g,
e chi lo attiva senza saperlo si ritrova sostituzioni “strane”.
Buffer, finestre e tab
In Vim un buffer è un file caricato in memoria; una finestra è una vista su un buffer; una tab è un insieme di finestre. Non sono la stessa cosa dei tab di un browser: si possono avere più finestre sullo stesso buffer e più buffer nella stessa finestra. Capire questa distinzione evita metà della confusione iniziale.
:ls " elenco dei buffer
:b 3 " passa al buffer 3
:bn " buffer successivo
:bp " buffer precedente
:bd " chiude il buffer corrente
:bufdo %s/foo/bar/g " esegue su tutti i buffer
:ball " apre tutti i buffer in finestre
:sp file " split orizzontale
:vsp file " split verticale
Ctrl-W h/j/k/l " spostati tra le finestre
Ctrl-W = " equalizza le dimensioni
Ctrl-W o " lascia solo la finestra corrente
Ctrl-W T " sposta la finestra in una nuova tab
:tabnew " nuova tab
:tabedit file " nuova tab con un file
gt / gT " tab successiva / precedente
:tabdo %s/a/b/g " esegue su tutte le tab
:mksession Session.vim
:source Session.vim " ripristina buffer, finestre e posizioni
Ctrl-^ (oppure :e #) alterna il file corrente
e quello precedente, un gesto che sostituisce decine di
:b. Con :set hidden i buffer modificati
possono restare in memoria senza essere salvati quando si passa ad
altro; è l’impostazione che rende i buffer utilizzabili
come veri documenti aperti. :args gestisce la lista degli
argomenti della sessione e :argdo applica un comando a
tutti.
Le sessioni salvano la disposizione, non i contenuti non salvati.
:mksession! sovrascrive una sessione esistente;
:set sessionoptions decide cosa includere. Per riaprire
l’ultima sessione all’avvio si può usare
vim -S Session.vim, oppure un autocomando nel
vimrc.
Macro e comandi ripetuti
Una macro è la registrazione di tasti in un registro. Si comincia
con q seguito da una lettera, si esegue la sequenza e si
ferma con q. Poi @a la esegue,
@@ ripete l’ultima e 10@a la esegue
dieci volte. Le macro registrano comandi normal, non testo: una
sequenza di movimenti e operatori è molto più robusta di
una serie di tasti freccia.
" Registrare una macro nel registro a
qa
0f,dt,
j
q
" Eseguirla sulle righe successive
10@a
" Modificare una macro: apre la command-line window
q:
" ...modifica la riga, poi Invio
" Eseguire la macro su tutto il file
:%normal @a
" Eseguire la macro su una selezione
:'<,'>normal @a
" Registrare una macro che incrementa un contatore
qa
0
Ctrl-A
j
q
100@a
Due accorgimenti evitano i disastri. Il primo: far iniziare la macro da
una posizione nota, di solito con 0 o gg,
perché una macro registrata a metà riga dipende dal punto
di partenza. Il secondo: se una macro va in loop, Ctrl-C
la interrompe; se ha già modificato il file, u
annulla. Le macro ricorsive (una macro che chiama sé stessa)
funzionano solo con una condizione di uscita, altrimenti girano fino
all’interruzione.
:normal esegue comandi come se fossero digitati, ma
rispetta le mappature; :normal! ignora le mappature ed
è quello che si vuole nei casi riproducibili. La
command-line window (q:, q/,
q?) permette di modificare comandi e ricerche con gli
strumenti di Vim: è il modo pulito per correggere una macro
sbagliata senza rifarla da capo.
Marcatori, pieghe e quickfix
I marcatori salvano una posizione. ma imposta il marcatore
a, 'a salta alla riga, `a alla
posizione esatta. Le lettere minuscole sono locali al buffer, le
maiuscole sono globali e funzionano tra file. :marks li
elenca, :delmarks a b li cancella. Alcuni marcatori sono
automatici: '" è l’ultima posizione in
cui si è usciti dal file, '^ l’ultimo punto
di inserimento, '. l’ultima modifica,
'[ e '] gli estremi dell’ultima
modifica o copia.
Le pieghe nascondono parti di testo senza cancellarle.
zf{movimento} crea una piega, zo la apre,
zc la chiude, za alterna, zR
apre tutto, zM chiude tutto. Il metodo predefinito
è manual; per codice sono comodi
indent e expr, per il testo
marker con {{{ e }}}. Con
:set foldlevel=99 si aprono tutte le pieghe.
:set foldmethod=indent
:set foldlevel=1
zf " crea una piega sulla selezione
zR " apre tutte le pieghe
zM " chiude tutte le pieghe
:vimgrep /TODO/g **/*.c
:copen " apre la quickfix list
:cnext / :cprev " naviga i risultati
:cdo s/TODO/DONE/g | update
:cfdo %s/foo/bar/g | update
La quickfix list è la lista dei risultati di
:grep, :vimgrep, :make o di un
linter. :copen la apre, :cnext e
:cprev navigano, :cdo esegue un comando su
ogni voce, :cfdo una volta per file. È il ponte tra
Vim e il resto della toolchain: un compilatore che scrive errori in
formato standard diventa navigabile senza plugin.
Configurazione: vimrc e opzioni
Vim legge la configurazione utente da ~/.vimrc oppure
~/.vim/vimrc su Unix, da $HOME/_vimrc o
$HOME/vimfiles/vimrc su Windows. Neovim usa
~/.config/nvim/init.vim o init.lua, e
rispetta $XDG_CONFIG_HOME. :version mostra
quali file sono stati letti; :echo $MYVIMRC dà il
percorso del file utente; :source $MYVIMRC lo ricarica
senza riavviare.
:set mostra le opzioni diverse dal default,
:set all tutte, :set nome? interroga una
singola opzione e :verbose set nome? dice anche dove
è stata impostata per ultima. :setlocal agisce solo
sulla finestra o sul buffer corrente, :setglobal sul
valore globale. La distinzione conta per opzioni come
shiftwidth, expandtab e
textwidth, che spesso devono essere diverse per file.
" ~/.vimrc -- configurazione minima e leggibile
set nocompatible
set encoding=utf-8
set fileencoding=utf-8
set number relativenumber
set showcmd showmode
set wildmenu
set wildmode=longest:full,list:full
set incsearch hlsearch
set ignorecase smartcase
set backspace=indent,eol,start
set mouse=a
set clipboard=unnamedplus
set undofile
set undodir=~/.vim/undo//
set swapfile
set directory=~/.vim/swap//
set backup
set backupdir=~/.vim/backup//
set tabstop=4
set shiftwidth=4
set softtabstop=4
set expandtab
set autoindent
set breakindent
set list listchars=tab:»·,trail:·,extends:›
filetype plugin indent on
syntax on
augroup filetypes
autocmd!
autocmd FileType yaml,yml setlocal tabstop=2 shiftwidth=2 softtabstop=2 expandtab
autocmd FileType make setlocal noexpandtab
autocmd FileType markdown setlocal spell spelllang=it,en
augroup END
Le directory con // finale fanno usare a Vim il percorso
completo del file, evitando collisioni tra file con lo stesso nome.
undofile rende l’undo persistente tra sessioni:
dopo aver chiuso e riaperto un file, u continua a
funzionare. backup e swapfile sono reti di
sicurezza, non alternative: il primo conserva la versione precedente,
il secondo il lavoro non salvato.
Le modeline sono righe speciali nel file, come
# vim: set ts=4 sw=4 et:, che impostano opzioni solo per
quel file. Sono comode e pericolose: un file ostile può
impostare opzioni indesiderate. :set modeline le abilita
(di norma lo sono), :set nomodeline le disabilita, e per
aprire file non fidati conviene usare vim -u NONE -N.
Vim 9 ha due linguaggi di scripting. Il vecchio Vim script usa
let, function, if e le stringhe
con . per la concatenazione; Vim9 script, introdotto nella
9.0, usa vim9script, var, const,
def ... enddef, tipi e compilazione. I due possono
convivere nello stesso file con :legacy e
:vim9script, ma è meglio non mescolarli senza
motivo.
Plugin, Vim 9 e Neovim
Vim 8 ha introdotto i pacchetti nativi: un plugin si mette in
~/.vim/pack/nome/start/plugin/ e viene caricato
all’avvio; in opt/ resta disponibile e si attiva con
:packadd plugin. :helptags genera i tag della
documentazione. Per pochi plugin è una soluzione onesta, senza
gestori di terze parti.
Per più plugin si usano vim-plug,
lazy.nvim (Neovim) o packer.nvim, ormai
archiviato. I plugin che cambiano davvero il lavoro sono pochi:
telescope.nvim o fzf.vim per la ricerca
fuzzy, vim-fugitive per Git, vim-surround per
gestire delimitatori, vim-commentary per commentare,
nvim-tree.lua o neo-tree per l’albero
dei file. Su Neovim, LSP e Treesitter sono integrati e si configurano
in Lua; :checkhealth dice cosa manca.
Vim 9.2 porta miglioramenti a Vim9 script, alla modalità diff e al completamento; Neovim 0.12.6 è la stabile di riferimento per chi vuole Lua, API asincrona e un ecosistema più moderno. La scelta tra i due non è tecnica in senso stretto: Vim è ovunque, anche su server vecchi e sistemi minimali; Neovim richiede un’installazione più recente e una configurazione iniziale maggiore, ma offre un’integrazione migliore con LSP e Treesitter.
Sicurezza dei plugin. Un plugin esegue codice con i tuoi privilegi, esattamente come uno script shell. Installa solo da repository noti, leggi il codice dei plugin piccoli, blocca le versioni invece di seguire sempre il branch principale e non scaricare configurazioni “chiavi in mano” senza capire cosa contengono. Le configurazioni altrui sono un ottimo punto di partenza, non un contratto di fiducia.
Comandi ex: cheat sheet
I comandi che cominciano con : vengono dall’editor
ex e funzionano anche in modalità batch, dentro
script e in vim -c. Sono la parte di Vim che si può
automatizzare senza plugin.
| Comando | Effetto |
|---|---|
:w :q :wq | Salva, esci, salva ed esci |
:x | Salva solo se ci sono modifiche, poi esce |
:q! :qa! | Esci senza salvare, anche da tutte le finestre |
:e file | Apri un file nel buffer corrente |
:r file :r !cmd | Inserisci un file o l’output di un comando |
:!cmd | Esegui un comando shell |
:%!jq . | Filtra tutto il buffer attraverso un comando |
:sort u | Ordina e rimuove le righe duplicate |
:g/^$/d | Cancella le righe vuote |
:m 10 :t 5 | Sposta o copia la riga corrente |
:normal! @a | Esegue la macro a senza mappature |
:%s/foo/bar/g | Sostituzione globale |
:earlier 10m :later 10m | Torna indietro o avanti nel tempo |
:mksession :source | Salva e ripristina la sessione |
:terminal | Apre una shell in una finestra |
:w !sudo tee % | Salva un file protetto usando sudo |
:set ff=unix | Converte i fine riga in formato Unix |
:set ff=dos | Converte i fine riga in formato Windows |
:x e :wq sembrano uguali ma non lo sono:
:wq scrive sempre, :x solo se il buffer
è modificato. Su file grandi o su dischi di rete la differenza
si sente. :w !sudo tee % funziona perché
% viene espanso nel nome del file corrente e
tee scrive con i privilegi di sudo; dopo il comando Vim
segnala che il file è cambiato e chiede conferma.
Un uso meno noto ma potentissimo è il filtro:
:%!sort, :%!jq ., :%!column -t
passano l’intero buffer a un programma e ne prendono
l’output. Con una selezione visual il filtro agisce solo su
quella. È il motivo per cui Vim resta comodo anche quando il
lavoro vero lo fanno sed, awk e
jq.
Errori, swap e recupero
Il messaggio che spaventa di più è
E325: ATTENTION, seguito da un file
.nome.swp. Significa che esiste un file di swap, di solito
perché Vim è aperto altrove o perché un crash ha
lasciato il file. Non va cancellato d’istinto: potrebbe contenere
modifiche non salvate. Le strade sono tre: tornare alla sessione
esistente, aprire in sola lettura (vim -R file) oppure
recuperare.
:swapname " mostra il percorso del file di swap
:recover file " recupera le modifiche dal swap
:w nuovo.txt " salva il recupero su un file nuovo
:set noswapfile " disabilita lo swap per il buffer corrente
:set swapfile
:set directory? " mostra dove finiscono i file di swap
Dopo un recupero conviene salvare subito su un nome diverso, confrontare
con l’originale e solo dopo sovrascrivere. Il file di swap va
rimosso a mano quando si è certi che non serve più. Se il
problema è che Vim non ha i permessi di scrittura, il comando
:w !sudo tee % risolve; se il file è in sola
lettura per scelta, :set noreadonly toglie il blocco.
Altri inciampi ricorrenti:
| Sintomo | Causa e rimedio |
|---|---|
| Il testo incollato “scala” a destra | Autoindent durante l’incolla: :set paste, incolla, :set nopaste; oppure usa il terminale con bracketed paste |
E45: 'readonly' option is set | :set noreadonly se sei sicuro di voler scrivere |
E212: Can't open file for writing | Permessi o directory inesistente: :w !sudo tee % o correggi il percorso |
| La clipboard non funziona | :echo has('clipboard'); su Neovim installa xclip/wl-clipboard e controlla :checkhealth |
| Accenti o caratteri strani | :set fileencoding?, riapri con :e ++enc=utf-8, controlla :set encoding |
| Fine riga sbagliata | :set ff=unix o :set ff=dos, poi salva |
| Bloccato in terminal mode | Ctrl-\ Ctrl-N per tornare in normal mode |
| Una macro non finisce più | Ctrl-C, poi u per annullare |
| Non ricordo un comando | :help, :help index, :helpgrep parola, vimtutor |
L’undo persistente è la rete di sicurezza migliore:
set undofile e una undodir dedicata
permettono di tornare indietro anche dopo aver chiuso il file. Con
:earlier e :later si naviga la cronologia a
intervalli di tempo, con :undo e :redo a
passi. Se il file è stato sovrascritto da un comando esterno,
l’undo di Vim non lo recupera: servono i backup o un file system
con snapshot.
Fonti
- vim.org, Documentation —
:help,usr_,index.txt,options.txt,pattern.txt,change.txteeval.txt. - vim.org, Download — Vim 9.2 come ultima versione stabile, consultata il 14 novembre 2026.
- Debian Package Tracker, vim —
patch
9.1.2132nei repository Debian. - Neovim, Documentation e Releases
—
:help,vim.lsp,vim.treesitter,:checkhealth; stabile 0.12.6 del 9 ottobre 2026. - POSIX, vi — specifica dell’editor e dei comandi ex.
- Vim, Vim9 script —
:help vim9,def,var,importe compilazione. - Neovim, LSP e Treesitter — configurazione integrata e provider esterni per la clipboard.
Versioni verificate il 14 novembre 2026: Vim 9.2 è la stabile
indicata da vim.org, mentre Debian trixie distribuisce una
9.1 con patch fino a 9.1.2132; Neovim è alla
0.12.6 dal 9 ottobre 2026. Il comando vi può
corrispondere a implementazioni diverse: controlla
vi --version prima di assumere che un comando Vim
funzioni.