Como posso fechar um buffer sem fechar a janela?

As visualizações em várias camadas do Vim (Windows, Buffers e Tabs) me deixaram um pouco confuso. Digamos que eu divida a exibição (: sp) e selecione um buffer diferente para exibir em cada janela. Agora eu quero fechar um dos buffers, mas não quero que a janela feche (após o fechamento, pode exibir o próximo buffer da lista ou um buffer vazio, não importa). Como posso fazer isso?

Obrigado.

Existe um script no wiki do Vim para fazer isso. Não acho que haja um embutido que faça o que você quer.

A última versão do vim-bufkill está no github .

Eu baguncei um pouco com isso e finalmente descobri:

:bp | sp | bn | bd

Esta é a versão copiar / colar para mapeamento de teclas:

:bp<bar>sp<bar>bn<bar>bd<CR>

Eu testei bastante e funciona de forma consistente em várias condições. Quando usado no último buffer, ele deixará você com um novo buffer em branco.

Jogue isso em seu .vimrc:

map <leader>q :bp<bar>sp<bar>bn<bar>bd<CR>

Reinicie o Vim ou apenas :source ~/.vimrcpara que as alterações tenham efeito. Da próxima vez que você quiser fechar um buffer, basta digitar: \q(se \for a sua chave líder)

Eu pesquisei por isso hoje e encontrei

:b#|bd#

que muda a janela atual para o buffer aberto anteriormente e apaga / oculta o buffer do qual você acabou de trocar.

Isso requer pelo menos dois buffers conhecidos.

Se outra janela, mas a atual mostrar o mesmo buffer, isso ainda destruirá a divisão. Você pode alterar todas as janelas para o buffer aberto anteriormente com

:windo b#

Eu adicionei mais detalhes sobre o comando anterior que discute um mapeamento para ele (e algumas armadilhas) em uma resposta a uma pergunta semelhante .

nmap <leader>d :bprevious<CR>:bdelete #<CR>

Funciona como deveria até que um buffer seja aberto em várias janelas. Bom o suficiente, a menos que você queira usar os scripts maiores que existem.

Editar: é isso que eu uso agora:

function! BufferDelete()
    if &modified
        echohl ErrorMsg
        echomsg "No write since last change. Not closing buffer."
        echohl NONE
    else
        let s:total_nr_buffers = len(filter(range(1, bufnr('$')), 'buflisted(v:val)'))

        if s:total_nr_buffers == 1
            bdelete
            echo "Buffer deleted. Created new buffer."
        else
            bprevious
            bdelete #
            echo "Buffer deleted."
        endif
    endif
endfunction

Acho que é isso que você está procurando

http://www.vim.org/htmldoc/windows.html#window-moving

Experimente isto:

Procure seu id de buffer usando

:buffers

você verá uma lista de buffers como

1  a.cpp
2  b.py
3  c.php

se você deseja remover b.py do buffer

:2bw

se você deseja remover / fechar todos os buffers

:1,3bw

Para quem usa NERDTree.

Corrijo isso usando este plugin https://github.com/jistr/vim-nerdtree-tabs e agora posso fechar o único buff / arquivo / guia sem fechar a janela.

Depois de instalar o plugin acima, coloque o seguinte código no meu .vimrc:

let g:nerdtree_tabs_autoclose=0

A descrição da variável acima é: Feche a guia atual se houver apenas uma janela nela e for NERDTree (padrão 1)

Mais informações aqui: https://github.com/jistr/vim-nerdtree-tabs#configuration

Não acho que haja uma maneira única de fazer isso, mas você pode fazer :enewou :lslistar seus buffers e trocar para um diferente usando :b [number].

Uma vez que você tenha um buffer diferente na janela :bd #, o buffer anterior será excluído da janela e, como o buffer atual ainda existe, a janela não será fechada.

Eu costumava usar :

:bp<bar>sp<bar>bn<bar>bd<CR>

Mas descobri certas ocasiões em que fechou minha janela.

