Il modo più veloce per passare a un buffer in vim?

Un modo per selezionare un buffer in vim potrebbe essere quello di sfogliare l'elenco dei buffer, usando i comandi standard come :lso con un codice plugin / vimscript esterno per sfogliare un elenco in una finestra .

Diciamo che voglio passare direttamente a un buffer, il più velocemente possibile.

Per attraversare l'elenco dei buffer in modalità sequenziale, ora uso le <C-J> <C-K>scorciatoie, avendo impostato nel mio .vimrc:

" move among buffers with CTRL
map <C-J> :bnext<CR>
map <C-K> :bprev<CR>

Un altro modo (accesso diretto) potrebbe essere la commutazione in base al numero : conoscendo il numero del buffer, è possibile passare direttamente inserendo il numero del buffer seguito da <C-^>. Quindi, se voglio passare al buffer numero 5, premo 5<C-^>.

Ma questo non sembra funzionare per me (uso vim 7.4 su Ubuntu Box, da un guest Windows, con tastiera italiana ). Ho il sospetto che sia perché il ^personaggio è nel tasto maiuscolo ^ìnella tastiera italiana, quindi per farlo ^devo premereSHIFT-^

Qualche idea?

Il :bcomando può anche prendere una sottostringa del nome del file del buffer in cui si desidera viaggiare, il che è molto conveniente.

Ad esempio, se si dispone di tre buffer foo, bare baz, quindi

• :b barpasserà al barfile.

• :b opasserà al foofile.

• :b ati darà un errore perché potrebbe significare uno baro baz, ma puoi correggere il nome per essere più specifico con, ad esempio : ↑ r Enter,.

Questo può essere molto utile, perché significa invece di

:buffer very/very/long/path/to/a/veryVeryLongFileName.txt

puoi fare qualcosa del genere

:b LongFileName

che è molto più breve e più facile.

Questo comando può anche prendere un numero, se vuoi usarlo:

:b 5

Questo è quello che uso:

nnoremap <Leader>b :ls<CR>:b<Space>

Ora premendo \bverranno elencati i buffer disponibili e preparati :bper te.

Quindi puoi semplicemente digitare il numero del buffer e premere Invio.

Oppure puoi digitare parte del nome file e premere Invio. (Comunque di solito premo Tab prima di premere Invio, per verificare di avere il buffer giusto. Altrimenti, continuo a pedalare con Tab fino a quando non ottengo quello che volevo.)

In effetti, utilizzo una versione leggermente ottimizzata di quanto sopra:

nnoremap <C-e> :set nomore <Bar> :ls <Bar> :set more <CR>:b<Space>

Ciò impedirà la -- More --visualizzazione del prompt quando si hanno più buffer delle linee disponibili per visualizzarli.

Ma se in genere l' 'more'opzione è disabilitata, questa mappatura ti infastidirà davvero, perché riattiva l' 'more'opzione dopo averlo fatto ls!

:CtrlPBufferdal plugin CtrlP (4k ★)

La caratteristica principale di questo plugin è di fornire una corrispondenza fuzzy per aprire comodamente un buffer diverso con feedback visivo.

Aprire l'elenco di buffer fuzzy con :CtrlPBuffero premere <C-p>seguito da <C-b>per cambiare la modalità in buffer.

Immettere un numero sufficiente di caratteri per specificare il buffer che si desidera aprire.
È inoltre possibile utilizzare <C-j>e <C-k>per scorrere l'elenco e selezionare manualmente il buffer.

Personalizzazione

Se desideri aprire immediatamente l'elenco dei buffer con <C-p>, aggiungi la seguente riga al tuo vimrc:

let g:ctrlp_cmd = 'CtrlPBuffer'

È possibile utilizzare <C-f/b>per cambiare la modalità della finestra ctrlp.

Io personalmente uso let g:ctrlp_cmd = 'CtrlPMRU'. L'elenco (mru) utilizzato più di recente contiene anche i buffer aperti. Se si utilizzano diverse modalità ctrlp e si desidera attenersi all'ultima modalità, è possibile impostare let g:ctrlp_cmd = 'CtrlPLastMode [--dir]'.

Plugin simili

Esistono più plugin che forniscono un elenco buffer con un prompt interattivo con corrispondenza fuzzy, ad es

• fzf.vim (4k ★) di Junegunn (+ terminal, vai)
• command-t di Wincent (+ ruby)
• denite.nvim di Shougo (+ python3, vim8 o neovim)

Il lato oscuro contro il lato chiaro

(ad es. installazione di vim pesantemente plug-in rispetto al modo vim)

Prima di decidere di utilizzare questi plugin più complessi, studia le risposte di @Doorknob e @joeytwiddle . In particolare, controlla il one-liner se uno di loro soddisfa già le tue esigenze.

1. nnoremap <Leader>b :b <C-d>
2. nnoremap <Leader>b :ls<Cr>:b<Space>

L'installazione dei plugin solo per la commutazione del buffer potrebbe essere eccessiva. Vedi anche le osservazioni su https://www.vi-improved.org/recommendations e l'articolo di Drew Neil "Sull'affilatura della sega" .

