Navigazione tra i file Vim

Sto cercando davvero di imparare vim dopo aver usato TextMate negli ultimi anni.

Ho iniziato a salvare in memoria parte della navigazione in-file, ma ho difficoltà a navigare tra più file.

Nel mio flusso di lavoro è abbastanza comune sfogliare una manciata di file abbastanza regolarmente (file sufficienti in modo tale che le finestre a riquadro diviso diventino troppo piccole).

Attualmente sto usando NERDTree ma trovo scomodo il drill-down nelle directory e utilizzo costantemente CTRL+ W h/ CTRL+ W lper saltare avanti e indietro.

Penso che farei meglio con le schede che posso facilmente passare da una all'altra, ma forse ho bisogno di utilizzare un flusso di lavoro diverso.

Vorrei anche una scorciatoia "Vai a file ..." come CMD+ Tin TextMate. Ho trovato fuzzy_file_finderma richiede che vim sia compilato con collegamenti Ruby, il che non è il caso delle installazioni native su cui ho lavorato.

Anche se potrei ricostruire il motivo principale per cui voglio passare a vim è così posso avere un ambiente di editor che so funzionerà facilmente su qualsiasi piattaforma.

Le opzioni disponibili sono travolgenti, tutte le idee sono molto apprezzate!

Non trovo che il drill down nelle sottodirectory tramite il semplice vecchio :esia così ingombrante data una configurazione decente per il completamento della scheda.

Cerca 'wildmenu'nell'opzione per fare in modo che Vim mostri un elenco di completamenti (nomi di file) nella modeline sopra la riga di comando. È possibile modificare l' 'wildmode'opzione per configurare ulteriormente il tipo di completamento con tabulazione che Vim eseguirà.

Personalmente lo uso :set wildmode=full.

Il mio flusso di lavoro è così:

1. :cd nella directory di primo livello del mio progetto.

2. Per aprire il file foo/bar/baz:

   • Scenario più semplice: tipo :e f<tab>b<tab>b<tab><enter>.

   • Se bin una di queste directory sono presenti più file che iniziano con, potrebbe essere necessario eseguire uno <left>o un <right>altro <tab>sulla tastiera per passare da uno all'altro (o digitare qualche lettera in più per chiarire le ambiguità).

   • Nel peggiore dei casi, sono presenti file e directory che condividono un nome ed è necessario eseguire il drill-down nella directory. In questo caso, completare con la scheda il nome della directory, quindi digitare *<tab>per eseguire il drill down.

3. Apri 2 o 3 finestre e apri i file in ognuna di esse secondo necessità.
4. Una volta che un file è aperto in un buffer, non terminare il buffer. Lascialo aperto in background quando apri nuovi file. Solo :eun nuovo file nella stessa finestra.
5. Quindi, utilizzare :b <tab>per scorrere i buffer già aperti in background. Se digiti :b foo<tab>, corrisponderà solo ai file attualmente aperti che corrispondono foo.

Uso anche queste mappature per facilitare l'apertura di nuove finestre e passare da una all'altra perché è qualcosa che faccio così spesso.

" 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

Mi ci vogliono pochi secondi per aprire Vim, impostare alcune finestre e aprire alcuni file in esse. Personalmente non ho mai trovato molto utile nessuno degli script di esplorazione dei file di terze parti.

Un modo semplice per navigare nel file system è il comando:

:Sex

Non me lo sto inventando :)

:Sex, :Vex, :TexE :Exsono tutti i comandi utili per ex (ploring) i file sul vostro sistema se si desidera utilizzare qualcosa di diverso da:e

(dove S/V/Tsono abbreviazione di Split / Vertical / Tab)

Se non li hai già trovati, potresti voler controllare:

• il plugin Fuzzy Finder originale - che IIRC non ha i problemi di binding di Ruby
• il plugin Project - simile a NERDTree
• il plug-in buffer explorer - mostra un elenco di buffer aperti

Tieni inoltre presente che puoi rimappare le scorciatoie da tastiera nel tuo .vimrc per renderle meno ingombranti. Uso molto le finestre divise; Ho scoperto che quanto segue rende molto più facile gestirli:

" 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

Penso che farei meglio con le schede che posso facilmente passare da una all'altra, ma forse ho bisogno di utilizzare un flusso di lavoro diverso.

Conosci le schede di Vim? Non sono sicuro se ti stessi riferendo alle schede di Vim lì, o se ti stavi struggendo per TextMate. Non è chiaro quale versione di Vim stai utilizzando, ma ha schede almeno dalla 7.0 (che sembra essere installata ovunque guardo ultimamente) e sono fantastiche.

:tabene apre una nuova (abbreviazione di "tab edit", quindi ad es. :tabeper vuoto o :tabe path/to/fileper aprire un file in una nuova scheda,) puoi spostarti tra le schede adiacenti con gt/ gT, e ci sono anche un sacco di altri comandi di navigazione relativi alle schede, come potresti aspettarti da Vim ( :help tabs)

Il mio flusso di lavoro per progetti di grandi dimensioni tende a coinvolgere un gruppo di schede, ciascuna con da 1 a 3 finestre a seconda del tipo di contesto di cui ho bisogno. Funziona ancora meglio se ho una finestra di terminale a doppia larghezza poiché posso dividere verticalmente con :vs, quindi una singola scheda può facilmente mostrarmi 4 file contemporaneamente con molto spazio per ciascuno.

