Como trabalhar efetivamente com vários arquivos no Vim

Comecei a usar o Vim para desenvolver scripts Perl e estou começando a achar muito poderoso.

Uma coisa que eu gosto é poder abrir vários arquivos de uma só vez com:

vi main.pl maintenance.pl

e então pule entre eles com:

:n
:prev

e veja com qual arquivo é aberto:

:args

E para adicionar um arquivo, posso dizer:

:n test.pl

que espero que seja adicionado à minha lista de arquivos, mas apaga minha lista de arquivos atual e, quando digito :args, só tenho test.plaberto.

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

Por que não usar guias (introduzidas no Vim 7)? Você pode alternar entre as guias com :tabne :tabp, Com :tabe <filepath>você pode adicionar uma nova guia; e com um regular :qou :wqvocê fecha uma guia. Se você mapear :tabne :tabppara suas teclas F7/, F8poderá alternar facilmente entre arquivos.

Se não há que muitos arquivos ou você não tem Vim 7, você também pode dividir a tela em vários arquivos: :sp <filepath>. Em seguida, você pode alternar entre as telas divididas com Ctrl+ We, em seguida, uma tecla de seta na direção que deseja mover (ou em vez das teclas de seta, wpara a próxima e Wpara a tela dividida anterior)

Listagem

Para ver uma lista dos buffers atuais, eu uso:

:ls

Abertura

Para abrir um novo arquivo, eu uso

:e ../myFile.pl

com conclusão aprimorada da guia (coloque a set wildmenusua .vimrc).

Nota: você também pode usar o :findque pesquisará um conjunto de caminhos para você, mas precisará personalizá-los primeiro.

Comutação

Para alternar entre todos os arquivos abertos, eu uso

:b myfile

com conclusão aprimorada da guia (ainda set wildmenu).

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

Usando janelas

Ctrl-W se Ctrl-W vpara dividir a janela atual horizontal e verticalmente. Você também pode usar :splite :vertical split( :spe :vs)

Ctrl-W wpara alternar entre janelas abertas e Ctrl-W h(ou jou kou l) para navegar pelas janelas abertas.

Ctrl-W cfechar a janela atual e Ctrl-W ofechar todas as janelas, exceto a atual.

Iniciar o vim com um sinalizador -oou -Oabre cada arquivo em sua própria divisão.

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

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

:ls

para lista de buffers abertos

• :bp buffer anterior
• :bn próximo buffer
• :bn( num número) mova para o enésimo buffer
• :b <filename-part> com tecla de tabulação que fornece preenchimento automático (incrível !!)

Em algumas versões do vim, bne bpsão reais bnexte bpreviousrespectivamente. A conclusão automática da guia é útil nesse caso.

Ou, quando estiver no modo normal, use ^para alternar para o último arquivo em que estava trabalhando.

Além disso, você pode salvar sessões do vim

:mksession! ~/today.ses

O comando acima salva os buffers de arquivo aberto atuais e as configurações em ~/today.ses . Você pode carregar essa sessão usando

vim -S ~/today.ses

Sem problemas para lembrar de onde você parou ontem. ;)

Para adicionar à argslista:

:argadd

Para excluir da argslista:

:argdelete

No seu exemplo, você pode usar :argedittest.pl para adicionar test.pl à argslista e editar o arquivo em uma etapa.

:help args fornece muito mais detalhes e uso avançado

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

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

Tente fazer um :lspara 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 navegar pelos arquivos consultando-os pelos números listados, por exemplo: 3b

ou você pode dividir sua tela digitando o número, mas usando sb em vez de apenas b.

Como um% de lado se refere ao arquivo atualmente visível e # se refere ao arquivo alternativo.

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

Editar: como :lsvocê pode usar :regpara ver o conteúdo atual de seus registros, incluindo os registros de 0 a 9 que contêm o que você excluiu. Isso é especialmente útil se você deseja reutilizar algum texto que você excluiu anteriormente.

