¿Cuál es una forma más eficiente de usar tampones?

Últimamente he estado reduciendo drásticamente la cantidad de complementos que estoy usando, así que estoy buscando respuestas usando solo las funciones integradas de Vim.

He estado notando una falla en mi flujo de trabajo cuando estoy editando muchos buffers: estoy en un buffer y quiero cambiar a otro del cual no recuerdo el nombre y que no es el buffer alternativo . Por lo tanto, :b#no es posible usarlo y usar la finalización con el comando :btampoco es conveniente.

Para hacer eso estaba haciendo lo siguiente:

• Primer uso :bufferspara obtener la lista de buffers abiertos
• Recuerda el número del búfer que quiero usar
• Presione Enterpara cerrar la lista de buffers
• Use :bXcon Xel número del búfer a usar.

Este flujo de trabajo me pareció bastante pesado, así que agregué las siguientes líneas a mi .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 

Esto me da un comando :B(y un mapeo) que llama a la función :buffersesperar una entrada y finalmente llama :bseguido de la entrada.

Funciona bien, pero me sorprende que haya tenido que desarrollar dicha función: por lo general, Vim tiene un flujo de trabajo predeterminado bastante eficiente, por lo que me pregunto si hay una mejor manera de cambiar a un búfer del que no sé nada, excepto que ya se abrió en mi sesión de edición.

He estado notando una falla en mi flujo de trabajo cuando estoy editando muchos buffers: estoy en un buffer y quiero cambiar a otro del cual no recuerdo el nombre y que no es el buffer alternativo . Por lo tanto, :b#no es posible usarlo y usar la finalización con el comando :btampoco es conveniente.

Por el contrario, considero que completar las pestañas es extremadamente conveniente. Establecer las opciones correctas en valores que funcionen para usted puede ayudar mucho. Estas son las líneas relevantes de mi vimrc (funcionan para mí pero pueden no funcionar para usted, así que no las copie simplemente) :

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 eso, el búfer correcto rara vez está a más de cinco o seis pulsaciones de teclas:

Esto me da un comando :B(y un mapeo) que llama a la función :buffersesperar una entrada y finalmente llama :bseguido de la entrada.

A Barry Arthur se le ocurrió una solución mucho más simple hace años que se ha vuelto bastante popular desde entonces:

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

de las cuales propuse una variante un poco más versátil hace un par de años:

nnoremap gb :ls<CR>:b

Ya que estamos hablando de vimscript, aquí hay una pequeña y agradable función que escribí que "autocompone" la línea de comandos con el código auxiliar de comando correcto después de comandos tipo lista como :lso :ilist. La ventaja de esa función sobre las asignaciones anteriores es que no tengo que recordar asignaciones específicas. Funciona igual que Vim, pero con un pequeño giro .

" 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

Dicho esto, soy un gran defensor de la "navegación basada en símbolos" sobre la "navegación basada en archivos". Cuando corresponde, la navegación basada en símbolos es mucho más rápida y mucho más económica que la navegación basada en archivos.

El último GIF muestra un medio de navegación basada en símbolos, por cierto. El ejemplo es tonto pero ... bueno.

Encontré el mismo problema hace un tiempo y encontré una solución:

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

Esto abrirá la lista de búfer y, sin ocultarla, le dará la opción de cambiar el búfer.

Creo que tiene sentido que Vim no tenga una opción de "lista y selección" aquí, estas son dos acciones separadas. Pero Vim es lo suficientemente poderoso como para combinar el comando juntos.

Piense en ello como la filosofía de Unix: haga una cosa y hágalo bien.

:buffersenumera los búferes y le :buffer xxxpermite seleccionar uno.

Por un tiempo usé la técnica de nobe4 como esta:

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

Luego comencé a usar Tab-complete con eso (como sugiere romainl)

Pero más recientemente he encontrado que el método más rápido con la menor cantidad de pulsaciones de teclas es usar:

{count} CTRL-^

Esto no es tan diferente de, :b#<Enter>pero como usted dice, ¡ necesita saber el número de búfer!

Entonces, para eso, ejecuto el complemento MiniBufExplorer , que muestra una lista de nombres de archivos en la parte superior (como casi cualquier otro editor). Estoy seguro de que hay numerosas alternativas.

Finalmente, dado que Ctrl-^es un poco exagerado para mis dedos, y esta es una operación muy común, lo moví a Ctrl-E. La implementación para eso no es demasiado compleja:

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

Entonces mi proceso actual de cambio de búfer es algo como esto:

1. Mira MiniBufExplorer
2. Golpear 3 Ctrl-E

Lamentablemente, MBE y el script anterior no son Vim incorporados, como solicitó. Cuando estoy en una máquina remota sin configuración, solo uso :b [partial]y tabulación completa.