Navegação de arquivo Vim

Estou tentando muito aprender o vim depois de usar o TextMate nos últimos anos.

Comecei a comprometer parte da navegação no arquivo para a memória, mas estou tendo dificuldades para navegar entre vários arquivos.

No meu fluxo de trabalho, é bastante comum que eu alterne entre um punhado de arquivos com bastante regularidade (arquivos suficientes para que as janelas de painel dividido fiquem muito pequenas).

No momento, estou usando o NERDTree, mas acho que o detalhamento dos diretórios é complicado, bem como o uso constante de CTRL+ W h/ CTRL+ W lpara ir e voltar.

Acho que faria melhor com guias que posso alternar facilmente, mas talvez eu precise usar um fluxo de trabalho diferente.

Também gostaria de um atalho "Ir para o arquivo ..." como CMD+ Tno TextMate. Eu descobri, fuzzy_file_findermas requer que o vim seja construído com vínculos Ruby, o que não é o caso das instalações nativas nas quais trabalhei.

Embora eu pudesse reconstruir, o principal motivo pelo qual quero mudar para o vim é para ter um ambiente de editor que funcione facilmente em qualquer plataforma.

As opções lá fora são esmagadoras, todas as ideias são muito apreciadas!

Não acho que aprofundar em subdiretórios via plain old :eseja tão complicado, dada uma configuração decente para preenchimento de tabulação.

Verifique a 'wildmenu'opção de fazer com que o Vim mostre uma lista de conclusões (nomes de arquivos) na linha de modelo acima da linha de comando. Você pode alterar a 'wildmode'opção para configurar ainda mais o tipo de preenchimento de guia que o Vim fará.

Pessoalmente, eu uso :set wildmode=full.

Meu fluxo de trabalho é assim:

1. :cd no diretório de nível superior do meu projeto.

2. Para abrir o arquivo foo/bar/baz:

   • Cenário mais simples: digite :e f<tab>b<tab>b<tab><enter>.

   • Se houver mais de um arquivo começando bem um desses diretórios, você pode ter que fazer um <left>ou <right>ou outro <tab>no teclado para pular entre eles (ou digitar mais algumas letras para eliminar a ambigüidade).

   • Na pior das hipóteses, existem arquivos e diretórios que compartilham um nome e você precisa fazer uma busca detalhada no diretório. Neste caso, complete com tabulação o nome do diretório e, em seguida, digite *<tab>para detalhar.

3. Abra 2 ou 3 janelas e abra arquivos em todas elas conforme necessário.
4. Depois que um arquivo é aberto em um buffer, não elimine o buffer. Deixe-o aberto em segundo plano ao abrir novos arquivos. Apenas :eum novo arquivo na mesma janela.
5. Em seguida, use :b <tab>para percorrer os buffers que já estão abertos em segundo plano. Se você digitar, :b foo<tab>ele corresponderá apenas aos arquivos abertos no momento correspondentes foo.

Também uso esses mapeamentos para facilitar a abertura de novas janelas e pular entre elas, porque é algo que faço com frequência.

" Window movements; I do this often enough to warrant using up M-arrows on this"
nnoremap <M-Right> <C-W><Right>
nnoremap <M-Left> <C-W><Left>
nnoremap <M-Up> <C-W><Up>
nnoremap <M-Down> <C-W><Down>

" Open window below instead of above"
nnoremap <C-W>N :let sb=&sb<BAR>set sb<BAR>new<BAR>let &sb=sb<CR>

" Vertical equivalent of C-w-n and C-w-N"
nnoremap <C-w>v :vnew<CR>
nnoremap <C-w>V :let spr=&spr<BAR>set nospr<BAR>vnew<BAR>let &spr=spr<CR>

" I open new windows to warrant using up C-M-arrows on this"
nmap <C-M-Up> <C-w>n
nmap <C-M-Down> <C-w>N
nmap <C-M-Right> <C-w>v
nmap <C-M-Left> <C-w>V

Demoro alguns segundos para abrir o Vim, configurar algumas janelas e abrir alguns arquivos nelas. Pessoalmente, nunca achei nenhum script de navegação de arquivos de terceiros muito útil.

Uma maneira fácil de navegar no sistema de arquivos é o comando:

:Sex

Eu não estou inventando isso :)

:Sex, :Vex, :TexE :Exsão todos os comandos úteis para ex (ploring) os arquivos em seu sistema se você quiser usar algo diferente do:e

