Suggerimenti per portare la bellezza di Visual Studio Code a Vim.

Premessa

Voglio iniziare col dire che questo non è un articolo per denigrare gli editor. Puoi usare qualunque editor di testo tu voglia. In effetti non importa. Sto solo scrivendo questo perché ho trovato in Vim un livello di produttività che non ho mai ottenuto con qualsiasi editor usato prima (Sublime Text, Atom o VSCode).

Se hai sentito parlare di Vim, e desideri provarlo, spero che questo articolo possa darti un poco della familiarità che troveresti in VSCode.

Perché Vim?

Ci sono tante ragioni per usare Vim, queste sono alcune delle mie.

Mantieni le Tue Mani a Ore 10 e 2

Quando usi solo la tastiera, ottieni una spinta intrinseca nella produttività semplicemente perché non devi fisicamente spostare le tue mani. Forse sarai anche cintura nera di movimento mouse, e ti potresti spostare avanti e indietro a una velocità tale che il movimento risulti invisibile a occhio nudo. Per il resto di noi semplici umani, ci vuole tempo.

E ora un po' di matematica veloce.

Ci vogliono 600ms per spostare la mano dai "tasti home" al mouse. In media, per amor di discussione, lo faccio una volta al minuto mentre sto scrivendo del codice, che sia per scorrere le videate, per passare a un nuovo file, o qualcosa di simile.

