vim, alternando entre arquivos rapidamente usando o vanilla Vim (sem plug-ins)

Eu entendo que me limitar ao Vanilla Vim (não usar plug-ins) limita o poder do editor, mas como eu alterno entre máquinas diferentes com frequência, geralmente é muito trabalhoso mover meu ambiente para todos os lugares. Eu quero apenas ficar no Vanilla Vim.

Algo que me impede é a capacidade de alternar rapidamente entre os arquivos. I (acredite pelo menos) têm uma boa compreensão de buffers , janelas , abas , bem como netrw ( Vex, Ex, etc).

Mas em um editor como o Sublime Text , posso simplesmente digitar ctrl- pe imediatamente estou no arquivo.

Eu sei que posso descer para o shell, mas me pergunto se há algum outro segredo "oculto" para alternar rapidamente entre arquivos no Vim baseado em mais do que apenas o nome do arquivo.

O equivalente mais próximo ("mais próximo", não "exato") do ST2 Ctrl+ Pé um plugin chamado, prepare-se ... CtrlP . Existem outros plug - ins semelhantes, como Command-T ou FuzzyFinder .

Eu uso o CtrlP e adoro isso, mas apoio de todo o coração sua decisão de ir "sem plugins". Não é a maneira mais fácil de fazer, mas vai render no longo prazo.

Abrindo arquivos

A maneira mais básica de abrir um arquivo é :e /path/to/filename. Felizmente, você obtém preenchimento de tabulação e curingas: o clássico *e um especial **, que significa "qualquer subdiretório".

Combinando tudo isso, você pode fazer:

:e **/*foo<Tab>

para escolher entre todos os arquivos que contêm fooem seu nome no diretório de trabalho ou:

:e **/*foo/*bar<Tab>

para escolher entre todos os arquivos que contêm barem seu nome em qualquer subdiretório que contenha fooem seu nome, em qualquer lugar no diretório de trabalho.

Claro, que trabalha para :tabe[dit], :sp[lit]e :vs[plit]também.

Esses comandos são limitados a um arquivo, no entanto. Use :nextpara abrir vários arquivos:

:next **/*.js

e dê uma olhada em :help arglist.

Saltando entre buffers

:b[uffer] é o comando básico de troca de buffer:

:b4         " switch to buffer number 4
:bn         " switch to next buffer in the buffer list
:bp         " switch to previous buffer in the buffer list
:bf         " switch to first buffer in the buffer list
:bl         " switch to last buffer in the buffer list
:b foo<Tab> " switch by buffer name with tab-completion
:b#         " switch to the alternate file

Observe que muitos desses comandos e seus parentes aceitam uma contagem.

O :lscomando mostra uma lista de buffers carregados. No entanto, é um pouco "especial": os buffers recebem um número quando são criados, de modo que você pode ter uma lista semelhante à de 1 2 5excluir os buffers. Isso é um pouco estranho, sim, e torna a troca para um buffer por seu número um pouco problemática. Prefira alternar por nome parcial :b foo<Tab>ou por ciclo :bn :bp.

De qualquer forma, aqui está um mapeamento legal que lista todos os buffers carregados e preenche o prompt para você, esperando que você digite o número de um buffer e pressione <enter>:

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

Com esse mapeamento, mudar para outro buffer é tão simples como:

gb
(quickly scanning the list)
3<CR>

ou:

gb
(quickly scanning the list)
foo<tab><CR>

A ideia surge desta imagem retirada da coleção de infográficos do Vim de Bairui :

O Vim também tem <C-^>(ou <C-6>em alguns teclados) —o modo normal equivalente a :b#—para saltar entre o buffer atual e o anterior. Use-o se você costuma alternar entre dois buffers.

Leia tudo sobre buffers em :help buffers.

Vá para a declaração

Em um arquivo, você pode usar gdou gD.

Dentro de um projeto, o recurso de "tags" do Vim é seu amigo, mas você precisará de um indexador de código externo como ctags ou cscope. Os comandos mais básicos são :tag fooe <C-]>com o cursor no nome de um método. Ambas as ferramentas estão bem integradas ao Vim: veja :help tags, :help ctagse :help cscope.