(onde S/V/Tsão abreviações de Split / Vertical / Tab)

Se você ainda não os encontrou, convém verificar:

• o plug-in fuzzy finder original - que IIRC não tem os problemas de ligação Ruby
• o plugin do projeto - semelhante ao NERDTree
• o plugin do explorador de buffer - mostra uma lista de buffers abertos

Lembre-se também de que você pode remapear os atalhos principais em seu .vimrc para torná-los menos complicados. Eu uso muito janelas divididas; Descobri que o seguinte torna muito mais fácil lidar com eles:

" set your own personal modifier key to something handy
let mapleader = "," 

" use ,v to make a new vertical split, ,s for horiz, ,x to close a split
noremap <leader>v <c-w>v<c-w>l
noremap <leader>s <c-w>s<c-w>j
noremap <leader>x <c-w>c

" use ctrl-h/j/k/l to switch between splits
map <c-j> <c-w>j
map <c-k> <c-w>k
map <c-l> <c-w>l
map <c-h> <c-w>h

Acho que faria melhor com as guias que posso alternar facilmente, mas talvez eu precise usar um fluxo de trabalho diferente.

Você está ciente das guias do Vim? Não tenho certeza se você estava se referindo às próprias guias do Vim lá, ou ansiando por TextMate. Não está claro qual versão do Vim você está usando, mas tem abas desde pelo menos a 7.0 (que parece estar instalada em todos os lugares que vejo ultimamente), e elas são incríveis.

:tabeabre uma nova (abreviação de "edição de guia", por exemplo, :tabepara vazio ou :tabe path/to/filepara abrir um arquivo em uma nova guia,) você pode mover entre as guias adjacentes com gt/ gT, e há um monte de outros comandos de navegação relacionados à guia também, como você pode esperar do Vim ( :help tabs)

Meu fluxo de trabalho para grandes projetos tende a envolver um monte de guias, cada uma com entre 1 e 3 janelas, dependendo do tipo de contexto de que preciso. Isso funciona ainda melhor se eu tiver uma janela de terminal de largura dupla, já que posso dividir verticalmente com :vs, então uma única guia pode me mostrar facilmente 4 arquivos de uma vez com bastante espaço para cada um.

Dica final: às vezes uso o comando "switch buffer" ( :sb <partial_buf_name>) que é meio parecido com a descoberta confusa do TM, pois funciona muito bem, mas apenas para buffers já abertos. Ainda é ótimo para quando tenho uma dúzia ou mais de arquivos abertos ao mesmo tempo. (NB, eu precisava :set switchbuf=usetabno meu vimrc para que funcionasse em todas as guias, mas uma vez definido, é ótimo.)

Acho o LustyExplorer o melhor até agora.

Você pode abrir um arquivo digitando apenas uma parte de seu nome.

Você pode abrir um arquivo do diretório do arquivo atual, ou do atual pwd, ou da lista de buffers.

Se você abrir um arquivo da lista de buffer, não será necessário navegar pela árvore de diretórios, embora, infelizmente, para os outros dois modos, ainda seja necessário navegar pela árvore. O bom é que você não precisa começar do primeiro caractere.

Se você tem:

dir_a/
    ...
dir_b/
    file.js
    file.html

e você deseja abrir, dir_b/file.htmlvocê geralmente pode encontrá-lo digitandob<Tab>h

É surpreendente ver que o :findcomando não foi mencionado em nenhuma das respostas. Normalmente trabalho com projetos Rails onde preciso me aprofundar na hierarquia de diretórios. Portanto, para um arquivo application.css, localizado em app/assets/stylesheets/tudo que eu tenho que digitar é :find applicae, em seguida, pressione tab para autocompletar e Enter para abrir.

Verifique o plugin ctrlp como alternativa ao plugin Command-T . É melhor do que isso porque é um script Vim 'nativo' e não precisa do Vim para ser compilado com ruby ​​(ou outro suporte), embora seja executado de forma muito rápida e discreta.

Se o arquivo que você deseja já estiver carregado em um buffer (o que é provável se você estiver alternando entre um punhado de arquivos regularmente), você pode alternar rapidamente para o buffer com o :b[uffer]comando.

:bpode receber um número de buffer como parâmetro ou (mais útil) uma string que corresponda a parte do caminho / nome do arquivo. Se houver várias correspondências, você pode usar a guia para alternar entre elas.

