current - Como efetivamente trabalhar com vários arquivos no Vim?




vim desktop (18)

Eu comecei a usar o Vim para desenvolver scripts em Perl e estou começando a achá-lo muito poderoso.

Uma coisa que eu gosto é poder abrir vários arquivos de uma só vez com por exemplo, vi main.pl maintenance.pl e então hop entre eles com:

:n
:prev

e ver quais arquivos estão abertos

:args

E para adicionar um arquivo, posso dizer:

:n test.pl

O que eu espero seria, então, adicionado à minha lista de arquivos, mas em vez disso, apaga minha lista de arquivos atual e quando eu digito :args eu só tenho test.pl aberto.

Então, como posso adicionar e remover arquivos à minha lista de argumentos?


Listagem

Para ver uma lista de buffers atuais, eu uso:

:ls

Abertura

Para abrir um novo arquivo, eu uso

:e ../myFile.pl

com finalização de tabulação aprimorada (coloque set wildmenu no seu .vimrc ).

Nota: você também pode usar :find que pesquisará um conjunto de caminhos para você, mas você precisa personalizar esses caminhos primeiro.

Comutação

Para alternar entre todos os arquivos abertos, eu uso

:b myfile

com conclusão de tabulação aprimorada (ainda set wildmenu ).

Nota:: :b# escolhe o último arquivo visitado, então você pode usá-lo para alternar rapidamente entre dois arquivos.

Usando janelas

Ctrl-W s e Ctrl-W v para dividir a janela atual horizontalmente e verticalmente. Você também pode usar :split e :vertical split ( :sp e :vs )

Ctrl-W w para alternar entre janelas abertas e Ctrl-W h (ou j ou k ou l ) para navegar pelas janelas abertas.

Ctrl-W c para fechar a janela atual e Ctrl-W o para fechar todas as janelas, exceto a atual.

Iniciar o vim com um sinalizador -o ou -O abre cada arquivo em sua própria divisão.

Com tudo isso eu não preciso de abas no Vim, e meus dedos encontram meus amortecedores, não meus olhos.

Nota: se você quiser que todos os arquivos acessem a mesma instância do Vim, inicie o Vim com a opção --remote-silent .


A maioria das respostas neste tópico está usando comandos simples do vim, o que é claro, mas eu pensei em fornecer uma resposta extensa usando uma combinação de plugins e funções que eu acho particularmente útil (pelo menos algumas dessas dicas vieram do arquivo de Gary Bernhardt) dicas de navegação ):

  1. Para alternar entre os dois últimos arquivos, pressione <leader> duas vezes. Eu recomendo atribuir <leader> para a barra de espaço:

    nnoremap <leader><leader> <c-^>
    
  2. Para se mover rapidamente em torno de um projeto, a resposta é uma solução de correspondência difusa, como CtrlP . Eu o vinculo a <leader>a para acesso rápido.

  3. No caso eu quero ver uma representação visual dos buffers atualmente abertos eu uso o plugin BufExplorer . Simples mas efetivo.

  4. Se eu quiser navegar em torno do sistema de arquivos eu usaria a linha de comando ou um utilitário externo (Quicklsilver, Afred etc.), mas para olhar para a estrutura atual do projeto Nerdtree é um clássico. Não use isso no lugar de 2 como seu método de localização do arquivo principal. Isso vai realmente te atrapalhar. Eu uso a ligação <leader>ff .

Estes devem ser suficientes para encontrar e abrir arquivos. A partir daí, é claro, use divisões horizontais e verticais. Em relação às divisões, considero estas funções particularmente úteis:

  1. Abra novas divisões em áreas menores quando não houver espaço suficiente e expanda-as na navegação. Consulte aqui os comentários sobre o que eles fazem exatamente:

    set winwidth=84
    set winheight=5
    set winminheight=5
    set winheight=999
    
    nnoremap <C-w>v :111vs<CR>
    nnoremap <C-w>s :rightbelow split<CR>
    set splitright
    
  2. Mude de divisão para dividir facilmente:

    nnoremap <C-J> <C-W><C-J>
    nnoremap <C-K> <C-W><C-K>
    nnoremap <C-L> <C-W><C-L>
    nnoremap <C-H> <C-W><C-H>
    

