Qual è un modo più efficiente di utilizzare i buffer?

Ultimamente ho ridotto drasticamente il numero di plugin che sto usando, quindi cerco risposte usando solo le funzionalità integrate di Vim.

Ho notato un difetto nel mio flusso di lavoro quando sto modificando molti buffer: sono su un buffer e voglio passare a un altro dei quali non ricordo il nome e che non è il buffer alternativo . Quindi l'uso :b#non è possibile e l'utilizzo del completamento con il comando :bnon è conveniente neanche.

Per fare ciò stavo facendo quanto segue:

• Primo utilizzo :buffersper ottenere l'elenco dei buffer aperti
• Ricorda il numero del buffer che voglio usare
• Premere Enterper chiudere l'elenco dei buffer
• Utilizzare :bXcon Xil numero del buffer da utilizzare.

Questo flusso di lavoro mi è sembrato piuttosto pesante, quindi ho aggiunto le seguenti righe al mio .vimrc:

" Improve the navigation in the buffers 
nnoremap <Leader><S-b> :B<CR> 
command! B call Buffers() 

function! Buffers() 
    execute "buffers" 
    let buffer=input("Enter a buffer:") 
    execute "b" . buffer 
endfunction 

Questo mi dà un comando :B(e una mappatura) che chiama la funzione :buffersaspetta un input e infine chiama :bseguito dall'input.

Funziona bene ma sono sorpreso di dover sviluppare una tale funzione: di solito Vim ha un flusso di lavoro predefinito piuttosto efficiente, quindi mi chiedo se c'è un modo migliore per passare a un buffer di cui non so nulla tranne che è già stato aperto nella mia sessione di editing.

Ho notato un difetto nel mio flusso di lavoro quando sto modificando molti buffer: sono su un buffer e voglio passare a un altro dei quali non ricordo il nome e che non è il buffer alternativo . Quindi l'uso :b#non è possibile e l'utilizzo del completamento con il comando :bnon è conveniente neanche.

Al contrario, trovo che il completamento delle schede sia estremamente conveniente. Impostare le giuste opzioni su valori che funzionano per te può essere di grande aiuto. Queste sono le linee pertinenti della mia vimrc (funzionano per me ma potrebbero non funzionare per te, quindi non limitarti a copiarle) :

nnoremap ,b :buffer *
set wildmenu
set wildignore+=*.swp,*.bak
set wildignore+=*.pyc,*.class,*.sln,*.Master,*.csproj,*.csproj.user,*.cache,*.dll,*.pdb,*.min.*
set wildignore+=*/.git/**/*,*/.hg/**/*,*/.svn/**/*
set wildignore+=*/min/*,*/vendor/*,*/node_modules/*,*/bower_components/*
set wildignore+=tags,cscope.*
set wildignore+=*.tar.*
set wildignorecase
set wildmode=full

Con ciò, il buffer giusto è raramente a più di cinque o sei sequenze di tasti:

Questo mi dà un comando :B(e una mappatura) che chiama la funzione :buffersaspetta un input e infine chiama :bseguito dall'input.

Barry Arthur ha inventato anni fa una soluzione molto più semplice che è diventata molto popolare da allora:

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

di cui ho proposto una variante leggermente più versatile un paio di anni fa:

nnoremap gb :ls<CR>:b

Dato che stiamo parlando di vimscript, ecco una bella piccola funzione che ho scritto che "popola automaticamente" la riga di comando con lo stub di comando giusto dopo comandi simili a elenchi come :lso :ilist. Il vantaggio di quella funzione rispetto alle mappature sopra è che non devo ricordare mappature specifiche. Funziona proprio come Vim, ma con una leggera svolta .

" smooth listing
cnoremap <expr> <CR> <SID>CCR()

function! s:CCR()
    if getcmdtype() == ":"
        let cmdline = getcmdline()
            if cmdline =~ '\v\C^(dli|il)' | return "\<CR>:" . cmdline[0] . "jump  " . split(cmdline, " ")[1] . "\<S-Left>\<Left>"
        elseif cmdline =~ '\v\C^(cli|lli)' | return "\<CR>:silent " . repeat(cmdline[0], 2) . "\<Space>"
        elseif cmdline =~ '\C^changes' | set nomore | return "\<CR>:sil se more|norm! g;\<S-Left>"
        elseif cmdline =~ '\C^ju' | set nomore | return "\<CR>:sil se more|norm! \<C-o>\<S-Left>"
        elseif cmdline =~ '\C^ol' | set nomore | return "\<CR>:sil se more|e #<"
        elseif cmdline =~ '\C^undol' | return "\<CR>:u "
        elseif cmdline =~ '\C^ls' | return "\<CR>:b"
        elseif cmdline =~ '/#$' | return "\<CR>:"
        else | return "\<CR>" | endif
    else | return "\<CR>" | endif
endfunction

Detto questo, sono un grande sostenitore della "navigazione basata su simboli" rispetto alla "navigazione basata su file". Se applicabile, la navigazione basata su simboli è molto più veloce e molto più economica della navigazione basata su file.

A proposito, l' ultima GIF mostra un mezzo di navigazione basata su simboli. L'esempio è sciocco ma ... vabbè.

Ho riscontrato lo stesso problema qualche tempo fa e ho trovato una soluzione:

nnoremap <leader>b :buffers<CR>:buffer<space>

Questo aprirà l'elenco dei buffer e senza nasconderlo, ti darà la possibilità di cambiare buffer.

Penso che abbia senso che Vim non abbia un'opzione "elenca e seleziona" qui, queste sono due azioni separate. Ma Vim è abbastanza potente da combinare il comando insieme.

Pensala come la filosofia Unix: fai una cosa e fallo bene.

:bufferselenca i buffer e :buffer xxxconsente di selezionarne uno.

Per un po 'ho usato la tecnica di nobe4 in questo modo:

nnoremap <Leader>b :set nomore<Bar>:ls<Bar>:set more<CR>:b<Space>

Poi ho iniziato a usare Tab-completamento con quello (come suggerisce Romainl)

Ma più recentemente ho trovato il metodo più veloce con il minor numero di tasti da utilizzare:

{count} CTRL-^

Questo non è così diverso da :b#<Enter>ma, come dici tu, devi conoscere il numero del buffer!

Quindi per questo eseguo il plugin MiniBufExplorer , che mostra un elenco di nomi di file in alto (come quasi tutti gli altri editor). Sono sicuro che ci sono numerose alternative.

Infine, poiché Ctrl-^è un po 'un allungamento per le dita, e questa è un'operazione molto comune, l'ho spostato su Ctrl-E. L' implementazione per questo non è troppo complessa:

nnoremap <C-E> :<C-U>call SwitchToBuffer()<CR>

function! SwitchToBuffer()
  if v:count > 0
    exec v:count . "b"
    return
  endif

  " Whatever you want to do if you didn't provide a count
  " In this case, fall back to nobe4's technique:
  call feedkeys(":ls\n:b ")
endfunction

Quindi il mio attuale processo di commutazione del buffer va in questo modo:

1. Guarda MiniBufExplorer
2. Colpire 3 Ctrl-E

Purtroppo MBE e lo script sopra non sono integrati in Vim, come da lei richiesto. Quando sono su una macchina remota senza configurazione, utilizzo solo il :b [partial]completamento con Tab.