Se você quiser dividir a janela e abrir o buffer na nova janela, use :sb name

Se você quiser abrir o buffer em uma nova guia, use :tab b name

Você também pode usar o :lscomando para ver uma lista de buffers carregados atualmente.

Eu uso esta função para localizar arquivos em subdiretórios, mas não a escrevi. É do vim wiki :

função! Encontrar (nome)
    let l: list = system ("find. -name '" .a: name. "' | grep -v \". svn / \ "| perl -ne 'print \" $. \\ t $ _ \ "' ") 
    deixe l: num = strlen (substituto (l: list, "[^ \ n]", "", "g")) 
    se l: num 0 
            echo "Não é um número" 
            Retorna 
        fim se 
        se l: inputl: num 
            echo "Fora de alcance" 
            Retorna 
        fim se 
        let l: line = matchstr ("\ n" .l: list, "\ n" .l: input. "\ t [^ \ n] *") 
    outro 
      deixe l: linha = l: lista 
    fim se 
    deixe l: linha = substituto (l: linha, "^ [^ \ t] * \ t. /", "", "") 
    execute ": e" .l: linha 
função final 

comando! -nargs = 1 Find: chamar Find ("")

Uma coisa que eu gosto é que ele tem suporte para curingas (*). Também é bem comportado para partidas múltiplas.

Além das wildmenurespostas, uso o plug- in BufExplorer e os seguintes mapeamentos para pular buffers rapidamente:

nmap <A-1> :b 1<CR>
nmap <A-2> :b 2<CR>
nmap <A-3> :b 3<CR>
...
nmap <A-0> :b 10<CR>
nmap <A-=> \bs

Ou você pode simplesmente substituir o explorador de buffer pelo :lscomando, que basicamente exibe a mesma coisa.

O último mapeia o Alt-=para mostrar o explorador de buffer.

Não uso muito o Windows, pois geralmente só tenho uma ou duas janelas.

Também modifiquei o statuslinepara incluir o número do buffer %2n, para que eu sempre saiba qual buffer está sendo editado. Vejo:h statusline

você conhece o aplicativo MacVim? É VIM polido para OS X, e um de seus recursos é o suporte para abas (CMD + T para abrir nova aba), tem gaveta, etc ... (leia isto: http://zerokspot.com/weblog/2008 / 08/03 / macvim-as-textmate-replacement / )

Tente!

Atenciosamente Michal

NerdTree é melhor para navegação de arquivos no vim.

O link abaixo é uma boa introdução ao nerdtree.

http://www.catonmat.net/blog/vim-plugins-nerdtree-vim/

Aqui está algo bastante trivial que coloco na minha .vimrc. Ele irá carregar um arquivo de qualquer subdiretório.

" load from an unspecified subdirectory 
function! LoadFromSubdirectory(filespec) 
  let filename = glob("`find . -name '" . a:filespec . "' -print`") 
  exe ':e '.filename 
endfunction 
:command -nargs=1 Er :call LoadFromSubdirectory(<f-args>) 

Então, posso apenas dizer:

: Er Main.java

e ele pesquisará subdiretórios, localizará Main.javae carregará. Não é adequado para vários arquivos com o mesmo nome, mas é rápido e simples.

A outra ferramenta que uso é o VTreeExplorer , que fornece uma janela de arquivos / diretórios baseada em árvore e não requer nenhuma opção especial de compilação do VIM (ou seja, é um plugin vanilla).

Meu fluxo de trabalho para localizar arquivos é o wildmenu, autocwd e :e.

Partes relevantes no .vimrc:

set wildmenu
set wildignore=*.dll,*.o,*.pyc,*.bak,*.exe,*.jpg,*.jpeg,*.png,*.gif
set wildmode=list:full
set autochdir
let g:netrw_list_hide='^\.,.\(pyc\|pyo\|o\)$'

E como usar:

:e myf^D

Isso dá todos os arquivos no diretório atual que começam com myf. Você também pode <Tab>por meio deles. Use return para abrir :)

^Dsempre lhe dará todas as correspondências. Como o autocmd sempre vai para a pasta do arquivo atual, é fácil de trabalhar. Se você está dentro foo/bar.pye quer ir, foo/baz.pysó vá :e baz.pye você está lá. Isso também funciona com buffers ( :b foo^Dlista todos os buffers começando com foo)