600 (tempo sprecato in millisecondi) x 60 (volte all'ora) x 5 (ore nelle quali scrivo codice) = 180,000ms sprecati =

3. Minuti.Ogni.Giorno.

Va bene, forse non è poi così male, tuttavia quei tre minuti potrebbero essere meglio spesi scrivendo una funzione oppure rifattorizzando del codice, non agitando la mano come se fossi Harry Potter!

Velocità

La mia citazione preferita che descrive cos'è scrivere codice in Vim è:

“Scrivi codice alla velocità del pensiero”

Vim è concepito attorno all'idea che tu stia comunicando direttamente con il tuo computer. Tu gli dici cosa vuoi fare, e lui lo fa per te. Ciò che a me ha fatto aprire gli occhi è stata questa piccola constatazione:

Cancellare tutto quanto si trova tra due oggetti (parentesi, apici, ecc.) è tanto semplice quanto digitare "di" più il simbolo che racchiude l'oggetto, per esempio per eliminare il contenuto del testo piazzato tra due apici digita

di'

Questo è solo un assaggio delle stupefacenti scorciatoie che puoi utilizzare con Vim.

Sono un Vero Programmatore!

Parte del viaggio per imparare VIM è esporre te stesso al mondo UNIX. Ho l'impressione che più conosci cose come bash, migliori saranno le tue qualità di programmatore.

È probabile che tu abbia una riga di comando ben impostata. Non sarebbe bello se il tuo editor di codice e la tua riga di comando potessero lavorare insieme?

Come Fai a Uscire da Vim?

È altamente probabile che qualche volta tu abbia modificato con Vim un file su un server Linux, e che non riuscissi ad uscire dal file. Diciamo, ad esempio, modificando la chiave SSH su Digital Ocean. Se conosci VIM...non ti devi preoccupare di questo!

La Vera Ragione per la Quale sono Passato a Vim

E' ora di essere onesti. La vera ragione che mi ha fatto passare a Vim è stata guardare Kyle Mathews (creatore di Gatsby.js) che lo usava durante una  demo.

Funzionalità di VS Code e Loro Equivalenti

Convinto? Bene, ecco alcuni strumenti!

Sistema di Plugin

Vim di per sé è piuttosto scarno. Per aggiungere i plugin, deve avere un meccanismo per gestirli. Entra in scena Plug:

junegunn/vim-plug

Nota: ci sono diversi gestori di plugin in circolazione. Ho scelto Plug senza una ragione particolare. Mi piace, e non ho mai avuto problemi usandolo. Per tua informazione, Vundle è deprecato.

Cercare i File

Negli anni, ci sono state un mucchio di soluzioni per la ricerca dei file, come indica la moltitudine di risposte nei forum. Ho provato diverse combinazioni e alla fine ho scelto questa:

Fuzzy Finder(fzf) + Ripgrep

Fzf è un plugin di ricerca fuzzy molto ben progettato e mantenuto, e funziona sia da riga di comando che da Vim.

Nota: potresti vedere Ag(Silver searcher) in molti articoli, tuttavia il progetto del plugin relativo ad Ag non è più mantenuto, pertanto suggerisco RipGrep.

Intellisense

Il sistema di completamento automatico (Intellisense) in VSCode è probabilmente la sua migliore funzionalità. Per nostra fortuna è stato portato su Vim!

neoclide/coc.nvim

CoC ha un proprio sistema di estensioni, che ricalca quello di VSCode. È facile da usare e ben documentato (la parte più importante).

Nota: potresti vedere qualche vecchio articolo che parla di YouCompleteMe, ma per quanto mi risulta non è più mantenuto.

File System Explorer

VSCode, come la maggior parte degli editor moderni, è dotato di un file explorer. Quello nativo di Vim netrw va bene, e ho visto parecchi articoli come questo, che dicevano che non ti serve nient'altro. Tuttavia trovo che NERDTree sia troppo utile per non usarlo.

scrooloose/nerdtree

Integrazione con Git

Qui devo essere onesto, eseguo la maggior parte delle mie interazioni con Git direttamente dal terminale. Tuttavia, VSCode ha una divisione dello schermo per il comando git diff incredibilmente accattivante. Per ottenere quel livello di integrazione prova questo plugin:

tpope/vim-fugitive

Plugin aggiuntivi che potresti volere

Queste sono alcune delle estensioni che usavo con Visual Studio Code e che volevo portare in Vim.

Autocomplete Brackets

Questo piccolo bel pacchetto chiuderà automaticamente quelle parentesi fastidiose.

jiangmiao/auto-pairs

File Icons

Questo aggiungerà icone a cose tipo NERDTree.

ryanoasis/vim-devicons

Prettier

Forse non lo sai, ma il team ufficiale di Prettier ha un plugin Vim. Fantastico! Inoltre è incredibilmente semplice da impostare.

prettier/vim-prettier

Fallo funzionare nel salvataggio automatico, dai un'occhiata a questo articolo.

Snippets - Frammenti di Codice

Sappi che se usi il plugin Conquer of Completion, puoi importare gli snippet di VSCode!

Prova questo per vedere come farlo:

neoclide/coc.nvim

Questo è il pacchetto di snippet di React che sto usando.

xabikos/vscode-react

Altre cose

La casa per i plugin di Vim è Vim Awesome.

Vim Awesome

Un gran bel posto per vedere le persone che usano Vim:

Vimcasts - Screencasts gratuiti sull'editor di testo Vim

Dotfiles

Ho rimappato alcuni tasti per facilitare le cose, puoi vedere il mio dotfile per tutto quanto.

DarthOstrich/dotfiles

Pensieri Finali

Il Mio Viaggio

Ora uso esclusivamente Vim, dopo averci messo circa un anno per impararlo. All'inizio lo usavo solo per il miei progetti personali, poiché il mio livello di produttività era basso. Dovevo sempre fermarmi per cercare informazioni su come fare qualcosa. Tuttavia ho abbandonato VSCode completamente circa 4 mesi fa, e non ho alcuna intenzione di tornare indietro.

Ci vuole disciplina

Impare Vim potrebbe sembrare scoraggiante, e francamente, lo è. Richiede l'imposizione di auto disciplina. D'altro canto, non serve dappertutto in ambito di sviluppo? Non c'è strumento/linguaggio/framework che abbia mai imparato che non avesse richiesto un certo qual livello di pratica deliberata.

Vim è una scelta di vita. Ci vorrà del tempo per abituarsi e sarà frustrante a volte. Tuttavia se perseveri, ti garantisco che il tuo flusso di lavoro migliorerà. Come sempre, buona programmazione!

Risorse Aggiuntive per Imparare (in lingua inglese)

Mastering Vim Quickly — Jovica Ilic

8 Vim Tricks That Will Take You From Beginner to Expert

Riferimenti (in lingua inglese)

Switching to Vim

10 simple Linux tips which save 50% of my time in the command line

Ciao, compagni programmatori! Potreste aver già sentito parlare dell'editor di codice VIM o addirittura averlo usato un po'.

Ci sono molte risorse in circolazione che coprono le basi di VIM e non voglio solo fare un'altra riscrittura di quelle. Invece, voglio condividere alcuni suggerimenti rapidi che ho imparato dagli altri usando VIM a tempo pieno al lavoro.

Sono piccole cose che puoi imparare velocemente, che faranno un'enorme differenza nel tuo lavoro quotidiano con Vim. A me hanno sicuramente facilitato la vita.

Ricorda: Vim è preinstallato su Mac e Linux. Devi solo aprire un terminale e digitare "vim" nel prompt di comando e verrà aperto Vim. Se il sistema operativo è Windows, segui queste istruzioni per installare Vim sul tuo PC.

Prima di iniziare

Se sei interessato a Vim ma non hai ancora iniziato a usarlo, ci sono queste risorse (in lingua inglese) che ti vorrei consigliare:

• OpenVim - tutorial Vim interattivo
• vimtutor - è un tutorial interattivo da riga di comando disponibile e installato su MacOS e su alcune distribuzioni Linux. Digita semplicemente vimtutor nel tuo terminale
• VimAdventures - I primi due livelli sono gratuiti, e se ti piace il formato, la licenza completa costa $25

Se ti piace Vim ma è troppo per te eseguirlo da solo, installa un'estensione Vim per il tuo editor preferito, come VSCode o Sublime Text o qualunque altro la supporti. In questo modo potrai utilizzare le azioni e le scorciatotie di Vim in un'interfaccia più amichevole alla quale sei abituato.

Un importante concetto che ho appreso imparando e lavorando con Vim è che non è necessario padroneggiare tutto (il che è comunque praticamente impossibile) per iniziare a usarlo.

Una volta che apprendi le basi, ogni volta che hai una domanda o ti blocchi durante il tuo lavoro quotidiano, annotala, poi cerca la risposta su Internet su come eseguirla con Vim.

In questo modo, puoi colmare gradualmente qualsiasi lacuna tu abbia e migliorerai ogni volta che aggiungerai una cosa nuova, anche se piccola, al tuo repertorio (questi micro miglioramenti saranno simili ai suggerimenti che ti darò in questo articolo).

Passiamo ora alle cose divertenti, i suggerimenti e i trucchi. Non devi avere alcun plugin installato per trarne vantaggio.

1. Come iniziare a scrivere su una riga al punto di indentazione corretto

Prima che imparassi questo, ero solito portarmi in una riga nuova poi passare alla modalità insert, usare il TAB per portarmi al corretto punto di indentazione e iniziare a scrivere il codice. Con questo piccolo trucco non dovrai utilizzare i TAB extra. Ti porterà direttamente nel corretto punto di indentazione in modalità insert.

RICETTA: Shift-s

DEMO:

2. Ridimensionare automaticamente le finestre

Molto spesso agiamo sulle finestre all'interno di Vim provocandone un ridimensionamento non corretto, talvolta una è troppo larga e un'altra è troppo stretta.

Il modo più facile per vedere questo effetto è aprire 3 finestre in una scheda di Vim e ridimensionare la finestra del terminale nel quale hai aperto Vim.

Se vuoi ridimensionare le finestre in modo che siano tutte della stessa dimensione, con lo spazio disponibile equamente distribuito, ho buone notizie, non devi farlo manualmente.

RICETTA: CTRL+w =

La combinazione di CTRL+w, seguito dal tasto = renderà tutte le finestre della stessa dimensione.

DEMO:

3. Vai alla parentesi corrispondente

Con il tuo cursore su una parentesi tonda, quadra o graffa, digita % (Shift-5) per portarti sulla parentesi corrispondente. Digita ancora % per tornare alla parentesi da cui sei partito.

if (condition) {
  // codice
}
// Se il tuo cursore si trova su {, digitando % si porterà sulla parentesi di chiusura corrispondente }

RICETTA: digitando % con il cursore su una parentesi, esso si porterà sulla corrispondente parentesi contraria a quella di partenza.

DEMO:

4. Indentare/eliminare l'indentazione su una riga o più righe

>> ⁠– indenta una riga
<< ⁠– toglie l'indentazione su una riga

Quando hai più di una riga selezionata (in modalità VISUAL), devi solo digitare  > oppure < una volta per indentare o eliminare l'indentazione per le righe selezionate (come mostrato nella demo seguente).

Non importa dove è posizionato il cursore all'interno della riga durante l'indentazione, funzionerà ugualmente. Dopo che l'indentazione è stata eseguita, il cursore si auto posizionerà sul primo carattere non vuoto nella riga.

RICETTA: Per una riga: >>, <<. Per più righe: >, <.

DEMO:

5. Sistemare l'indentazione su un intero file

Parti dall'inizio del file (per arrivare lì digita gg da qualsiasi parte del file ti trovi). Poi digita =G, e Vim sistemerà l'indentazione su tutto il file. Se non parti dall'inizio del file, l'indentazione sarà sistemata dalla riga corrente fino alla fine.

RICETTA: =G

Digita il tasto =, seguito da SHIFT+G

DEMO:

6. Nozioni di base sul lavoro con le schede

Spesso occorre cercare su diversi file o contesti allo stesso tempo. Le schede di Vim (tab) sono una funzionalità  molto utile ma poco uilizzata per questa esigenza. Non so quale altro editor supporti questo (ma sono sicuro che c'è un modo per farlo anche altrove).

Per esempio, mi piace mantenere i file relativi al mio codice nella mia scheda principale, e in un'altra scheda un file README con un elenco di TODO e un posto dove posso annotare ulteriori idee.

Per scrivere i comandi per lavorare con le schede, dovrai essere nella modalità comando. Per iniziare a scrivere il comando digita :. Il comando verrà mostrato all'estremità inferiore sinistra dell'editor mano a mano che lo digiti. Premi Enter per eseguirlo.

RICETTA:
:tabnew crea una nuova scheda
gt - va alla scheda successiva
gT - va alla scheda precedente
:tabo - chiudi tutte le schede tranne quella attiva

DEMO:

7. Come ritornare velocemente a un file precedente

Spesso, quando modifichi un file con del codice, ne avevi aperto un altro nella stessa finestra. Non è così facile tornare a quello sul quale avevi appena lavorato. Potresti elencare i buffer e portarti sul buffer desiderato, ma devi ricordare il suo nome perdendo tempo prezioso. Agli utenti di Vim non piace utilizzare troppo tempo eseguendo azioni. :) Quindi per questo puoi usare CTRL+o.

Tutto quello che fa è trovare la posizione precedente del tuo cursore, e se detta posizione si trova in un file diverso (quello che hai perso aprendone un altro nuovo) ti porterà di nuovo là.

Grazie per la lettura, spero che questi suggerimenti ti siano stati utili!

Se vuoi seguire le mie avventure, ecco il mio Twitter :)

Scrivo una newsletter settimanale che tratta argomenti come imparare a programmare, modificare le abitudini, finanza personale, consigli su libri e concetti chiave, minimalismo, iniziare un'attività, psicologia e altro. Se sei interessato puoi unirti alle oltre mille persone con la passione per migliorare se stessi e imparare.
Iscriviti qui