Suggerimento finale: a volte uso il comando "switch buffer" ( :sb <partial_buf_name>) che è un po 'come la ricerca fuzzy di TM, in quanto funziona abbastanza bene ma solo per buffer già aperti. Ancora ottimo per quando ho una dozzina o più file aperti contemporaneamente. (NB avevo bisogno di farlo :set switchbuf=usetabnel mio vimrc perché funzionasse su più schede, ma una volta impostato è fantastico.)

Trovo LustyExplorer il migliore finora.

Puoi aprire un file digitando solo una parte del suo nome.

È possibile aprire un file dalla directory del file corrente, da quello corrente pwdo dall'elenco dei buffer.

Se apri un file dalla lista del buffer, non devi navigare attraverso l'albero delle directory, anche se sfortunatamente per le altre due modalità, devi ancora navigare attraverso l'albero. La cosa buona è che non devi iniziare dal primo personaggio.

Se hai:

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

e si desidera aprire lo dir_b/file.htmlsi può generalmente trovare digitandob<Tab>h

È sorprendente vedere che il :findcomando non è stato menzionato in nessuna delle risposte. Di solito lavoro con progetti rails in cui ho bisogno di approfondire la gerarchia delle directory. Così, per un file application.css, che si trova in app/assets/stylesheets/tutto quello che devo tipo è :find applicaquindi premere scheda di completamento automatico e digitare per aprire.

Controlla il plugin ctrlp come alternativa al plugin Command-T . È meglio di questo in quanto è uno script Vim "nativo" e non ha bisogno di Vim per essere compilato con ruby ​​(o altro supporto) mentre gira molto velocemente e non invadente.

Se il file che desideri è già caricato in un buffer (il che è probabile se stai sfogliando regolarmente una manciata di file), puoi passare rapidamente al buffer con il :b[uffer]comando.

:bpuò prendere un numero di buffer come parametro o (più utilmente) una stringa che corrisponde a parte del percorso / nome del file. Se sono presenti più corrispondenze, puoi utilizzare Tab per scorrere le varie corrispondenze.

Se vuoi dividere la finestra e aprire il buffer nella nuova finestra, usa :sb name

Se vuoi aprire il buffer in una nuova scheda, usa :tab b name

È inoltre possibile utilizzare il :lscomando per visualizzare un elenco dei buffer attualmente caricati.

Uso questa funzione per trovare i file nelle sottodirectory, ma non l'ho scritta. È tratto dal wiki di vim :

funzione! Trova (nome)
    let l: list = system ("find. -name '" .a: name. "' | grep -v \". svn / \ "| perl -ne 'print \" $. \\ t $ _ \ "' ") 
    let l: num = strlen (substitute (l: list, "[^ \ n]", "", "g")) 
    se l: num 0 
            echo "Non è un numero" 
            ritorno 
        finisci se 
        se l: inputl: num 
            echo "Fuori portata" 
            ritorno 
        finisci se 
        let l: line = matchstr ("\ n" .l: list, "\ n" .l: input. "\ t [^ \ n] *") 
    altro 
      let l: line = l: list 
    finisci se 
    let l: line = substitute (l: line, "^ [^ \ t] * \ t. /", "", "") 
    eseguire ": e" .l: line 
funzione finale 

comando! -nargs = 1 Trova: chiama Trova ("")

Una cosa che mi piace è che supporta i caratteri jolly (*). Si comporta bene anche per più partite.

Oltre alle wildmenurisposte, utilizzo il plug-in BufExplorer e le seguenti mappature per saltare rapidamente i buffer:

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

Oppure puoi semplicemente sostituire il buffer explorer con il :lscomando, che sostanzialmente visualizza la stessa cosa.

L'ultimo mappa il Alt-=per mostrare il buffer explorer.

Non uso molto Windows, dato che generalmente ho solo una o due finestre.

Ho anche modificato il statuslineper includere il numero del buffer %2n, in modo che io sappia sempre quale buffer viene modificato. Vedere:h statusline

conosci l'applicazione MacVim? È VIM lucido per OS X e una delle sue funzionalità è il supporto per le schede (CMD + T per aprire una nuova scheda), ha un drawer, ecc ... (leggi questo: http://zerokspot.com/weblog/2008 / 08/03 / macvim-as-textmate-replacement / )

Provalo!

Saluti Michal

NerdTree è il migliore per la navigazione dei file in vim.

Il link sottostante è una buona introduzione a nerdtree.

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

Ecco qualcosa di abbastanza banale che metto nel mio .vimrc. Caricherà un file da qualsiasi sottodirectory.

" 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>) 

Quindi posso solo dire:

: Er Main.java

e cercherà nelle sottodirectory, lo troverà Main.javae lo caricherà. Non si comporta bene per più file con lo stesso nome, ma è semplice e veloce.

L'altro strumento che utilizzo è VTreeExplorer , che fornisce una finestra di file / directory basata su albero e non richiede alcuna speciale opzione di compilazione da VIM (cioè è un plugin vanilla).

Il mio flusso di lavoro per la ricerca dei file è il wildmenu, autocwd e :e.

Parti rilevanti in .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 come usarlo:

:e myf^D

Ciò fornisce tutti i file nella directory corrente che iniziano con myf. Puoi anche <Tab>attraverso di loro. Usa Invio per aprire :)

^Dti darà sempre tutte le partite. Poiché autocmd va sempre nella cartella del file corrente, è facile lavorare. Se ci sei foo/bar.pye vuoi andare da foo/baz.pysolo fallo :e baz.pye ci sei. Funziona anche con i buffer ( :b foo^Delenca tutti i buffer che iniziano con foo)