Puntatori utili: Pagina iniziale · Riferimenti rapidi · Indice User Manual Vim · Indice generale · FAQ in inglese
*tips.txt* Per Vim version 8.0. Ultima modifica: 2009 Nov 07 VIM Manuale di Riferimento di Bram Moolenaar Traduzione di questo testo: Antonio Colombo Suggerimenti e idee per usare Vim *tips* Sono qui descritti solo pochi esempi che riteniamo utile per molti utenti. Molti di più possono essere trovati sulla wiki. L'URL relativo può essere trovato nel sito http://www.vim.org Non dimenticatevi di consultare il manuale utente, che contiene anche una grande quantità di suggerimenti utili: |usr_toc|. Modificare programmi C |C-editing| Trovare dove sono usati identificatori |ident-search| Cambiare schermo in un xterm |xterm-screens| Scorrere in Modo Insert |scroll-insert| Scorrere dolcemente |scroll-smooth| Correggere refusi frequenti |type-mistakes| Contare, parole, righe, etc. |count-items| Ripristinare la posizione del cursore |restore-position| Rinominare file |rename-files| Cambiare un nome in più di un file |change-name| Velocizzare comandi esterni |speed-up| Mappature utili |useful-mappings| Comprimere i file di help |gzip-helpfile| Eseguire comandi della shell in una finestra |shell-window| Modificare in esadecimale |hex-editing| Uso della notazione<>
negli autocomandi |autocmd-<>| Evidenziare la parentesi corrispondente |match-parens|
Modificare programmi C *C-editing* Ci sono alcune funzionalità in Vim che possono esservi utili per editare file di programmi C. Ecco qualche indicazione con i tag a cui saltare: |usr_29| Capitolo "Spostarsi nei programmi" nel manuale utente. |usr_30| Capitolo "Modifica programmi" nel manuale utente. |C-indenting| Impostare automaticamente l'indentazione di una riga mentre di immette del testo. |=| Re-indentare qualche riga. |format-comments| Formattazione dei commenti inseriti nel programma. |:checkpath| Lista tutti i file inclusi in maniera ricorsiva. |[i| Ricerca l'identificativo sotto il cursore nel file corrente e in quelli inclusi. |[_CTRL-I| Salta alla corrispondenza per "[i" |[I| Lista tutte le righe nel file corrente e in quelli inclusi contenenti l'identificatore sotto il cursore. |[d| Ricerca la define sotto il cursore nel file corrente e in quelli inclusi. |CTRL-]| Salta alla tag sotto il cursore (per esempio, alla definizione di una funzione). |CTRL-T| Salta indietro a dove si era prima del comando CTRL-]. |:tselect| Sceglie una tag in una lista di tag che costituisce il risultato di una ricerca. |gD| Va alla dichiarazione di variabile globale sotto il cursore. |gf| Vai in edit sul nome-file sotto il cursore. |%| Vai alla (),{}
, [], /* */, #if, #else, #endif corrispondente. |[/| Vai al precedente inizio di commento. |]/| Vai alla precedente fine di commento. |[#| Torna indietro fino a un #if, #ifdef, o #else non chiuso. |]#| Vai avanti fino a un #else o #endif non chiuso. |[(| Torna indietro fino a una '(' non chiusa. |])| Vai avanti fino a una ')' non chiusa. |[{| Torna indietro fino a una '{' non chiusa. |]}| Vai avanti fino a una '}' non chiusa. |v_ab| Seleziona un blocco "a block" da "[(" a "])", parentesi comprese. |v_ib| Seleziona un blocco interno "inner block" da "[(" a "])" (parentesi escluse). |v_aB| Seleziona un blocco "a block" da "[{" a "]}
", parentesi comprese. |v_iB| Seleziona un blocco interno "inner block" da "[{" a "]}" (parentesi escluse).
Trovare dove sono usati identificatori *ident-search* è probabile che già sappiate che le tag |tags| possono essere usate per saltare alla posizione in cui è stata definita una funzione o una variabile. Ma può capitare che vogliate saltare a tutti i posti in cui una funzione o variabile è utilizzata. Ciò è possibile in due modi: 1. Usando il comando |:grep|. Questo metodo dovrebbe funzionare in quasi tutti i sistemi Unix, ma può essere lento (legge tutti i file) e la ricerca è limitata a una sola directory. 2. Usando i programmi di utilità ID. Questo metodo è veloce e può lavorare con più di una directory. Un database è usato per memorizzare le posizioni. Saranno necessari alcuni programmi in più perché la cosa funzioni. E il database dovrà essere tenuto aggiornato. Usare i programmi di utilità GNU id-tools: Cosa vi serve: - Il pacchetto GNU id-tools disponibile (mkid serve per creare ID e lid serve per usare le macro). - Un file contenete il database degli identificativi, di nome "ID", nella directory corrente. Lo potete creare con il comando della shell "mkid file1 file2 ..". Mettete quanto segue nel vostro .vimrc:map _u :call ID_search()
<Bar>
execute "/\\<" . g:word . "\\>
"<CR>
map _n :n
<Bar>
execute "/\\<" . g:word . "\\>
"<CR>
function! ID_search()
let g:word = expand("
<cword>
")let x = system("lid --key=none ". g:word)
let x = substitute(x, "\n", " ", "g")
execute "next " . x
endfun
Per usarlo, mettete il cursore sopra una parola, battete "_u" e vim caricherà il file che contiene la parola. Potete trovare la successiva occorrenza della parola nello stesso file con "n". Passate al prossimo file con "_n". Quanto sopra è stato testato usando id-utils-3.2 (è questo il nome del file che contiene il software id-tools sul sito mirror di gnu-ftp-mirror più vicino a voi). [l'idea per quanto sopra è di Andreas Kutschera]
Cambiare schermo in un xterm *xterm-screens* *xterm-save-screen* (scritto da Juergen Weigert in comp.editors, rispondendo a una domanda) :> Un'altra domanda è che dopo essere usciti da vim, lo schermo è lasciato :> com'era, cioè i contenuti del file che stavo vedendo (editando) sono :> ancora sullo schermo. L'output del mio precedente "ls" si è perduto, :> cioè, non è più disponibile nel buffer scorrevole. So che c'è un modo per :> ripristinare lo schermo dopo essere usciti da vim o da un altro editor :> simile a vi, ma non so come fare. Ogni aiuto è apprezzato. Grazie. : :Immagino che qualcun altro possa rispondere a questa domanda. Suppongo che :vim e vi si comportino entrambi allo stesso modo a fronte di una data :configurazione di xterm. Il comportamento non è necessariamente lo stesso, potrebbe esserci un problema di utilizzo di termcap invece che terminfo. Dovresti tener presente che ci sono due database che descrivono gli attributi di un particolare tipo di terminale: termcap e terminfo. Questo può implicare delle differenze quando le descrizioni sono differenti E quando uno dei programmi in questione usa terminfo, mentre l'altro usa termcap (vedere anche |+terminfo|). Nel tuo caso particolare, stai cercando le sequenze di caratteri di controllo ^[[?47h e ^[[?47l. Questo fanno passare dallo schermo alternato a quello principale del buffer. Come soluzione temporanea veloce, una sequenza di comandi comeecho -n "^[[?47h"; vim ... ; echo -n "^[[?47l"
può produrre l'effetto da te desiderato. (La mia notazione ^[ indica il tasto<ESC>
, vedrai più sotto che i database usano invece \E). A inizio programma, vim invia il valore della variabile termcap ti (terminfo smcup) al terminale. In uscita, invia te (terminfo: rmcup). Per cui queste due variabili sono il posto giusto in cui dovrebbero essere inserite le sequenze di controllo menzionate sopra. Confrontate le righe termcap che si riferiscono a xterm (le trovate in /etc/termcap) con la descrizione terminfo dello stesso (che si può avere battendo "infocmp -C xterm"). Entrambe dovrebbero contenere righe simili a::te=\E[2J\E[?47l\E8:ti=\E7\E[?47h:
PS: Se rilevate delle differenze, qualcuno (il vostro amministratore di sistema?) farebbe bene a controllare gli interi database termcap e terminfo per assicurarsi che siano consistenti fra loro. NOTA 1: Se ricompilate Vim con FEAT_XTERM_SAVE definita in feature.h, l'xterm interno di Vim comprenderà le righe di descrizione menzionate, "te" e "ti". NOTA 2: Se volete disabilitare il passaggio di schermo e non volete cambiare le vostre termcap, potete aggiungere queste righe al vostro .vimrc:
:set t_ti= t_te=
Scorrere in Modo Insert *scroll-insert* Se siete in Modo Insert e volete vedere qualcosa che si trova vicino a quel che vedete sull schermo, potete usareCTRL-X
CTRL-E
eCTRL-X
CTRL-Y
per far scorrere lo schermo. |i_CTRL-X_CTRL-E| Per facilitare la cosa, potreste usare queste mappature::inoremap
<C-E>
<C-X>
<C-E>
:inoremap
(Battete questo letteralmente, assicuratevi che il flag '<' non sia specificato in 'cpoptions'). In questo modo perdete la possibilità di copiare del testo sopra/sotto la riga del cursore |i_CTRL-E|. Considerate anche se impostare 'scrolloff' a un valore maggiore, in modo da poter sempre vedere qualche riga di contesto attorno al cursore. Se 'scrolloff' è più alto della metà della finistra, il cursore starà sempre nel mezzo, e il testo viene fatto scorrere quando si sposta il cursore in su o in giù.<C-Y>
<C-X>
<C-Y>
Scorrere dolcemente *scroll-smooth* Se volete uno scorrimento un po' più dolce, potete usare queste mappature::map
<C-U>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
<C-Y>
:map
<C-D>
<C-E>
<C-E>
<C-E>
<C-E>
<C-E>
<C-E>
<C-E>
<C-E>
<C-E>
<C-E>
<C-E>
<C-E>
<C-E>
<C-E>
<C-E>
<C-E>
(Battete questo letteralmente, assicuratevi che il flag '<' non sia specificato in 'cpoptions').
Correggere refusi frequenti *type-mistakes* Se ci sono alcune parole che spesso battete in maniera scorretta, create delle abbreviazioni per correggerle. Per esempio::ab gil gli
:ab pre per
Contare, parole, righe, etc. *count-items* Per contare le occorrenze di un'espressione regolare nel buffer corrente, usate il comando substitute, aggiungendo il flag 'n' per evitare di fare realmente la sostituzione. Il numero di sostituzioni riportato è il numero delle occorrenze. Esempi:
:%s/./&/gn caratteri
:%s/\i\+/&/gn parole
:%s/^//n righe
:%s/il/&/gn "il" da qualsiasi parte (anche dentro parole)
:%s/\
<il\>
/&/gn "il" inteso come parolaPotreste annullare 'hlsearch' o impostare ":nohlsearch". Aggiungere il flag 'e' se non voleta una segnalazione di errore quando non viene trovata nessuna corrispondenza. Una alternativa è usare |v_g_CTRL-G| in Modo Visual. Per trovare corrispondenze in più di un file, potete usare |:vimgrep|. *count-bytes* Se volete contare byte, potete fare così: Selezionate i caratteri in Modo Visual (o anche nel Modo Block Visual Usate "y" per copiare i caratteri Usate la funzione strlen():
:echo strlen(@")
Ogni carattere di fine linea è contato come un byte.
Ripristinare la posizione del cursore *restore-position* Qualche volta potreste voler definire una mappatura che fa qualche tipo di modifica da qualche parte nel file, e poi ripristina la posizione del cursore, senza far scorrere il testo. Per esempio, per cambiare l'indicatore della data in un file::map
<F2>
msHmtgg/Last [cC]hange:\s*/e+1<CR>
"_D"=strftime("%Y %b %d")<CR>
p'tzt`sDettaglio salvataggio posizione: ms metti posizione cursore nel marcatore 's' H vai alla prima linea della finestra mt metti questa posizione nel marcatore 't' Dettaglio ripristino posizione: 't vai alla linea che era prima in cima alla finestra zt scorri per muovere questa linea in cima alla finestra `s salta alla posizione originale del cursore Per qualcosa di più sofisticato vedere |winsaveview()| e |winrestview()|.
Rinominare file *rename-files* Supponiamo di avere una directory che contiene i seguenti file (directory scelta a caso :-): buffer.c charset.c digraph.c ... e di voler rinominare *.c in *.bla. Farei così:
$ vim
:r !ls *.c
:%s/\(.*\).c/mv & \1.bla
:w !sh
:q!
Cambiare un nome in più di un file *change-name* Esempio di uso di uno script file per cambiare nome a più file: Create un file "subs.vim" che contiene dei comandi substitute e un comando :update : :%s/Rossi/Bianchi/g :%s/Mario/Pietro/g :update < Invocate Vim per i file che volete modificare, ed eseguite lo script per ogni file specificato nella lista argumenti:
vim *.let
argdo source subs.vim
Vedere |:argdo|.
Velocizzare comandi esterni *speed-up* In alcune situazioni, l'esecuzione di un comando esterno può essere molto lenta. Trovate qui alcuni suggerimenti per poter procedere più rapidamente. Se il vostro file .cshrc (o il file corrispondente, a seconda della shell che usate) è molto lungo, dovreste dividerlo in una parte dedicata all'utente che interagisce, e in una parte per uso non-interattivo (spesso chiamata "shell secondaria"). Quando eseguite un comando da Vim come per esempio ":!ls", non avete alcun bisogno della parte "interattiva" (per esempio, quella che imposta il prompt). Mettete la parte che non vi serve dopo le linee seguenti:
if ($?prompt == 0) then
exit 0
endif
un altro modo è si specificare alla shell il flag "-f", per esempio:
:set shell=csh\ -f
(il "\" serve per inserire lo spazio seguente nell'opzione). Questo parametro farà sì che lo shell non utilizzi affatto il file .cshrc. Ciò può a sua volta far sì che alcune cose siano non funzionanti.
Mappature utili *useful-mappings* Ecco alcune mappature che piacciono a qualcuno. *map-backtick*:map ' `
Fa sì che l'apice semplice di comporti come l'apice retroverso. Mette il cursore sulla colonna di una marcatura, invece che andare al primo carattere non-bianco della linea. *emacs-keys* Per modifiche su riga-comando in stile Emacs:" vai a inizio linea
:cnoremap
<C-A>
<Home>
" indietro di un carattere
:cnoremap
<C-B>
<Left>
" cancella carattere sotto il cursore
:cnoremap
<C-D>
<Del>
" vai a fine linea
:cnoremap
<C-E>
<End>
" avanti di un carattere
:cnoremap
<C-F>
<Right>
" richiama la linea-comando più recente
:cnoremap
<C-N>
<Down>
" richiama la linea-comando precedente (più vecchia)
:cnoremap
<C-P>
<Up>
" indietro di una parola
:cnoremap
<Esc>
<C-B>
<S-Left>
" avanti di una parola
:cnoremap
<Esc>
<C-F>
<S-Right>
NOTA: Questo richiede che il flag '<' non sia specificato in 'cpoptions'. *format-bullet-list* Questa mappatura formatterà ogni lista a punti. Richiede che ci sia una linea vuota prima e dopo ogni elemento della lista. La serie di comandi è stata scritta in modo da poter aggiungere commenti a ogni singola parte della mappatura.
:let m = ":map _f :set ai
<CR>
" " 'autoindent' va impostato:let m = m . "{O
<Esc>
" " linea vuota sopra elemento:let m = m . "}{)^W" " al testo dopo il punto
:let m = m . "i
<CR>
<Esc>
" " aggiungi spazio x indentatura:let m = m . "gq}" " formatta testo dopo il punto
:let m = m . "{dd" " togli linea vuota
:let m = m . "5lDJ" " metti testo dopo il punto
:execute m |" definisci mappatura
(
<>
Notazione |<>|. Notare che i caratteri vanni immessi come. sono scritti. ^W è "^" "W", nonCTRL-W
. Potete copiare/incollare questo testo in Vim se il flag '<' non è incluso in 'cpoptions'.) Notare che l'ultimo commento inizia con |", perché il comando ":execute" non accetta un commento normale (lo tratterebbe come un parametro). Dovete anche impostare 'textwidth' a un valore diverso da zero, per esempio;:set tw=70
Segue una mappatura che fa quasi lo stesso, ma prende l'indentatura per la lista dalla prima linea (Notare: questa mappatura è una singola linea molto lunga contenente parecchi spazi):
:map _f :set ai
*collapse* Le mappature seguenti riducono una sequenza di linee vuote (;b) o contenenti solo spazi (;n) a una sola linea<CR>
}{a
'mJO<Esc>
WWmmkD`mi<CR>
<Esc>
kkddpJgq}<Esc>
j:map ;b GoZ
<Esc>
:g/^$/.,/./-j<CR>
Gdd:map ;n GoZ
<Esc>
:g/^[<Tab>
]*$/.,/[^<Tab>
]/-j<CR>
Gdd
Comprimere i file di help *gzip-helpfile* Per chi fra voi abbia veramente poco spazio disco, è possibile comprimere i file di help, continuando a poterli visualizzare all'interno di Vim. Questo rallenta un po' il tempo di accesso ai file, e richiede che sia disponibile il programma gzip. (1) Comprimete tutti i file di help: "gzip doc/*.txt". (2) Andate in edit su "doc/tags" e cambiate ".txt" in ".txt.gz"::%s=\(\t.*\.txt\)\t=\1.gz\t=
(3) Aggiungete questa linea al vostro file vimrc:
set helpfile=
{nome-directory}
/help.txt.gzDove
{nome-directory}
è la directory in cui risiedono i file di help. Il plugin per |gzip| si occuperà della decompressione dei file. Dovete assicurarvi che $VIMRUNTIME sia impostato a dove si trovano gli altri file di Vim, quando non siano nella stessa posizione della directory "doc" compressa. Vedere |$VIMRUNTIME|.
Eseguire comandi della shell in una finestra *shell-window*
Alcuni hanno chiesto riguardo alla possibilità di eseguire una shell in una
delle finestre di Vim. La risposta: non è possibile! Aggiungere questa
funzionalità richiede di aggiungere un mucchio di pezzi di programma a Vim, il
che è una buona ragione "a sfavore". Dopo tutto, Vim è un editor di testi,
non ci si aspetta che svolga compiti diversi da questo. Comunque, per
ottenere qualcosa di simile, potreste provare a dividere in due il vostro
terminale o la vostra finestra con il programma "splitvt". Potete
probabilmente procurarvelo da qualche server ftp. La persona più esperta
riguardo a questo programma è Sam Lantinga <slouken@cs.ucdavis.edu>
.
In alternativa c'è il comando "window", disponibile nei sistemi BSD Unix, che
supporta molte finestre, una sopra l'altra. O il programma "screen",
disponibile nel sito www.uni-erlangen.de, che supporta una pila di finestre.
Modificare in esadecimale *hex-editing* *using-xxd* Vedere la sezione |23.4| del manuale utente. Se i vostri file binari usano una particolare estensione (tipo exe, bin, etc.) potete trovar utile automatizzare il procedimento con il seguente pezzettino di autocomando nel vostro file<.vimrc>
. Cambiate "*.bin", usato nell'esempio, con una qualsiasi lista di estensioni, separate da virgola, che indichi i file che volete modificare in maniera binaria:
" vim -b : edit in forma binaria usando il formato using xxd!
augroup Binary
au!
au BufReadPre *.bin let &bin=1
au BufReadPost *.bin if &bin | %!xxd
au BufReadPost *.bin set ft=xxd | endif
au BufWritePre *.bin if &bin | %!xxd -r
au BufWritePre *.bin endif
au BufWritePost *.bin if &bin | %!xxd
au BufWritePost *.bin set nomod | endif
augroup END
Uso della notazione<>
negli autocomandi *autocmd-<>* La notazione<>
non è riconosciuta come argomento in un :autocmd. Per evitare di dover usare dei caratteri speciali, potreste usare una mappatura che si cancella dopo essere stata usata, per poter adoperare la notazione<>
, e quindi richiamare la mappatura all'interno di un autocomando. Esempio: *map-self-destroy*" Per aggiungere automaticamente il nome del file alla lista menù.
" Usa una mappatura auto-distruttiva!
" 1. usare una linea nel buffer per convertire i '.' nel nome-file a \.
" 2. memorizzare il risultato nel registro '"'
" 3. aggiungere quel nome alla lista menù dei buffer
" AVVISO: ci sono alcuni effetti collaterali, come la sovrascrittura del
" contenuto corrente del registro, e la rimozione di mappature eventualmente
" presenti per il comando "i".
"
autocmd BufNewFile,BufReadPre * nmap i :nunmap i
<CR>
O<C-R>
%<Esc>
:.g/\./s/\./\\./g<CR>
0"9y$u:menu Buffers.<C-R>
9 :buffer<C-R>
%<C-V>
<CR>
<CR>
autocmd BufNewFile,BufReadPre * normal i
Un altro metodo, forse migliore, è di usare il comando ":execute". Nella stringa potete usare la notazione
<>
premettendo un backslash ('\'). Non dimenticatevi di raddoppiare il numero dei backslash già esistenti, e di mettere un backslash prima di '"'.autocmd BufNewFile,BufReadPre * exe "normal O\
<C-R>
%\<Esc>
:.g/\\./s/\\./\\\\./g\<CR>
0\"9y$u:menu Buffers.\<C-R>
9 :buffer \<C-R>
%\<C-V>
\<CR>
\<CR>
"Per un vero menù dei buffer, sarebbe meglio usare delle funzioni (vedere |:function|), ma in quel caso la notazione
<>
non è usata, il che impedisce di usarla qui come esempio.
Evidenziare la parentesi corrispondente *match-parens* Questo esempio mostra l'uso di alcuni funzionalità avanzate: - usare l'evento di autocomando |CursorMoved| - usare |searchpairpos()| per trovare una parentesi corrispondente - usare |synID()| per capire se il cursore è in una stringa o in un commento - usare |:match| per evidenziare qualcosa - usare un'espressione regolare |pattern| per trovare una posizione specifica in un file Questo andrebbe messo in un file script di Vim, perché usa variabili locali allo script. Salta le corrispondenze nelle stringhe o nei commenti, a meno che il cursore sia inizialmente in una stringa o commento. è necessario che sia attiva l'evidenziazione sintattica. Una versione lievemente più complessa è usata nel plugin |matchparen|.let s:evidenzia_paren = 0
function s:Evidenzia_Paren_Corrisp()
if s:evidenzia_paren
match none
let s:evidenzia_paren = 0
endif
let c_num_riga = line('.')
let c_colonna = col('.')
let c = getline(c_num_riga)[c_colonna - 1]
let plist = split(&coppia_corrisp, ':\|,')
let i = index(plist, c)
if i < 0
return
endif
if i % 2 == 0
let s_flags = 'nW'
let c2 = plist[i + 1]
else
let s_flags = 'nbW'
let c2 = c
let c = plist[i - 1]
endif
if c == '['
let c = '\['
let c2 = '\]'
endif
let s_skip ='synIDattr(synID(line("."), col("."), 0), "name") ' .
\ '=~? "string\\|comment"'
execute 'if' s_skip '|
let s_skip = 0
| endif'
let [m_num_riga, m_colonna] = searchpairpos(c, '', c2, s_flags, s_skip)
if m_num_riga > 0 && m_num_riga >= line('w0') && m_num_riga <= line('w$')
exe 'match Search /\(\%' . c_num_riga . 'l\%' . c_colonna .
\ 'c\)\|\(\%' . m_num_riga . 'l\%' . m_colonna . 'c\)/'
let s:evidenzia_paren = 1
endif
endfunction
autocmd CursorMoved,CursorMovedI * call s:Evidenzia_Paren_Corrisp()
autocmd InsertEnter * match none
vim:tw=78:ts=8:ft=help:norl: Per segnalazioni scrivere a vimdoc.it at gmail dot com oppure ad Antonio Colombo azc100 at gmail dot com
Generato da una versione modificata di vim2html in data mer 20 giu 2018, 20.48.28, CEST