In questi giorni (N.d.T.: riferito alla scrittura dell'articolo originale) sto lavorando su un mio progetto secondario, una app chiamata "Zerno". Iscriviti qui per un accesso in anteprima!
ZERNO app

Configurare il file  .vimrc ti consente di sfruttare il pieno potenziale di Vim. Con un file .vimrc personalizzato puoi moltiplicare la potenza di Vim.

In questo articolo, ti mostrerò alcuni modi per personalizzare il tuo file .vimrc.

Esaminerò:

• Impostazioni base
• Plugin
• Piegature (folding)
• Script di Vim (Vimscript)
• Riga di stato

Per prima cosa, crea la seguente struttura di directory nella tua home con il comando sotto indicato:

.vim/
 ├── autoload/
 ├── backup/
 ├── colors/
 └── plugged/

$ mkdir -p ~/.vim ~/.vim/autoload ~/.vim/backup ~/.vim/colors ~/.vim/plugged

Quindi crea un file .vimrc nella tua directory home.

$ touch ~/.vimrc

Come Aggiornare le Impostazioni di Base in Vim

Per prima cosa aggiungiamo alcune impostazioni di base che miglioreranno la tua esperienza di editing. Userò i doppi apici per commentare le righe.

Aggiungi quanto segue al file .vimrc:

" Disabilita la compatibilità con vi che può causare problemi inaspettati.
set nocompatible

" Abilita il rilevamento del tipo di file. Vim sarà in grado di aiutarti a rilevare il tipo di file in uso.
filetype on

" Abilita i plugin e carica i plugin per il tipo di file rilevato.
filetype plugin on

" Carica il file di indentazione per il tipo di file rilevato.
filetype indent on

L'evidenziazione della sintassi è molto utile. La riga che segue abilita l'evidenziazione della sintassi rendendo il tuo codice più facile da leggere.

" Abilta l'evidenziazione della sintassi.
syntax on

Senza evidenziazione sintassi:

Con evidenziazione sintassi:

Puoi anche scegliere di visualizzare i numeri di riga per spostarti più facilmente nel file.

" Aggiungi i numeri a ciascuna riga nella parte sinistra.
set number

Puoi individuare esattamente dove si trova il cursore evidenziando la riga sia orizzontalmente che verticalmente.

Aggiungi queste righe per abilitare la funzionalità.

" Evidenzia orizzontalmente la riga dove si trova il cursore.
set cursorline

" Evidenzia verticalmente la riga dove si trova il cursore.
set cursorcolumn

Di seguito alcune delle altre più comuni impostazioni che possono migliorare la tua esperienza di editing.
Ogni riga è commentata con la spiegazione di cosa fa l'opzione.

Aggiungi queste righe al tuo file .vimrc.

" Imposta lo shift a 4 spazi.
set shiftwidth=4

" Imposta il tab a 4 colunne.
set tabstop=4

" Usa gli spazi invece del carattere di tabulazione.
set expandtab

" Non salvare file di backup.
set nobackup

" Non consentire al cursore di spostarsi sopra o sotto N numeri di righe durante lo scorrimento.
set scrolloff=10

" Non andare a capo sulle righe. Consenti righe tanto lunghe quanto la massima estensione possibile.
set nowrap

" Durante la ricerca incrementale in un file, evidenzia i caratteri che trovano corrispondenza mentre digiti.
set incsearch

" Ignora le maiuscole durante la ricerca.
set ignorecase

" Ignora l'opzione ignorecase se nella ricerca digiti lettere maiuscole.
" Questo ti consente di cercare specificamente lettere maiuscole.
set smartcase

" Mostra la parte del comando che digiti nell'ultima riga dello schermo.
set showcmd

" Mostra la modalità nella quale ti trovi nell'ultima riga.
set showmode

" Mostra le parole corrispondenti durante una ricerca.
set showmatch

" Usa l'evidenziazione durante una ricerca.
set hlsearch

" Imposta il numero di comandi da salvare nella cronologia (default è 20).
set history=1000

Il completamento di Bash è una grande funzionalità che ti risparmia digitazioni sulla tastiera completando automaticamente quello che digiti. Vim ha una funzionalità simile chiamata wildmenu.

Aggiungi le seguenti righe per abilitare wildmenu. Vedrai un elenco di file che corrispondono al file che stai cercando. Puoi anche abilitare l'autocompletamento in Vim.

" Abilita il menu di autocompletamento quando digiti TAB.
set wildmenu

" Rende il comportamento di wildmenu simile a quello del completamento in Bash.
set wildmode=list:longest

" Ci sono alcuni file che non vogliamo mai editare in Vim.
" Wildmenu ignorerà i file con queste estensioni.
set wildignore=*.docx,*.jpg,*.png,*.gif,*.pdf,*.pyc,*.exe,*.flv,*.img,*.xlsx

Digita :help <comando> per maggiori informazioni su uno specifico comando.

Esempio:

:help nocompatible

Come Piegare (Nascondere) File Grandi in Vim

Il file .vimrc può assumere grandi dimensioni, quindi organizzarlo in sezioni è una buona idea. Vim ti consente di "piegare" porzioni di file di grandi dimensioni nascondendo sezioni di testo.

Aggiungi le seguenti righe alla fine del tuo file .vimrc per organizzare il file in sezioni.

" PLUGINS ---------------------------------------------------------------- {{{

" Il codice per i plugin va qui.

" }}}


" MAPPINGS --------------------------------------------------------------- {{{

" Il codice per le mappature va qui.

" }}}


" VIMSCRIPT -------------------------------------------------------------- {{{

" Questo abilita la piegatura del codice.
" Usa il metodo di marcatura (marker) per la piegatura.
augroup filetype_vim
    autocmd!
    autocmd FileType vim setlocal foldmethod=marker
augroup END

" Codice per altri Vimscripts va qui.

" }}}


" STATUS LINE ------------------------------------------------------------ {{{

" Il codice per la riga di stato va qui.

" }}}

Salva il file .vimrc con il comando :w e ricarica .vimrc con il comando :source ~/.vimrc per rendere effettive le modifiche. Ora quando sposti il tuo cursore su un contrassegno di piegatura puoi digitare:

zo per aprire la piegatura al cursore.

zc per chiudere la piegatura al cursore.

zR per aprire tutte le piegatura.

zM per chiudere tutte le piegature.

Digita :help folding per maggiori informazioni.

Come Aggiungere Plugin a Vim

Per aggiungere funzionalità a Vim puoi utilizzare i plugin. Molti usano un gestore di plugin per facilitare l'installazione dei medesimi.

Ci sono diversi gestori di plugin che possiamo usare. Ti mostrerò come installare e usare il gestore di plugin vim-plug .

Per installarlo esegui questo comando:

Su Linux o Mac OS.

$ curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

Su Windows con Powershell.

$ irw -useb https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim |`
    ni $HOME/vimfiles/autoload/plug.vim -Force

Aggiungi le righe call plug#begin('~/.vim/plugged') e call plug#end() nella sezione plugin. I riferimenti dei plugin da installare saranno aggiunti tra le due chiamate di funzione.

" PLUGINS ---------------------------------------------------------------- {{{

call plug#begin('~/.vim/plugged')




call plug#end()

" }}}

Ora installare plugin è tanto facile quanto aggiungere la stringa Plug 'username/nome-plugin' che trovi in  GitHub tra le due chiamate di funzione.

Ecco come ho installato i plugin NERDTree e Asynchronous Lint Engine (ALE).

Aggiungi queste due righe tra le due istruzioni call plug#...:

" PLUGINS ---------------------------------------------------------------- {{{

call plug#begin('~/.vim/plugged')


  Plug 'dense-analysis/ale'

  Plug 'preservim/nerdtree'


call plug#end()

" }}}

Salva il file .vimrc con il comando :w  e ricarica  .vimrc con il comando :source ~/.vimrc per rendere effettive le modifiche.

Ora digita :PlugInstall per scaricare e installare i due plugin.

Come Mappare le Scorciatoie da Tastiera in Vim

Nella sezione "mappings" di .vimrc aggiungeremo scorciatoie per facilitare la digitazione dei comandi più lunghi. In questo modo risparmierai molto tempo, specialmente per comandi lunghi.

La sintassi per la mappatura dei tasti è la seguente:

modalità_mappatura <quello_che_digiti> <quello_che_viene_eseguito>

Modalità di Mappatura Popolari in Vim

Di seguito alcune popolari modalità di mappatura, e probabilmente le più utili e importanti.

• nnoremap – Consente la mappatura dei tasti in modalità normal (normale).
• inoremap – Consente la mappatura dei tasti in modalità insert (inserimento).
• vnoremap – Consente la mappatura dei tasti in modalità visual (visuale).

Un comune esempio di mappatura è la combinazione dei tasti  'jj' con il tasto di escape ESC. Dovrai utilizzare molto il tasto ESC , che si trova all'estremità della tastiera. La lettera "j", viceversa, è nel mezzo della tastiera quindi è più facile per te digitare "jj" invece che raggiungere il tasto ESC.

Ecco come dovresti mappare il tasto ESC a jj:

inoremap jj <esc>

Come Usare Mapleader in Vim

Mapleader ti consente di impostare un tasto non utilizzato da Vim come tasto  <leader> .
Il tasto leader, in combinazione con un altro tasto, ti consente di creare nuove scorciatoie.

Il tasto della barra rovesciata "\" è il tasto leader predefinito ma alcuni preferiscono modificarlo in una virgola ",".

let mapleader = "\"

Con il tasto leader mappato alla barra rovesciata, posso usarlo in questo modo:

Disabilita l'evidenziazione della ricerca digitando \\:
nnoremap <leader>\ :nohlsearch<CR>

Di seguito alcune comuni mappature usate (vedi i commenti per una spiegazione).

Aggiungi questo codice alla sezione "mappings":

" MAPPINGS --------------------------------------------------------------- {{{

" Imposta la barra rovesciata come tasto leader.
let mapleader = "\"

" Digita \\ per tornare all'ultima posizione del cursore.
nnoremap <leader>\ ``

" Digita \p per stampare il file corrente alla stampante predefinta da un sistema operativo Linux.
" Visualizza le stampanti disponibili:   lpstat -v
" Imposta la stampante predefinita:       lpoptions -d <printer_name>
" <silent> significa non visualizzare output.
nnoremap <silent> <leader>p :%w !lp<CR>

" Digita jj per uscire velocemente dalla modalità insert.
inoremap jj <Esc>

" Usa la barra spaziatrice per digitare il carattere : in modalità comandi.
nnoremap <space> :

" Digitando la lettera o verrà aperta una nuova riga sotto quella corrente.
" Esce dalla modalità inserimento dopo aver creato una nuova riga sopra  o sotto quella corrente.
nnoremap o o<esc>
nnoremap O O<esc>

" Centra il cursore verticalmente quando ti sposti alla parola successiva durante una ricerca.
nnoremap n nzz
nnoremap N Nzz

" Copia dal cursore alla fine della riga.
nnoremap Y y$

" Mappa il tasto F5 per eseguire uno script Python all'interno di Vim.
" Qui mappo F5 a una catena di comandi.
" :w salva il file.
" <CR> (carriage return) è come premere ENTER.
" !clear esegue il comando esterno clear screen per pulire lo schermo.
" !python3 % esegue con Python il file corrente.
nnoremap <f5> :w <CR>:!clear <CR>:!python3 % <CR>

" Puoi dividere la finestra in Vim digitando :split (dividi orizzontalmente) o :vsplit (dividi verticalmente).
" Puoi spostarti più facilmente tra le finestre digitando CTRL+j, CTRL+k, CTRL+h, or CTRL+l.
nnoremap <c-j> <c-w>j
nnoremap <c-k> <c-w>k
nnoremap <c-h> <c-w>h
nnoremap <c-l> <c-w>l

" Ridimensiona le finestre usando i tasti preccia digitando:
" CTRL+UP, CTRL+DOWN, CTRL+LEFT, or CTRL+RIGHT.
noremap <c-up> <c-w>+
noremap <c-down> <c-w>-
noremap <c-left> <c-w>>
noremap <c-right> <c-w><

" Mappature specifiche per il plugin NERDTree.
" Mappa il tasto F3 per aprire/chiudere NERDTree.
nnoremap <F3> :NERDTreeToggle<cr>

" Fa ignorare a nerdtree file con certe estensioni e certe directory.
let NERDTreeIgnore=['\.git$', '\.jpg$', '\.mp4$', '\.ogg$', '\.iso$', '\.pdf$', '\.pyc$', '\.odt$', '\.png$', '\.gif$', '\.db$']

" }}}

Digita help: map-modes per maggiori informazioni.

Come Aggiungere Qualche Script di Vim

Vimscript è il linguaggio di scripting che ti consente di creare script usando variabili, istruzioni if else e funzioni. Gli auto comandi (autocmd) sono in attesa del verificarsi di eventi per attivare un comando.

" VIMSCRIPT -------------------------------------------------------------- {{{

" Abilita il metodo di marcatura per la piegatura.
augroup filetype_vim
    autocmd!
    autocmd FileType vim setlocal foldmethod=marker
augroup END

" Se il tipo di file corrente è HTML, imposta l'indentazione a 2 spazi.
autocmd Filetype html setlocal tabstop=2 shiftwidth=2 expandtab

" Se la versione di Vim è maggiore/uguale a 7.3 abilita undofile.
" Questo ti consente di ripristinare le modifiche a un file anche dopo averlo salvato.
if version >= 703
    set undodir=~/.vim/backup
    set undofile
    set undoreload=10000
endif

" Puoi dividere una finestra in sezioni digitando `:split` o `:vsplit`.
" Visualizza la riga e la colonna del cursore solo nella finestra attiva.
augroup cursor_off
    autocmd!
    autocmd WinLeave * set nocursorline nocursorcolumn
    autocmd WinEnter * set cursorline cursorcolumn
augroup END

" Se è in esecuzione una versione GUI di Vim imposta queste opzioni.
if has('gui_running')

    " Imposta la tonalità dello sfondo.
    set background=dark

    " Imposta lo schema di colorazione.
    colorscheme molokai

    " Imposta un font personalizzato che devi avere installato nel tuo computer.
    " Sitassi: set guifont=<font_name>\ <font_weight>\ <size>
    set guifont=Monospace\ Regular\ 12

    " In modalità predefinita visualizza altre informazioni oltre al nome del file.
    " Nascondi la barra degli strumenti.
    set guioptions-=T

    " Nascondi la barra di scorrimento di sinistra.
    set guioptions-=L

    " Nascondi la barra di scorrimento di destra.
    set guioptions-=r

    " Nascondi la barra del menu.
    set guioptions-=m

    " Nascondi la barra di scorrimento inferiore.
    set guioptions-=b

    " Mappa il tasto F4 per attivare/disattivare il menu, la barra degli strumenti e la barra di scorrimento.
    " <Bar> è il carattere pipe (|).
    " <CR> è il tasto ENTER.
    nnoremap <F4> :if &guioptions=~#'mTr'<Bar>
        \set guioptions-=mTr<Bar>
        \else<Bar>
        \set guioptions+=mTr<Bar>
        \endif<CR>

endif

" }}}

Leggi Learn Vimscript the Hard Way per maggiori informazioni su Vimscript.

Digita :help autocmd per maggiori informazioni sugli auto comandi.

Come Aggiungere uno Schema di Colorazione a Vim

Puoi facilmente aggiungere schemi di colorazione a Vim per modificare i suoi colori predefiniti. Cerca in Internet "Vim color schemes" e potrai trovare moltissimi schemi da cui scegliere.

Installare uno schema di colorazione è tanto facile quanto aggiungere un file <schemacolore>.vim alla directory ~/.vim/colors/ .

Aggiungerò il popolare schema molokai:

$ cd ~/.vim/colors

$ curl -o molokai.vim https://raw.githubusercontent.com/tomasr/molokai/master/colors/molokai.vim
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  7558  100  7558    0     0   150k      0 --:--:-- --:--:-- --:--:--  150k

Per impostare lo schema di colorazione digita il comando:

:colorscheme molokai

Esempi di schemi di colorazione:

Come Configurare la Barra di Stato in Vim

Puoi corredare la barra di stato di Vim con informazioni utili. Per esempio configurare il tipo di file, il numero totale di righe nel file, il percorso del file, il numero di colonna e di riga, la percentuale di avanzamento rispetto all'inizio del file e molto altro.

Aggiungi questo codice alla sezione "status line":

" STATUS LINE ------------------------------------------------------------ {{{

" Pulisci lo riga di stato quando Vim viene ricaricato.
set statusline=

" Lato sinistro della riga di stato.
set statusline+=\ %F\ %M\ %Y\ %R

" Usa un separatore per dividere la parte destra dalla sinistra.
set statusline+=%=

" Lato destro della riga di stato.
set statusline+=\ ascii:\ %b\ hex:\ 0x%B\ row:\ %l\ col:\ %c\ percent:\ %p%%

" Mostra lo stato sulla penultima riga.
set laststatus=2

" }}}

%F – Visualizza il percorso completo del file corrente.

%M – Questo flag mostra se il file non è salvato.

%Y – Tipo di file nel buffer.

%R – Visualizza il flag se il file è di sola lettura.

%b – Mostra il codice  ASCII/Unicode del carattere al cursore.

0x%B – Mostra il codice esadecimale del carattere al cursore.

%l – Mostra il numero di riga.

%c – Mostra il numero di colonna.

%p%% – Mostra la posizione del cursore in percentuale rispetto all'inizio del file.

Digita help: statusline per maggiori informazioni.

Questo è il file .vim.rc completo.

"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""               
"               
"               ██╗   ██╗██╗███╗   ███╗██████╗  ██████╗
"               ██║   ██║██║████╗ ████║██╔══██╗██╔════╝
"               ██║   ██║██║██╔████╔██║██████╔╝██║     
"               ╚██╗ ██╔╝██║██║╚██╔╝██║██╔══██╗██║     
"                ╚████╔╝ ██║██║ ╚═╝ ██║██║  ██║╚██████╗
"                 ╚═══╝  ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝ ╚═════╝
"               
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""               

" Disabilita la compatibilità con vi che può causare problemi inaspettati.
set nocompatible

" Abilita il rilevamento del tipo di file. Vim sarà in grado di aiutarti 
" a rilevare il tipo di file in uso.
filetype on

" Abilita i plugin e carica i plugin per il tipo di file rilevato.
filetype plugin on

" Carica il file di indentazione per il tipo di file rilevato.
filetype indent on

" Abilta l'evidenziazione della sintassi.
syntax on

" Aggiungi i numeri a ciascuna riga nella parte sinistra.
set number

" Evidenzia orizzontalmente la riga dove si trova il cursore.
set cursorline

" Evidenzia verticalmente la riga dove si trova il cursore.
"set cursorcolumn 

" Imposta lo shift a 4 spazi.
set shiftwidth=4

" Imposta il tab a 4 colunne.
set tabstop=4

" Usa gli spazi invece del carattere di tabulazione.
set expandtab

" Non salvare file di backup.
set nobackup

" Non consentire al cursore di spostarsi sopra o sotto N righe durante lo scorrimento.
set scrolloff=10

" Non andare a capo sulle righe. Consenti righe tanto lunghe quanto la massima estensione possibile.
set nowrap

" Durante la ricerca incrementale in un file, evidenzia i caratteri che trovano corrispondenza mentre digiti.
set incsearch

" Ignora le maiuscole durante la ricerca.
set ignorecase

" Ignora l'opzione ignorecase se nella ricerca digiti lettere maiuscole.
" Questo ti consente di cercare specificamente lettere maiuscole.
set smartcase

" Mostra la parte del comando che digiti nell'ultima riga dello schermo.
set showcmd

" Mostra la modalità nella quale ti trovi nell'ultima riga.
set showmode

" Mostra le parole corrispondenti durante una ricerca.
set showmatch

" Usa l'evidenziazione durante una ricerca.
set hlsearch

" Imposta il numero di comandi da salvare nella cronologia (default è 20).
set history=1000

" Abilita il menu di auto completamento quando digiti TAB.
set wildmenu

" Rende il comportamento di wildmenu simile a quello del completamento in Bash.
set wildmode=list:longest

" Ci sono alcuni file che non vogliamo mai editare in Vime.
" Wildmenu ignorerà i file con queste estensioni.
set wildignore=*.docx,*.jpg,*.png,*.gif,*.pdf,*.pyc,*.exe,*.flv,*.img,*.xlsx

" PLUGINS ---------------------------------------------------------------- {{{

call plug#begin('~/.vim/plugged')

    Plug 'dense-analysis/ale'

    Plug 'preservim/nerdtree'


call plug#end()

" }}}


" MAPPINGS --------------------------------------------------------------- {{{

" Imposta la barra rovesciata come tasto leader.
let mapleader = '\'

" Digita \\ per tornare all'ultima posizione del cursore.
nnoremap <leader>\ ``

" Digita \p per stampare il file corrente alla stampante predefinta da un sistema operativo Linux.
" Visualizza le stampanti disponibili:   lpstat -v
" Imposta la stampante predefinita:       lpoptions -d <printer_name>
" <silent> significa non visualizzare output.
nnoremap <silent> <leader>p :%w !lp<CR>

" Digita jj per uscire velocemente dalla modalità insert.
inoremap jj <Esc>

" Usa la barra spaziatrice per digitare il carattere : in modalità comandi.
nnoremap <space> :

" Digitando la lettera o verrà aperta una nuova riga sotto quella corrente.
" Esce dalla modalità inserimento dopo aver creato una nuova riga sopra  o sotto quella corrente.
nnoremap o o<esc>
nnoremap O O<esc>

" Centra il cursore verticalmente quando ti sposti alla parola successiva durante una ricerca.
nnoremap n nzz
nnoremap N Nzz

" Copia dal cursore alla fine della riga.
nnoremap Y y$

" Mappa il tasto F5 per eseguire uno script Python all'interno di Vim (su Linux o Mac).
" Qui mappo F5 a una catena di comandi.
" :w salva il file.
" <CR> (carriage return) è come premere ENTER.
" !clear esegue il comando esterno clear screen per pulire lo schermo.
" !python3 % esegue con Python il file corrente.
nnoremap <f5> :w <CR>:!clear <CR>:!python3 % <CR>

" Puoi dividere la finestra in Vim digitando :split (dividi orizzontalmente) o :vsplit (dividi verticalmente).
" Puoi spostarti più facilmente tra le finestre digitando CTRL+j, CTRL+k, CTRL+h, or CTRL+l.
nnoremap <c-j> <c-w>j
nnoremap <c-k> <c-w>k
nnoremap <c-h> <c-w>h
nnoremap <c-l> <c-w>l

" Ridimensiona le finestre usando i tasti freccia digitando:
" CTRL+UP, CTRL+DOWN, CTRL+LEFT, or CTRL+RIGHT.
noremap <c-up> <c-w>+
noremap <c-down> <c-w>-
noremap <c-left> <c-w>>
noremap <c-right> <c-w><

" Mappature specifiche per il plugin NERDTree.
" Mappa il tasto F3 per aprire/chiudere NERDTree.
nnoremap <F3> :NERDTreeToggle<cr>

" Fa ignorare a nerdtree file con certe estensioni e certe directory.
let NERDTreeIgnore=['\.git$', '\.jpg$', '\.mp4$', '\.ogg$', '\.iso$', '\.pdf$', '\.pyc$', '\.odt$', '\.png$', '\.gif$', '\.db$']

" }}}


" VIMSCRIPT -------------------------------------------------------------- {{{

" Consente il metodo di marcatura per la piegatura.
augroup filetype_vim
    autocmd!
    autocmd FileType vim setlocal foldmethod=marker
augroup END

" Se il tipo di file corrente è HTML, imposta l'indentazione a 2 spazi.
autocmd Filetype html setlocal tabstop=2 shiftwidth=2 expandtab

" Se la versione di Vim è maggiore/uguale a 7.3 abilita undofile.
" Questo ti consente di ripristinare le modifiche a un file anche dopo averlo salvato.
if version >= 703
    set undodir=~/.vim/backup
    set undofile
    set undoreload=10000
endif

" Puoi dividere una finestra in sezioni digitando `:split` o `:vsplit`.
" Visualizza la riga e la colonna del cursore solo nella finestra attiva.
augroup cursor_off
    autocmd!
    autocmd WinLeave * set nocursorline nocursorcolumn
    autocmd WinEnter * set cursorline cursorcolumn
augroup END

" Se è in esecuzione una versione GUI di Vim imposta queste opzioni.
if has('gui_running')

    " Imposta la tonalità dello sfondo.
    set background=dark

    " Imposta lo schema di colorazione.
    colorscheme molokai

    " Imposta un font personalizzato che devi avere installato nel tuo computer.
    " Sitassi: set guifont=<font_name>\ <font_weight>\ <size>
    set guifont=Monospace\ Regular\ 12

    " In modalità predefinita visualizza altre informazioni oltre al nome del file.
    " Nascondi la barra degli strumenti.
    set guioptions-=T

    " Nascondi la barra di scorrimento di sinistra.
    set guioptions-=L

    " Nascondi la barra di scorrimento di destra
    set guioptions-=r

    " Nascondi la barra del menu.
    set guioptions-=m

    " Nascondi la barra di scorrimento inferiore.
    set guioptions-=b

    " Mappa il tasto F4 per attivare/disattivare il menu, la barra degli strumenti e la barra di scorrimento.
    " <Bar> è il carattere pipe (|).
    " <CR> è il tasto ENTER.
    nnoremap <F4> :if &guioptions=~#'mTr'<Bar>
        \set guioptions-=mTr<Bar>
        \else<Bar>
        \set guioptions+=mTr<Bar>
        \endif<CR>

endif

" Codice per altri Vimscripts va qui.

" }}}


" STATUS LINE ------------------------------------------------------------ {{{

" Pulisci lo riga di stato quando Vim viene ricaricato.
set statusline=

" Lato sinistro della riga di stato.
set statusline+=\ %F\ %M\ %Y\ %R

" Usa un separatore per dividere la parte destra dalla sinistra.
set statusline+=%=

" Lato destro della riga di stato.
set statusline+=\ ascii:\ %b\ hex:\ 0x%B\ row:\ %l\ col:\ %c\ percent:\ %p%%

" Mostra lo stato sulla penultima riga.
set laststatus=2

" }}}

Conclusione

In questo articolo, ho solo scalfito la superficie su come personalizzare Vim.
Ci sono migliaia di modi per configurare .vimrc a piacimento.
Puoi anche scrivere i tuoi propri plugin e schemi di colorazione e condividerli con il resto della comunità.

Spero che tu abbia imparato qualche nuovo trucco leggendo questo articolo. Quindi se usi Vim, non uscire da casa senza il tuo file .vimrc!

A proposito, ho usato Vim per scrivere questo articolo.

Seguimi su Github | DEV.to

Una raccolta dei comandi più frequenti e di come utilizzarli

Se hai mai usato Vim, sai quanto può essere difficile raggiungere la stessa velocità di un editor con un'interfaccia grafica "normale". Ma una volta che ne sei in grado, la ricompensa è inestimabile – diventi molto più efficiente nello scrivere codice. Naturalmente, questo non è lo scopo principale di questo articolo.

La maggior parte delle volte si tratta – o dovrebbe trattarsi – di progettare una soluzione a un problema, e non di scrivere effettivamente del codice; quindi ottimizzare quanto sei veloce a programmare sembra l'ultima cosa a cui dedicarsi. Non è un punto su cui far leva.

Questo articolo nasce per un'altra ragione: l'inesistenza di interfacce grafiche sulle macchine SSH. Cosa intendi fare adesso? Su qualsiasi macchina in cui hai accesso al terminale e vuoi modificare un file, hai due opzioni:

1. Arrenderti e chiudere Vim
2. Padroneggiare Vim

Fare una copia di vimtutor non aiuterebbe nessuno, quindi utilizzerò un approccio diverso: ho raccolto le migliori parti di Vim che uso nella mia vita quotidiana di sviluppatore, insieme ad alcuni tecniche mnemoniche con cui ricordare delle cose. Questo articolo contiene quasi tutto quello di cui hai bisogno per la scrittura e l'editing usuale.

Le basi

Resta con me, qui non si tratta solo dei comandi, ma dell'idea che c'è dietro!

Modalità

Vim ha due modalità:

• Normale (Comando)
• Inserimento (Modifica)

Quando apri Vim, parti in modalità normale. Per tornare in modalità normale in qualsiasi momento, premi il tasto ESC. La modalità normale è quella in cui puoi impartire dei comandi: la lista di comandi è infinita!

Esistono molti modi per entrare in modalità di inserimento. Quello più intuitivo è usare il comando i (per insert). In modalità normale, premi i ed entrerai in modalità di inserimento. Ora tutto ciò che scrivi sarà mostrato nell'editor. Abbiamo risolto uno degli ostacoli più grandi.

Il modello mentale per comprendere l'idea: dato che non c'è un'interfaccia grafica, non esiste il concetto del click del mouse. Non c'è un menu da cui scegliere opzioni, non c'è tasto destro. Dunque devi trovare un modo per ottenere tutto questo dalla tastiera – la tua unica sorgente di input.

Avere due modalità ti permette di raggiungere questa condizione! Puoi pensare alla modalità normale come alla barra del menu e al mouse potenziati, mentre la modalità di inserimento è come la modalità standard degli editor con interfacce grafiche (dove quello che scrivi viene mostrato sullo schermo).

Parole

Per Vim, parola ha quasi lo stesso significato che ha per noi – un insieme di caratteri separati da spazi o caratteri speciali. Il comando è w.

Anatomia dei comandi

In Vim, i comandi seguono una serie di schemi. Saperlo ti aiuterà a mettere ogni comando in un certo gruppo e a sviluppare un migliore modello mentale.

I comandi hanno questo aspetto:

[azione] <numero> [movimento]

L'azione è quello che vuoi fare.

Il numero è quante volte vuoi svolgere l'azione.

Il movimento è l'intervallo dell'azione.

Il movimento è il campo di applicazione. Un esempio potrebbe essere utile per chiarire. Diciamo che vogliamo cancellare 3 parole partendo dalla posizione del cursore. In questo caso, l'azione è cancellare, il numero è 3 e il movimento è una parola. Il comando azione per cancellare è d.

Dunque, otteniamo il comando finale come: d3w — cancella le prossime 3 parole.

Omettere il numero fa sì che l'azione venga svolta una volta sola.

I movimenti possono essere usati senza un'azione, per navigare. Quindi, scrivere w in modalità di comando sposterà il cursore avanti di una parola.

Ora siamo ben equipaggiati per iniziare a imparare dei comandi specifici (e un intervallo di movimenti da combinarvi).

Comandi utili

Come chiudere Vim

Prima di tutto, non vogliamo restare bloccati in Vimlandia senza avere un piano di uscita. Occorre sempre avere una strategia di fuga.

:q per uscire

:q! per uscire forzatamente

:wq per salvare e uscire

Comandi azione

d : cancella

i : inserimento

p : incolla

y : copia

x : taglia

u : annulla

di: cancella all'interno* (inside), yi : copia all'interno*

v : visual / selezione

/ : ricerca

% : bracket matching, la gioia degli sviluppatori!

:s : sostituisci! In altre parole, un trova e sostituisci potenziato

Dato che le azioni su una intera riga sono molto frequenti, gli sviluppatori di Vim hanno creato un'apposita scorciatoia – omettere il movimento. Ripeti l'azione per applicarla sull'intera riga. Ad esempio:

Per cancellare la riga corrente: dd

Per copiare la riga corrente: yy

Comandi movimento

Come abbiamo visto, i movimenti vanno con le azioni e i movimenti disponibili variano a seconda dell'azione. Tuttavia, alcuni movimenti sono piuttosto generali.

w : inizio della prossima parola (lo abbiamo già incontrato!)

e : fine della parola corrente

b : inizio della parola precedente

Tasti freccia / <h,j,k,l> : rispettivi spostamenti. h,j,k,l sono dei sostituti dei tasti freccia e la fonte della velocità di Vim: non devi spostare le mani lontano dalla parte della tastiera che ti serve per scrivere.

$ : fine della riga

0 : inizio della riga

G : fine del file

nG : vai alla riga numero n

) : vai avanti di una frase

} : vai avanti di un paragrafo

Questo esempio può aiutare a visualizzare meglio alcuni comandi:

           ge      b          w                             e
           <-     <-         --->                          --->
    This is-a line, with special/separated/words (and some more). ~
       <----- <-----         -------------------->         ----->
         gE      B                   W                       E

Armati di queste azioni e di questi movimenti, possiamo creare la maggior parte dei comandi di base in Vim. Ecco una lista di 8 funzioni che possono esserti utili quotidianamente. Prova a trovare il modo per svolgerle!

1. Cancellare le prossime 3 righe (inclusa la corrente)
2. Copiare la parola corrente — con il cursore all'inizio della parola
3. Copiare la parola corrente — che ha caratteri speciali — cursore in mezzo alla parola
4. Navigare 10 righe in giù
5. Cancellare tutto all'interno delle parentesi graffe
6. Andare su di due paragrafi
7. Incollare il testo precedentemente selezionato 5 volte
8. Scrivere dove si trova il cursore: “Adesso so usare Vim!”

…

Aspetta un attimo…

…

Ed ecco le soluzioni:

1. d3j
2. yw
3. yiW : yi è per copiare all'interno e W l'oggetto da copiare (parola corrente). È estremamente utile, puoi usare ogni sorta di combinazione con inside!
4. 10j
5. di} : come il #3.
6. 2{ : questa era un po' più intuitiva. { è per andare su di un paragrafo, } è per andare giù di un paragrafo
7. 5p : ricordi i numeri opzionali? Possono essere usati quasi ovunque
8. i Adesso so usare Vim! : i è per passare alla modalità di inserimento, in modo da poter lavorare come in un editor "normale"

Bene, ce l'hai fatta! Congratulazioni, questo ti dovrebbe essere sufficiente per andare all'esplorazione di Vim da solo, avventuriero. Il tutorial è finito. Buona fortuna.

Se qualcuno ti chiede di Vim, puoi fare di meglio che usare questo meme. Spiegagli tutto, oppure rimandalo qui ;)

*Nota: questo è il mio modello di Vim. Non è esattamente il modo in cui le cose funzionano internamente. Se consulti la documentazione ( :help user-manual ), vedrai che d è il comando e il movimento è iw (inside word). C'è una differenza.
Perché? — perché ritengo che in questo modo sia più chiaro.

Bonus

Ecco alcuni comandi extra che possono tornare utili:

Split screen

:vsplit <nomefile>

Crea una divisione verticale. Ti permette di fare copia e incolla da uno schermo all'atro.

Per passare tra gli schermi divisi: ctrl + w.

Alternativamente, puoi usare i tasti freccia/ hjkl, in questo modo:

ctrl + w + h per andare alla schermata precedente.

Puoi chiudere le finestre come fai normalmente (:q), oppure —

:only — per chiudere tutte le altre finestre.

Schede multiple

:tabnew <nomefile> apre un nuovo file in una nuova scheda su Vim

:tabn per andare alla scheda successiva (o :gt)

:tabp per andare alla scheda precedente (o :gT)

Di nuovo, puoi copiare e incollare una scheda in un'altra.

Puoi anche far corrispondere questa combinazione a dei tasti di tua scelta!

Ho provato <Ctrl-Tab>, ma era già riservata. Che peccato. Invece abbiamo:

map <Ctrl-t><sinistra> :tabp<cr>
map <Ctrl-t><destra> :tabn<cr>

Che vuol dire <Ctrl-t> seguito dal tasto freccia sinistro o destro.

Come sono arrivato a questa corrispondenza? Dai un'occhiata a questo tutorial (risorsa in inglese).

Altri articoli di questa serie:

• How not to be afraid of Python anymore
• Come non avere più paura di Git

Dato che Vim è pensato sia per modificare del codice esistente che per scrivere del codice nuovo, il suo utilizzo avviene in diverse modalità a seconda dello scopo.

Modalità normale

Di default, Vim parte in modalità normale, alla quale si può accedere anche da altre modalità premendo Esc o <C-[>.

In modalità normale, i tasti non funzionano come ci si può aspettare. Non inseriscono testo nel documento, mentre premendo alcuni tasti è possibile:

Muovere il cursore

• h sposta di un carattere a sinistra
• j sposta di una riga in basso
• k sposta di una riga in alto
• l sposta di un carattere a destra

Come molti comandi di Vim, il movimento tra le righe può avere un numero come prefisso per spostarsi di più righe alla volta:

• 4j sposta di 4 righe in basso
• 6k sposta di 6 righe in alto
  

Movimenti di base tra la parole:

• w sposta all'inizio della parola successiva
• b sposta all'inizio della parola precedente
• e sposta alla fine della parola
• W sposta all'inizio della parola successiva dopo uno spazio
• B sposta all'inizio della parola precedente dopo uno spazio
• E sposta alla fine della parola dopo uno spazio

Movimenti nella riga:

• 0 sposta all'inizio della riga
• $ sposta alla fine della riga

Modificare il testo

Passare ad altre modalità

La modalità normale è quella in cui si dovrebbe passare la maggior parte del tempo usando Vim. Questo è ciò che rende Vim diverso dagli altri editor di testo.

In modalità normale, ci sono diversi modi per spostarsi in un file aperto. In aggiunta all'uso delle frecce, puoi usare anche i tasti h (sinistra), j (giù), k (su) e l (destra). Ciò è particolarmente utile a chi non piace doversi spostare dalla tastiera per fare delle modifiche.

Puoi anche fare modifiche a singoli caratteri in modalità normale. Ad esempio, per sostituire un singolo carattere, sposta il cursore su di esso e premi r, seguito dal carattere che vuoi inserire. Analogamente, puoi eliminare un singolo carattere muovendoti il cursore su di esso e premenedo x.

Per tornare indietro, premi u in modalità normale. Tornerai indietro fino all'ultima volta in cui eri in modalità normale. Se vuoi rieseguire (annullare il comando "indietro") premi Ctrl+r in modalità normale.

Modalità di inserimento

Questa è la seconda modalità più utilizzata e sarà quella con il comportamento più familiare per la maggior parte delle persone. Una volta in questa modalità, premere dei tasti inserirà caratteri nel documento proprio come un comune editor di testo. Per passare alla modalità di inserimento puoi usare il comando insert dalla modalità normale.

I comandi insert includono:

• i (insert) passa immediatamente alla modalità di inserimento
• a (append) sposta il cursore dopo il carattere attuale e passa alla modalità di inserimento
• o inserisce una nuova riga sotto quella corrente e passa in modalità di inserimento nella nuova riga

Questi comandi hanno anche delle varianti maiuscole:

• I sposta il cursore all'inizio della riga e passa in modalità di inserimento
• A sposta il cursore alla fine della riga e passa in modalità di inserimento
• O  inserisce una nuova riga sopra quella corrente e passa in modalità di inserimento nella nuova riga

Ci sono così tanti altri modi per inserire del testo in Vim che non posso elencarli qui, ma questi sono i più semplici. Fai attenzione a non stare troppo in modalità di inserimento: Vim non è pensato per stare in modalità di inserimento tutto il tempo.

Per lasciare la modalità di inserimento e tornare a quella normale, premi Esc o <C-[>

Modalità visuale

La modalità visuale viene usata per selezionare del testo, in modo simile a ciò che si fa cliccando e spostando il mouse. Selezionare del testo permette di applicare solo alla selezione specifica comandi come copia, cancella, sostituisci e così via .

Per selezionare del testo:

• Premi v per passare alla modalità visuale (e indicare il punto di partenza della selezione)
• Sposta il cursore sul punto di selezione desiderato (Vim ti mostrerà il testo selezionato in evidenza)

La modalità visuale ha anche delle varianti:

• V entra in modalità visuale di riga e permette di selezionare il testo per righe
• <C-V> entra in modalità di blocco visuale e permette di selezionare il testo in blocchi, muovendo il cursore per ottenere selezioni di testo rettangolari

Per lasciare la modalità visuale e tornare a quella normale, premi Esc o <C-[>.

La modalità visuale, in sostanza, ha più sottotipi: visuale, blocco visuale e visuale per riga

• visuale: come descritto sopra (v)
• blocco visuale: seleziona una regione rettangolare (<ctrl>+v)
• visuale a livello di linea: selezione righe intere (<shift>+v)

Modalità di comando

La modalità di comando ha svariati comandi che permettono di fare cose che in modalità normale non sono facilmente realizzabili. Per passare alla modalità di comando, digita ’:’ dalla modalità normale e poi premi il comando, che dovrebbe apparire nella parte inferiore della finestra. Ad esempio, per fare una ricerca globale ed effettuare una sostituzione, digita :%s/foo/bar/g (tutti i "foo" verranno sotituiti con "bar").

• : passa in modalità di comando
• % significa su tutte le righe
• s significa sostituisci
• /foo è un'espressione regolare per cercare le cose da sostituire
• /bar/ è un'espressione regolare per effettuare la sostituzione
• /g vuol dire globale, altrimenti il comando verrebbe eseguito solo sulla riga

Vim ha molti altri metodi di cui puoi leggere nella documentazione di supporto, :h o :help.

Modalità sostituzione

La modalità sostituzione permette di rimpiazzare il testo esistente scrivendo direttamente su di esso. Prima di entrare in questa modalità, passa alla modalità normale e metti il cursore in corrispondenza del primo carattere da sostituire e poi premi ‘R’ (maiuscola) per passare alla modalità sostituzione. A questo punto, qualsiasi cosa scrivi, sostituirà il testo esistente. Il cursore si muove automaticamente al carattere successivo, proprio come in modalità di inserimento. L'unica differenza è che ogni carattere che scrivi rimpiazzerà quello esistente.

Vim è un editor di codice estremamente utile, tanto che si trova installato di default sia nei sistemi Linux che Mac.

Se invece stai usando Windows come sistema operativo, dovrai installare Vim tu stesso.

Per fortuna, Microsoft rende molto semplice l'installazione e l'esecuzione di Vim sul tuo PC.

Scaricare Vim

Puoi scaricare l'ultima versione dell'editor di testo Vim direttamente da Vim.

Uno speciale programma di installazione autoeseguibile ti guiderà durante tutto il processo di installazione di Vim nella posizione corretta sul tuo disco rigido.

Installare Vim

Nota che per Windows, tecnicamente, scaricherai gVim, che è la versione di Vim che include un'interfaccia grafica utente (GUI). Puoi installarla scaricando questo programma di installazione eseguibile.

Una volta che hai scaricato il file, devi soltanto eseguirlo e vedrai un simpatico wizard di installazione come quello qui sotto:

L'installazione raccomandata è la tipica, ma se hai una memoria ragionevolmente grande, non avrai problemi scegliendo l'installazione completa:

Eseguire Vim in PowerShell

Dopo aver installato Vim, dovresti essere in grado di lanciarlo dal prompt dei comandi di Windows.

Nota che dal 2020, Powershell ha le stesse funzionalità del CMD, più molte altre in aggiunta. Consiglio di usare Powershell per qualsiasi cosa.

Puoi aprire Powershell dalla barra del menu di Windows scrivendo "powershell" nel campo di ricerca del menu start.

Windows aprirà Powershell e vedrai un prompt dei comandi con quest'aspetto:

Una volta entrato in Powershell, puoi eseguire Vim semplicemente digitando "vim" e premendo "invio". Ecco ciò che vedrai quando Vim si aprirà:

Ben fatto, adesso hai Vim installato sul tuo PC.

Eseguire Vim all'interno di VS Code

Se stai già utilizzando VS Code e desideri la velocità di Vim senza perdere le funzionalità di VS Code, ho buone notizie per te. Puoi utilizzare un plugin di Vim per VS Code. Quando ho scritto quest'articolo, questo plugin era stato installato da circa 2 milioni di utenti.

Imparare a usare Vim nel modo corretto

Vim è un editor di codice molto utile ma ti occorrerà molta pratica prima di prenderci la mano.

Ecco alcuni tutorial che ti saranno davvero di aiuto per cogliere le nozioni di base e migliorare in poco tempo.

Per i principianti, Vim è diverso dagli altri editor per via delle "modalità", che puoi trovare qui, spiegate con esempi.

Vim può apparire complicato e c'è tanto da imparare, ma questa guida ti mostrerà come non avere più paura di Vim.

Se stai già utilizzando VS Code e vuoi passare completamente a Vim, quest'articolo ti spiegherà come farlo.

Ed ecco 7 consigli su Vim dell'ideatore di #100DaysOfCode Alex Kallaway.  In quest'articolo, oltre a spiegarli, mostra anche delle demo con questi consigli in azione.

Vim: imparalo, vivilo e amalo.

Nei 30 anni passati da quando Bram Moolenaar ha creato Vim, il suo utilizzo si è sparso dappertutto, e anche oggi il progetto Vim viene costantemente aggiornato e migliorato.

Negli anni, ho incontrato molti sviluppatori che giurano su Vim.

Spero che questa guida ti abbia aiutato a eseguire Vim sul tuo PC Windows e spero che gli altri tutorial che ho condiviso con te ti aiuteranno a diventare un mago di Vim in poco tempo.

La chiave è continuare a fare pratica e non farsi scoraggiare da tutte le shortcut di Vim da ricordare. Alla fine, sarà tutto esercizio e volerai da un file all'altro sparando codice come un terminator.

Non c'è sensazione migliore che essere in grado di dare un'occhiata a del codebase e iniziare subito a fare dei cambiamenti senza neanche aver toccato il mouse o il trackpad. Vim ha molto da offrire e rispetta le promesse.