Pelo que vale a pena, eu uso a navegação por tag extensivamente para mover dentro de um projeto (usando CtrlP :CtrlPTage :CtrlPBufTagcomandos, principalmente, mas os embutidos também) e meu método de troca de buffer "genérico" favorito é pelo nome.

Implantar sua configuração

Muitos usuários do Vim colocam sua configuração sob controle de versão, o que torna muito rápido e fácil instalar sua própria configuração em uma nova máquina. Pense nisso.

EDITAR

Há alguns meses, tive que trabalhar em uma máquina remota com um Vim desatualizado. Eu poderia ter instalado um Vim adequado e clonado minha própria configuração, mas decidi viajar com pouca bagagem, dessa vez, para "afiar a serra". Rapidamente construí um minimalista .vimrce revisitei alguns recursos nativos meio esquecidos. Depois desse show, decidi que o CtrlP não era tão necessário e me livrei dele: recursos nativos e mapeamentos personalizados não são tão atraentes, mas realizam o trabalho sem muitas dependências.

Malabarismo com arquivos

set path=.,**
nnoremap <leader>f :find *
nnoremap <leader>s :sfind *
nnoremap <leader>v :vert sfind *
nnoremap <leader>t :tabfind *

:findé um comando verdadeiramente grande assim que você set pathcorretamente. Com minhas configurações, ,ffoo<Tab>irá encontrar todos os arquivos contidos foono diretório atual, recursivamente. É rápido, intuitivo e leve. Claro, eu me beneficio da mesma conclusão e curingas que com :edite amigos.

Para tornar o processo ainda mais rápido, os mapeamentos a seguir me permitem pular partes inteiras do projeto e encontrar arquivos recursivamente no diretório do arquivo atual:

nnoremap <leader>F :find <C-R>=expand('%:h').'/*'<CR>
nnoremap <leader>S :sfind <C-R>=expand('%:h').'/*'<CR>
nnoremap <leader>V :vert sfind <C-R>=expand('%:h').'/*'<CR>
nnoremap <leader>T :tabfind <C-R>=expand('%:h').'/*'<CR>

AVISO! A pathopção é extremamente poderosa. O valor acima— .,**—funciona para mim, mas os idiomas que uso não têm uma biblioteca padrão. O valor adequado depende inteiramente de suas necessidades.

Malabarismo com buffers

set wildcharm=<C-z>
nnoremap <leader>b :buffer <C-z><S-Tab>
nnoremap <leader>B :sbuffer <C-z><S-Tab>

Os mapeamentos acima listam os buffers disponíveis no "menu selvagem" com um prompt vazio, permitindo-me navegar no menu com <Tab>ou digitar algumas letras e <Tab>novamente para restringir a lista. Como com os mapeamentos de arquivo acima, o processo é rápido e quase sem atrito.

nnoremap <PageUp>   :bprevious<CR>
nnoremap <PageDown> :bnext<CR>

Esses mapeamentos falam por si.

Malabarismo com tags

nnoremap <leader>j :tjump /

Este mapeamento usa pesquisa regex em vez de pesquisa de palavra inteira para que eu possa fazer ,jba<Tab>para encontrar a tag foobarbaz().

Sim, a correspondência difusa é viciante, mas você pode ser igualmente produtivo sem ela. E por uma fração do custo.

MAIS EDITAR

Algumas dicas / truques adicionais ...

Opções de menu selvagem

O "wildmenu", ativado com set wildmenu, torna a navegação de arquivo / buffer mais fácil. Seu comportamento é regido por uma série de opções que valem a pena investigar:

wildmode diz ao Vim como você deseja que o "menu selvagem" se comporte:

set wildmode=list:full

wildignore filtra todo o lixo:

set wildignore=*.swp,*.bak
set wildignore+=*.pyc,*.class,*.sln,*.Master,*.csproj,*.csproj.user,*.cache,*.dll,*.pdb,*.min.*
set wildignore+=*/.git/**/*,*/.hg/**/*,*/.svn/**/*
set wildignore+=tags
set wildignore+=*.tar.*

wildignorecasepermite que você pesquise fooe encontre Foo:

set wildignorecase