Recentemente, percebi que sempre uso isso quando estou trabalhando em um projeto e preciso abrir o meu rapidamente .tmux.conf .zshrcantes de voltar ao trabalho.

Para este uso, acho melhor:

• voltar para o buffer em que estava trabalhando anteriormente C-6
• digite :bd#para eliminar o tampão anterior (I mapearam-lo assim: nnoremap <leader>d :bd#<CR>)

Isso me permite controlar o buffer para o qual estou voltando e parece mais natural.

Seria

:enew

faça o que você quiser? ele editará um novo buffer sem nome na janela atual, deixando o arquivo existente aberto em qualquer outra janela.

Minha solução favorita para isso é o plugin bufkill.vim ( GitHub ). Ele fornece versões alternativas dos vários:b comandos -prefix que funcionam da mesma forma que suas contrapartes, mas deixam a janela aberta. Eles exibem qualquer que seja o último buffer visível contido, ou um buffer vazio / novo se não houver nenhum buffer anterior.

Da documentação:

Quando você deseja descarregar / excluir / limpar um buffer, use:
  : bun /: bd /: bw para fechar a janela também (comando vim), ou
  : BUN /: BD /: BW para deixar a (s) janela (s) intacta (s) (este script).

Para 'fechar' uma visualização, use :hid[e]. Funciona se você conseguiu dividir a janela de exibição ou abriu vários arquivos. Você não pode ocultar o último buffer em exibição.

1 Outra dica que me ajudou: use :e ./path/to/file.workpara abrir um arquivo no viewport sem dividir a janela.

PS Depois de dois dias no vim, ainda tenho problemas para encontrar os comandos de ajuda precisos. Espero que isso ajude alguém a continuar trabalhando até que consiga realmente tempo para entender o vim.

Aqui está uma função vimscript muito legível, que lida bem com todos os casos ,

• se comportar de forma semelhante ao integrado :bd(se apenas uma janela, basta invocá-la!),
  • emitir um aviso e não fazer nada se o buffer for modificado.
  • se não houver outro buffer, crie um, via :enew.
  • se houver buffer alternativo e buffer-listestiver ativado, mude para ele, senão vá em seguida, via :bn.
• comportamento mais razoável para layout de múltiplas janelas
  • não fechando nenhuma janela,
  • sempre fique na janela original.
  • para cada janela que exibe o buffer atual, siga as instruções acima e exclua o buffer atual antigo.

nnoremap <Leader> b: chame DeleteCurBufferNotCloseWindow () <CR>

func! DeleteCurBufferNotCloseWindow () abortar
    se & modificado
        echohl ErrorMsg
        echom "E89: nenhuma gravação desde a última alteração"
        echohl Nenhum
    elseif winnr ('$') == 1
        bd
    senão "janela múltipla
        deixe oldbuf = bufnr ('%')
        deixe oldwin = winnr ()
        enquanto 1 "todas as janelas que exibem oldbuf permanecerão abertas
            se buflisted (bufnr ('#'))
                b #
            outro
                bn
                deixe curbuf = bufnr ('%')
                if curbuf == oldbuf
                    enew "oldbuf é o único buffer, crie um
                fim se
            fim se
            deixe win = bufwinnr (oldbuf)
            se ganhar == -1
                pausa
            else "há outra janela que exibe oldbuf
                exec win 'wincmd w'
            fim se
        no fim
        "excluir oldbuf e restaurar janela para oldwin
        exec oldbuf 'bd'
        exec oldwin 'wincmd w'
    fim se
endfunc

Se você é como eu e veio aqui tentando fazer o contrário , feche a janela sem fechar o buffer, você pode fazer isso via:

:close

Uma versão simples que eu uso pessoalmente é

:bp|bd#

Ele vai para o buffer anterior e exclui o outro buffer (que na verdade é o original de onde saltamos). Isso faz o que você esperaria em 99% dos casos, sem scripts complicados.

Como um atalho de teclado, uso o seguinte

nnoremap <silent> <Leader>c :bp<BAR>bd#<CR>

use ": bd" como um comando.