O Vim (mas não o Vi!) Original tem abas que considero (em muitos contextos) superiores aos buffers. Você pode dizer :tabe [filename]para abrir um arquivo em uma nova guia. O ciclo entre guias é feito clicando na guia ou nas combinações de teclas [ n ] gte gT. O Graphical Vim tem até abas gráficas.

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) são ultra rápidos e nerds.

• ctrlpvim / ctrlp.vim - para localizar arquivo por nome, pesquisa difusa por sua localização ou apenas por 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 os procurou com Ag)
• rking / ag.vim para pesquisar os arquivos em relação ao gitignore
• scrooloose / nerdtree para ver a estrutura de diretórios, procurar, adicionar / excluir / modificar arquivos

EDIT: Recentemente, tenho usado o dyng / ctrlsf.vim para pesquisar com exibição contextual (como a pesquisa sublime) e mudei o mecanismo de ag para ripgrep . O desempenho é excelente.

EDIT2: Juntamente com o CtrlSF, você pode usar o mg979 / vim-visual-multi , fazer alterações em vários arquivos de uma só vez e, no final, salvá-los de uma só vez.

Coisas como :ee :baddaceitarão apenas UM argumento, portanto, o seguinte falhará

:e foo.txt bar.txt
:e /foo/bar/*.txt
:badd /foo/bar/*

Se você deseja adicionar vários arquivos do vim, use arga[dd]

:arga foo.txt bar.txt
:arga /foo/bar/*.txt
:argadd /foo/bar/*

Algumas respostas neste tópico sugerem o uso de guias e outras sugerem o uso de 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 eu retirei do artigo:

Resumo:

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

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

• :b <partial filename><tab> (pule para um buffer)
• :bw (limpeza do buffer, remova um buffer)
• :e <file path> (edite, abra um novo buffer>
• pltags - habilitar o salto para definições de sub-rotina / método

Adicionar outra resposta, pois isso não é coberto por nenhuma das respostas

Para alterar todos os buffers para tabexibição.

 :tab sball

abrirá todos os buffers para a visualização em guias. Em seguida, podemos usar qualquer comando relacionado à guia

gt or :tabn           "    go to next tab
gT or :tabp or :tabN  "    go to previous tab

detalhes em :help tab-page-commands.

Podemos instruir o vim a abrir, como visualização de guia, vários arquivos por vim -p file1 file2. alias vim='vim -p'será útil.
A mesma coisa também pode ser alcançada seguindo o comando automático em~/.vimrc

 au VimEnter * if !&diff | tab all | tabfirst | endif

De qualquer forma, para responder à pergunta: Para adicionar à lista de argumentos: arga file ,

Para excluir da lista arg: argd pattern

Mais em :help arglist

Você pode querer usar marcas globais do Vim .

Dessa forma, você pode saltar rapidamente entre os arquivos e até o local marcado no arquivo. Além disso, os comandos principais são curtos: 'C leva-me ao código com o qual estou trabalhando, 'T leva-me ao teste de unidade em que estou trabalhando.

Quando você muda de lugar, a redefinição das marcas também é rápida: mC marca o novo ponto do código, mT marca o novo ponto do teste.

Eu uso o mesmo arquivo .vimrc para o gVim e a linha de comando do Vim. Eu costumo usar guias no gVim e buffers na linha de comando Vim, então eu tenho meu .vimrc configurado para facilitar o trabalho com os dois:

" Movement between tabs OR buffers
nnoremap L :call MyNext()<CR>
nnoremap H :call MyPrev()<CR>

" MyNext() and MyPrev(): Movement between tabs OR buffers
function! MyNext()
    if exists( '*tabpagenr' ) && tabpagenr('$') != 1
        " Tab support && tabs open
        normal gt
    else
        " No tab support, or no tabs open
        execute ":bnext"
    endif
endfunction
function! MyPrev()
    if exists( '*tabpagenr' ) && tabpagenr('$') != '1'
        " Tab support && tabs open
        normal gT
    else
        " No tab support, or no tabs open
        execute ":bprev"
    endif
endfunction

Isso impede os mapeamentos existentes para He L, mas torna a alternância entre arquivos extremamente rápida e fácil. Basta pressionar Hpara o próximo e Lpara o anterior; esteja usando guias ou buffers, você obterá os resultados pretendidos.

Se você for usar vários buffers, acho que o mais importante é ocultar, para que você possa alternar os buffers, mesmo que você tenha alterações não salvas no que está deixando.

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

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

Combina perfeitamente os comandos :lse :b- listando todos os buffers abertos e esperando que você insira o comando para alternar o buffer.

Dado o mapeamento acima no vimrc, depois que você digita <Leader>f,

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

Um instantâneo da saída para o mapeamento de teclas 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: %apara atual, hpara oculta,# para anterior, vazio para não foi alternado para.
• Terceira coluna: +para modificado.

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

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

1. Use buffers, não 'tab tab'. Buffers são o mesmo conceito que guias em quase todos os outros editores.
2. Se você quer o mesmo olhar de ter guias que você pode usar o vim-companhia aérea plugin com a seguinte configuração em sua .vimrc: let g:airline#extensions#tabline#enabled = 1. Isso exibe automaticamente todos os buffers como cabeçalhos de guias quando você não tem páginas de guias abertas
3. Use o tim-tim intacto de Tim Pope, que fornece [be ]bpara mover para os buffers anteriores / próximos, respectivamente (além de uma série de outras guloseimas)
4. Tenha set wildmenuem sua .vimrcem seguida, quando você digita :b <file part>+ Tabpara um buffer você receberá uma lista de possíveis buffers que você pode usar / direita setas para percorrer esquerda
5. Use o plug - in de obsessão por vim de Tim Pope para armazenar sessões que funcionam muito bem com a companhia aérea (tive muita dor com sessões e plug-ins )
6. Use o plugin de vim-vinagre de Tim Pope . Isso funciona com o nativo, :Exploremas facilita muito o trabalho. Você apenas digita -para abrir o explorer, que é a mesma chave que para subir um diretório no explorer. Torna a navegação mais rápida (no entanto, com fzf eu raramente uso isso)
7. O fzf (que pode ser instalado como um plugin do vim) também é um localizador fuzzy realmente poderoso que você pode usar para procurar arquivos (e buffers também). O fzf também funciona muito bem com o fd (uma versão mais rápida do find)
8. Use o Ripgrep com vim-ripgrep para pesquisar na sua base de código e, em seguida, você pode usar :cdonos resultados para pesquisar e substituir

Minha maneira de trabalhar efetivamente com vários arquivos é usar o tmux.

Permite dividir janelas vertical e horizontalmente, como em:

Eu trabalho dessa maneira em minhas máquinas mac e linux e acho melhor do que o mecanismo de comutação de painel de janela nativo fornecido (em Macs). Acho a troca mais fácil e apenas com o tmux consegui que a 'nova página no mesmo diretório atual' funcionasse no meu mac (apesar do fato de que parece haver opções para abrir novos painéis no mesmo diretório), o que é uma peça surpreendentemente crítica. Um novo painel instantâneo no local atual é incrivelmente útil. Um método que cria novos painéis com as mesmas combinações de teclas para os dois sistemas operacionais é fundamental para mim e um bônus para todos pela futura compatibilidade pessoal. Além de vários painéis tmux, também tentei usar várias guias, por exemplo e várias novas janelas, por exemploe, finalmente, descobri que vários painéis tmux são os mais úteis para mim. Sou muito 'visual' e gosto de manter meus vários contextos bem na minha frente, conectados juntos como painéis.

O tmux também suporta painéis horizontais e verticais que os mais antigos screennão (embora o iterm2 do mac pareça suportá-lo, mas, novamente, a configuração de diretório atual não funcionou para mim). tmux 1.8

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"

Isso abrirá cada novo arquivo em uma nova guia em uma janela existente e criará uma janela para cada repositório git. Portanto, se você abrir dois arquivos do repositório A e três arquivos do repositório B, terá duas janelas, uma para o repositório A com duas guias e outra 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 será direcionado para uma janela padrão.

Para pular entre as guias, 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 vários buffers definidos ocultos no meu ~/.vimrcarquivo.

O script mini-buffer explorer também é bom para obter uma lista compacta e agradável de seus buffers. Então :b1ou :b2... para ir para o buffer apropriado ou use o mini-explorer de buffer e navegue pelos buffers.

tente seguir os 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 <C-j> <C-w>j

nmap <C-k> <C-w>k

nmap <C-l> <C-w>l

nmap <C-h> <C-w>h

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

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

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 ordem MRU, basta pressionar Enter duas vezes e pular para o arquivo mais recente que você estava editando.

Após a instalação do plug-in, a única configuração necessária é:

nmap <CR> :CtrlPBuffer<CR>

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

Eu sugeriria usar o plugin

NERDtree

Aqui está o link do github com instruções.

Nerdtree

Eu uso o vim-plug como um gerenciador de plugins, mas você também pode usar o Vundle.

vim-plug

Vundle

No meu e em muitos outros usuários do vim, a melhor opção é:

• Abra o arquivo usando,

: e file_name.extension

E então apenas Ctrl + 6 para mudar para o último buffer. Ou você sempre pode pressionar

: ls para listar o buffer e altere-o usando b seguido do número do buffer.

• Fazemos uma divisão vertical ou horizontal usando

: vsp para divisão vertical

: sp para divisão horizontal

E então <C-W><C-H/K/L/j>para mudar a divisão de trabalho.

É claro que você pode editar qualquer arquivo em qualquer número de divisões.

Quando comecei a usar o VIM, não percebi que as guias deveriam ser usadas como layouts de janela diferentes, e o buffer serve para a edição / troca de arquivos múltiplos entre si. Na verdade, no começo, as abas não estavam lá antes da v7.0 e eu apenas abri um VIM dentro de uma aba de terminal (eu estava usando o gnome-terminal no momento) e alterne entre as abas usando alt + numbers, pois pensei em usar comandos como : buffers,: bn e: bp eram demais para mim. Quando o VIM 7.0 foi lançado, acho mais fácil gerenciar muitos arquivos e mudar para ele, mas recentemente percebi que os buffers sempre devem ser o caminho a seguir, a menos que uma coisa: você precise configurá-lo para que funcione corretamente.

Então, tentei o vim-airlines e ativei a barra de buffer visual no topo da guia, mas os gráficos estavam com problemas no meu iTerm2, então tentei alguns outros e parece que o MBE funciona melhor para mim. Também defino shift + h / l como atalhos, pois os originais (movendo-se para o início / fim da página atual) não são muito úteis para mim.

map <S-h> :bprev<Return>
map <S-l> :bnext<Return>

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

se você estiver no osx e quiser clicar em suas guias, use o MouseTerm e o SIMBL (extraídos daqui ). Além disso, confira esta discussão relacionada .

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

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

   nnoremap <leader><leader> <c-^>
   

2. Para se movimentar rapidamente em um projeto, a resposta é uma solução de correspondência difusa, como CtrlP . Eu o vinculo <leader>apara acesso rápido.

3. No caso, quero ver uma representação visual dos buffers atualmente abertos, uso o plug-in BufExplorer . Simples mas efetivo.

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

Isso deve ser suficiente para localizar e abrir arquivos. A partir daí, é claro, use divisões horizontais e verticais. Em relação às divisões, acho essas 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 divisão 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>
   

Você pode ser um louco absoluto e apelido vimpara vim -padicionando em sua .bashrc:

alias vim="vim -p"

Isso resultará na abertura de vários arquivos do shell em guias, sem a necessidade de chamar a :tab ballpartir do vim posteriormente.