Oltre alle risposte davvero utili di joeytwiddle e Doorknob non dimenticare :b#, che passa al buffer utilizzato più di recente. Può anche essere fatto solo con <C-^>. Quando si hanno molti buffer e si passa costantemente da uno all'altro, il buffer più recente è in genere la destinazione più comune.

Personalmente uso una combinazione di molti metodi. Quando lavoro principalmente con due buffer e il resto viene aperto solo per riferimento occasionale, tendo a passare da uno all'altro con :b#o <C-^>. Quando devo lavorare con più di loro e cambiare più spesso, uso i numeri (come nella punta di joeytwiddle) o parte dei nomi (come nella punta di Doorknob) con TAB per completarli. Quando i nomi sono confusi e ci sono molti buffer aperti (di solito oltre 10), uso il plug-in Ctrl-P più spesso ( https://github.com/kien/ctrlp.vim ) Con due sequenze di tasti veloci ho ottenuto l'elenco di tutti e sono in grado di utilizzare una potente ricerca fuzzy su di essi per trovare rapidamente quello che voglio.

[be ]bdal plugin vim-unimpaired(> 2k ★)

Se ti capita di aver installato vim-unimpaired, puoi usare

• [b( :bp[revious]) e
• ]b( :bn[ext])

per il ciclismo attraverso buffer aperti. Non è necessario definire mappature più preziose per gli stessi comandi. Inoltre, è possibile saltare al primo e all'ultimo buffer

• [B( :bf[irst]) e
• ]B( :bl[ast]).

Ci sono molte più mappature di parentesi contenute in vim-unimpairedcui potresti trovare utile. Seguono tutti lo stesso schema che semplifica la memorizzazione.

Il lato oscuro contro il lato chiaro

Questo plugin può essere considerato leggero e 'vimish'. È indicato dalla community #vim come plug-in "non dannoso".

Attualmente sto usando il tasto <Leader>+ numberper passare. La chiave del leader è la mia <space>chiave. Uso anche vim-compagnia aerea per mostrare il buffer nr nella parte superiore della finestra.

" airline settings
let g:airline#extensions#tabline#buffer_nr_show = 1
let g:airline#extensions#tabline#enabled = 1

Mentre il bufnr spesso supera 10, quindi ottimizzo la mia mappatura, se numberè l'unica corrispondenza, cambio buffer immediatamente, altrimenti aspetto più input numerico o <space>tasto per confermare:

nnoremap <expr> <Leader>1 tweak#wtb_switch#key_leader_bufnum(1)
nnoremap <expr> <Leader>2 tweak#wtb_switch#key_leader_bufnum(2)
nnoremap <expr> <Leader>3 tweak#wtb_switch#key_leader_bufnum(3)
nnoremap <expr> <Leader>4 tweak#wtb_switch#key_leader_bufnum(4)
nnoremap <expr> <Leader>5 tweak#wtb_switch#key_leader_bufnum(5)
nnoremap <expr> <Leader>6 tweak#wtb_switch#key_leader_bufnum(6)
nnoremap <expr> <Leader>7 tweak#wtb_switch#key_leader_bufnum(7)
nnoremap <expr> <Leader>8 tweak#wtb_switch#key_leader_bufnum(8)
nnoremap <expr> <Leader>9 tweak#wtb_switch#key_leader_bufnum(9)




func! tweak#wtb_switch#key_leader_bufnum(num)
    let l:buffers = tweak#wtb_switch#buflisted()
    let l:input = a:num . ""

    while 1

        let l:cnt = 0
        let l:i=0
        " count matches
        while l:i<len(l:buffers)
            let l:bn = l:buffers[l:i] . ""
            if l:input==l:bn[0:len(l:input)-1]
                let l:cnt+=1
            endif
            let l:i+=1
        endwhile

        " no matches
        if l:cnt==0 && len(l:input)>0
            echo "no buffer [" . l:input . "]"
            return ''
        elseif l:cnt==1
            return ":b " . l:input . "\<CR>"
        endif

        echo ":b " . l:input

        let l:n = getchar()

        if l:n==char2nr("\<BS>") ||  l:n==char2nr("\<C-h>")
            " delete one word
            if len(l:input)>=2
                let l:input = l:input[0:len(l:input)-2]
            else
                let l:input = ""
            endif
        elseif l:n==char2nr("\<CR>") || (l:n<char2nr('0') || l:n>char2nr('9'))
            return ":b " . l:input . "\<CR>"
        else
            let l:input = l:input . nr2char(l:n)
        endif

        let g:n = l:n

    endwhile
endfunc

func! tweak#wtb_switch#buflisted()
  return filter(range(1, bufnr('$')), 'buflisted(v:val)')
endfunc

Il codice viene incollato da qui

A proposito, io uso anche <S-h>e <S-l>per :bpe :bn, o :tabpe :tabnse attualmente è aperta più di una pagina. È abbastanza intuitivo per me.

In questi giorni sto usando [buffer_number]<Ctrl-^>per cambiare buffer perché è molto veloce.

Ma come sapere il numero del buffer? Uso MiniBufExplorer in modo da poter sempre vedere i numeri di buffer nella parte superiore di Vim.

Uso anche la seguente mappatura, perché <C-^>è un po 'difficile da raggiungere con una mano.

:nmap <C-E> <C-^>

Su una macchina nuova senza configurazione, torno a :b [part_of_filename]<Tab><Enter>