Marcas de arquivo

augroup VIMRC
  autocmd!

  autocmd BufLeave *.css  normal! mC
  autocmd BufLeave *.html normal! mH
  autocmd BufLeave *.js   normal! mJ
  autocmd BufLeave *.php  normal! mP
augroup END

Recentemente, encontrei esta joia na de outra pessoa ~/.vimrc. Ele cria uma marca de arquivo na posição exata do cursor sempre que você sai de um buffer, de forma que, onde quer que você esteja, 'Jpule para o buffer JavaScript mais recente que você editou. Impressionante.

A resposta depende muito de suas preferências e circunstâncias. Alguns exemplos:

• Se forem principalmente dois arquivos (por exemplo, um cabeçalho C e um arquivo de implementação), <C-^>é muito útil. Em geral, o arquivo alternativo é um conceito importante.
• Se você usar uma janela de editor grande, as janelas :splitevitam que o problema de localização de um buffer localize a janela (uma vez que todos os buffers estejam abertos). Você pode usar [N]<C-w><C-w>para alternar rapidamente para ele.
• Se você puder memorizar (alguns) números de buffer, os comandos :[N]b[uffer]e :[N]sb[uffer]são bastante úteis; :lsdiz os números.

Plug-ins (ou pelo menos mapeamentos personalizados) podem melhorar muito as coisas, e há uma grande variedade neste tópico no vim.org . Existem vários mecanismos para distribuir sua configuração (Pathogen + GitHub, Dropbox, ...), ou você pode editar remotamente os arquivos do servidor através do plugin netrw que vem com o Vim.

Às vezes, também é útil percorrer sequencialmente uma lista de arquivos (por exemplo, se você fez algo como vim *.phpabrir vários arquivos de uma vez). Depois, você pode usar :n[ext](bem como :prev[ious], :fir[st]e :la[st]) para navegação (além do que foi sugerido nas outras respostas).

Você pode completar a tabulação curinga na linha de comando sem nenhum plug-in. por exemplo

:e src/**/foo*<tab>

permitirá que você percorra todos os arquivos começando com 'foo' na árvore de diretórios sob ./src e selecione aquele que deseja editar.

Se você já editou o arquivo e ele ainda está em um buffer, você pode alternar para ele com:

:b foo<tab>

que percorrerá todos os buffers com 'foo' no caminho. Você pode precisar definir as opções wildmode e wildmenu para obter o comportamento desejado. eu tenho

wildmode=longest:full
wildmenu

em meu .vimrc.

Se você estiver usando um nome de arquivo e quiser pular para esse arquivo, o gffará por você. Também gosto de usar ctags , que não é um plugin; você acabou de criar as tags e pode facilmente pular em sua base de código.

Se você quiser alternar entre os arquivos no editor vim, veja a resposta abaixo

Primeiro pressione a Esctecla para sair do modo de edição.

Em seguida, digite :epara verificar o caminho do arquivo atual.

se você quiser ir para outro arquivo, digite :e /path-of-file.txt/usando isso para alternar.

Se você quiser ir para o arquivo anterior, simplesmente digite :e#qual alternar para o caminho do arquivo anterior.

Eu tive o mesmo problema com o Vim.

A última coisa que quero é depender de plug-ins para uma tarefa tão comum como a troca de arquivos.

Eu adicionei as seguintes linhas a .vimrc

set path+=**
set wildmenu

E BAM! Agora posso :find any/filename/in/any/folder/, desde que o vim esteja no diretório raiz do projeto. A conclusão da guia funciona. Os curingas funcionam!

Depois que os arquivos já estiverem abertos e houver uma tonelada de buffers em segundo plano (você pode usar :lspara ver todos os buffers), a execução de :b any/file <TAB>uma busca difusa por todos os buffers e pula para o arquivo necessário. Caso não seja exclusivo, haverá um menu selvagem de guias (daí a 2ª linha em .vimrc) que pode ser selecionado usando tab.

Minha resposta está vindo deste vídeo incrível
https://www.youtube.com/watch?v=XA2WjJbmmoM&feature=youtu.be&t=489
Existem mais truques e eu recomendo assisti-lo.