Algumas respostas neste tópico sugerem o uso de guias e outras sugerem usar o buffer para realizar a mesma coisa. Guias e Buffers são diferentes. Eu sugiro fortemente que você leia este artigo Vim Tab madness - Buffers vs Tabs

Aqui está um bom resumo que tirei do artigo:

Resumo:

  • Um buffer é o texto na memória de um arquivo.
  • Uma janela é uma viewport em um buffer.
  • Uma ficha de registro é uma coleção de janelas.

Ao usar vários arquivos no vim, eu uso principalmente esses comandos (com ~ 350 arquivos abertos):

  • :b <partial filename><tab> (salta para um buffer)
  • :bw (buffer limpe, remova um buffer)
  • :e <file path> (edite, abra um novo buffer>
  • pltags - permite saltar para sub-rotina / definições de método

Eu acho que você pode estar usando o comando errado para ver a lista de arquivos que você abriu.

Tente fazer um :ls para ver a lista de arquivos que você abriu e você verá:

   1 %a   "./checkin.pl"            line 1
  2 #    "./grabakamailogs.pl"     line 1
  3      "./grabwmlogs.pl"         line 0
  etc.

Você pode, então, saltar através dos arquivos, referindo-se a eles pelos números listados, por exemplo: 3b

ou você pode dividir sua tela digitando o número, mas usando sb ao invés de apenas b.

Como um desvio,% refere-se ao arquivo atualmente visível e # refere-se ao arquivo alternativo.

Você pode facilmente alternar entre esses dois arquivos, pressionando Ctrl Shift 6

Edit: like :ls você pode usar :reg para ver o conteúdo atual de seus registros, incluindo os registros 0-9 que contêm o que você excluiu. Isso é especialmente útil se você quiser reutilizar algum texto que você tenha excluído anteriormente.


Eu fiz um vídeo muito simples mostrando o fluxo de trabalho que eu uso. Basicamente eu uso o plugin Ctrl-P Vim, e mapeei a navegação do buffer para a tecla Enter.

Dessa forma, posso pressionar Enter no modo normal, ver a lista de arquivos abertos (que aparece em uma pequena janela nova na parte inferior da tela), selecionar o arquivo que desejo editar e pressionar Enter novamente. Para pesquisar rapidamente vários arquivos abertos, basta digitar parte do nome do arquivo, selecionar o arquivo e pressionar Enter.

Eu não tenho muitos arquivos abertos no vídeo, mas isso se torna incrivelmente útil quando você começa a ter muitos deles.

Como o plug-in classifica os buffers usando uma ordenação de MRU, basta pressionar Enter duas vezes e ir para o arquivo mais recente que você estava editando.

Depois que o plugin é instalado, a única configuração que você precisa é:

nmap <CR> :CtrlPBuffer<CR>

Claro que você pode mapeá-lo para uma chave diferente, mas acho que o mapeamento para entrar é muito útil.


Eu uso a linha de comando e git muito, então eu tenho esse alias no meu bashrc:

alias gvim="gvim --servername \$(git rev-parse --show-toplevel || echo 'default') --remote-tab"

Isto irá abrir cada novo arquivo em uma nova aba em uma janela existente e criará uma janela para cada repositório git. Então, se você abrir dois arquivos do repositório A e 3 arquivos do repositório B, você terá duas janelas, uma para o repositório A com duas guias e uma para o repositório B com três guias.

Se o arquivo que você está abrindo não estiver contido em um repositório git, ele irá para uma janela padrão.

Para pular entre as abas eu uso esses mapeamentos:

nmap <C-p> :tabprevious<CR>
nmap <C-n> :tabnext<CR>

Para abrir vários arquivos de uma só vez, você deve combinar isso com uma das outras soluções.


Eu uso comandos buffer - :bn (próximo buffer) :bp (buffer anterior) :buffers ( :buffers lista aberta) :b<n> (buffer aberto n) :bd (buffer de exclusão). :e <filename> será aberto em um novo buffer.


Eu uso o seguinte, isso lhe dá muitos recursos que você esperaria ter em outros editores, como Sublime Text / Textmate

  1. Use buffers não 'páginas de guia'. Os buffers são o mesmo conceito das guias em quase todos os outros editores.
  2. Se você quiser a mesma aparência de ter abas, pode usar o plugin vim-airline com a seguinte configuração em seu .vimrc : let g:airline#extensions#tabline#enabled = 1 . Isso exibe automaticamente todos os buffers como cabeçalhos de guias quando você não tem nenhuma guia aberta
  3. Use o tim vim-unimpaired Tim Pope que fornece [ b e ] b para mover para buffers anteriores / próximos, respectivamente (além de toda uma série de outras surpresas)
  4. Ter set wildmenu no seu .vimrc , em seguida, quando você digitar :b <file part> + Tab para um buffer, você obterá uma lista de possíveis buffers que você pode usar as setas esquerda / direita para percorrer
  5. Use o plugin vim-obsession Tim Pope para armazenar sessões que funcionam bem com a companhia aérea (eu tive muita dor com sessões e plugins )
  6. Use o plugin vim-vinegar Tim Pope. Isso funciona com o nativo :Explore mas facilita muito o trabalho. Você acabou de digitar - para abrir o explorador, que é a mesma chave para subir um diretório no explorador. Torna a navegação mais rápida (no entanto, com o fzf eu raramente uso isso)
  7. fzf (que pode ser instalado como um plugin vim) também é um localizador fuzzy muito poderoso que você pode usar para procurar arquivos (e buffers também). O fzf também toca muito bem com o fd (uma versão mais rápida do find)
  8. Use o Ripgrep com o vim-ripgrep para pesquisar em sua base de código e, em seguida, você pode usar :cdo nos resultados para pesquisar e substituir

Eu uso vários buffers que estão definidos no meu arquivo ~/.vimrc .

O mini-buffer explorer script é legal também para obter uma boa lista compacta de seus buffers. Então :b1 ou :b2 ... para ir ao buffer apropriado ou usar o mini-buffer explorer e tab através dos buffers.


Muitas respostas aqui! O que eu uso sem reinventar a roda - os plugins mais famosos (que não vão morrer tão cedo e são usados ​​por muitas pessoas) para serem ultra rápidos e nerds.

  • ctrlpvim / ctrlp.vim - para localizar o arquivo pelo nome de pesquisa difusa por sua localização ou apenas seu nome
  • jlanzarotta / bufexplorer - para procurar buffers abertos (quando você não se lembra de quantos arquivos você abriu e modificou recentemente e não se lembra onde eles estão, provavelmente porque você os pesquisou com Ag)
  • rking / ag.vim para pesquisar os arquivos em relação ao gitignore
  • scrooloose / nerdtree para ver a estrutura de diretório, lookaround, adicionar / excluir / modificar arquivos

ATUALIZAÇÃO : Recentemente estou usando o dyng / ctrlsf.vim para pesquisar com a visualização contextual (como a pesquisa Sublime) e mudei o mecanismo de ag para ripgrep . O desempenho é excelente.


Para adicionar à lista de args :

:argadd

Para excluir da lista de args :

:argdelete

No seu exemplo, você poderia usar :argedit test.pl para adicionar test.pl à lista args e editar o arquivo em uma única etapa.

:help args dá muito mais detalhes e uso avançado


Quando comecei a usar o VIM, não percebi que as guias deviam ser usadas como layouts de janelas diferentes, e o buffer serve a função de edição / troca de arquivos entre si. Na verdade, as abas iniciais nem estão lá antes da v7.0 e acabei de abrir um VIM dentro de uma aba do terminal (eu estava usando o gnome-terminal no momento), e alternar entre abas usando alt + numbers, já que pensei em usar comandos como : buffers,: bn e: bp foram demais para mim. Quando o VIM 7.0 foi lançado, descobri que é mais fácil gerenciar muitos arquivos e mudar para ele, mas recentemente percebi que os buffers devem sempre ser o caminho a seguir, a menos que uma coisa: você precise configurá-lo para que funcione corretamente.

Então, eu tentei o vim-airline e habilitei a barra de buffer visual, mas o gráfico estava tendo problemas com o meu iTerm2, então eu tentei um par de outros e parece que o MBE funciona melhor para mim. Eu também defino shift + h / l como atalhos, já que os originais (movendo para a cabeça / cauda da página atual) não são muito úteis para mim.

map <Sh> :bprev<Return>
map <Sl> :bnext<Return>

Parece ser até mais fácil que gt e gT, e: e é mais fácil que: tabnew também. Eu acho: bd não é tão conveniente quanto: q embora (MBE está tendo algum problema com isso), mas eu posso viver com todos os arquivos no buffer eu acho.


Se estiver usando apenas comandos internos do vim , o melhor que já vi para alternar entre vários buffers é este:

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

Ele combina perfeitamente os comandos :ls e :b - listando todos os buffers abertos e esperando que você insira o comando para trocar o buffer.

Dado o mapeamento acima no vimrc, assim que você digitar <Leader>f ,

  • Todos os buffers abertos são exibidos
  • Você pode:
    • Digite 23 para ir para o buffer 23,
    • Digite # para ir ao buffer alternativo / MRU,
    • Digite o nome parcial do arquivo e digite <Tab> ou <Ci> para preenchimento automático.
    • Ou apenas <CR> ou <Esc> para permanecer no buffer atual

Um instantâneo de saída para o mapeamento de chave acima é:

:set nomore|:ls|:set more
  1  h    "script.py"    line 1
  2 #h  + "file1.txt"    line 6  -- '#' for alternative buffer
  3 %a    "README.md"    line 17 -- '%' for current buffer
  4       "file3.txt"    line 0  -- line 0 for hasn't switched to
  5     + "/etc/passwd"  line 42 -- '+' for modified
:b '<Cursor> here'

No instantâneo acima:

  • Segunda coluna: %a para atual, h para oculto, # para anterior, vazio para não foi alterado para.
  • Terceira coluna: + para modificado.

Além disso, sugiro fortemente set hidden . Veja :help 'hidden' .


Se você for usar vários buffers, acho que a coisa mais importante é definir oculto para que ele permita que você alterne os buffers mesmo se você tiver alterações não salvas no que estiver deixando.


Vim (mas não o original Vi!) Tem abas que eu acho (em muitos contextos) superiores aos buffers. Você pode dizer :tabe [filename] para abrir um arquivo em uma nova aba. Andar de bicicleta entre as guias é feito clicando na guia ou pelas combinações de teclas [ n ] gt e gT . Vim gráfico ainda tem guias gráficas.


Você pode ser um louco absoluto e apelido de vim para vim -p , adicionando em seu .bashrc :

alias vim="vim -p"

Isso resultará na abertura de vários arquivos do shell nas abas, sem precisar invocar :tab ball no vim depois.


tente seguir mapas para facilitar a edição de vários arquivos

"janelas divididas

nmap <leader>sh :leftabove vnew<CR>

nmap <leader>sl :rightbelow vnew<CR>

nmap <leader>sk :leftabove new<CR>

nmap <leader>sj :rightbelow new<CR>

" movendo-se em torno de

nmap <Cj> <Cw>j

nmap <Ck> <Cw>k

nmap <Cl> <Cw>l

nmap <Ch> <Cw>h





vi