Trova un file (tramite la ricerca di directory ricorsiva) in Vim

C'è un modo per cercare un file in una directory ricorsivamente (usando i caratteri jolly quando necessario) in Vim? Se non in modo nativo, esiste un plugin in grado di gestirlo?

È possibile utilizzare caratteri jolly con il :editcomando. Così,

:e **/test/Suite.java

aprirà test / Suite.java indipendentemente da dove si trovi nella gerarchia di directory corrente. Funziona con il completamento con tabulazione, quindi puoi usare [tab] per espandere i caratteri jolly prima di aprire il file. Vedi anche l' opzione wildmode per un modo per sfogliare tutte le estensioni possibili.

Un altro trucco è usare

:r! find . -type f

per caricare un elenco di tutti i file nella directory corrente in un buffer. Quindi puoi usare tutti i soliti strumenti di manipolazione del testo di vim per navigare / ordinare / tagliare l'elenco e CTRL+W gfper aprire il file sotto il cursore in un nuovo pannello.

C'è un comando di ricerca. Se aggiungi **(vedi :help starstar) al tuo 'path', puoi cercare in modo ricorsivo:

:set path

ti mostrerà il tuo percorso attuale, aggiungi **facendo qualcosa come

:set path+=**

quindi puoi semplicemente digitare

:find myfile.txt

e si apre magicamente!

Se aggiungi il comando set al tuo .vimrc, in futuro potrai eseguire ricerche ricorsive. Non sembra cercare nelle directory dei punti (ad esempio .ssh)

Consiglierei ctrlp.vim . È un ottimo plugin, ideale per lavorare all'interno di grandi progetti. Ha la ricerca per nome file o percorso completo, ricerca regexp, rilevamento automatico della radice del progetto (quella con la cartella .git | hg | svn | bzr | _darcs), esclusioni di nomi di file personalizzati e molto altro.

Basta premere <c-p>e si aprirà un pannello molto intuitivo dove puoi cercare quello che vuoi:

È possibile selezionare e aprire più file contemporaneamente. Accetta anche comandi arbitrari aggiuntivi, come il salto a una certa riga, l'occorrenza di una stringa o qualsiasi altro comando Vim.

Repo: https://github.com/kien/ctrlp.vim

vim come comando find integrato (: help find) ma apre solo il primo file trovato. Tuttavia puoi usare questo fantastico plugin: FuzzyFinder che fa tutto quello che vuoi e anche di più

Puoi sfogliare il file system con :ex . , ma non so come cercare in modo ricorsivo (sono un principiante di Vim - lo uso solo da dieci anni).

Esistono alcuni plug-in di browser di file popolari:

• Albero NERD
• Esploratore lussurioso
• vtreexplorer

Vedi anche questo thread su SuperUser .

Comando-T ti consente di trovare un file molto velocemente semplicemente digitando alcune lettere. Puoi anche aprire il file in una nuova scheda, ma ha bisogno di vim compilato con il supporto per ruby.

Puoi usare ! per eseguire i comandi della shell:

:! find . -name *.xml

vim ha bild in comandi chiamati grep, lgrep, vimgrep o lvimgrep che possono farlo

ecco un tutorial su come usarli http://vim.wikia.com/wiki/Find_in_files_within_Vim#Recursive_Search

puoi anche usare un comando esterno come find o grep da vim eseguendolo in questo modo

:!find ...

Sono sorpreso che nessuno abbia ancora menzionato Unite.vim .

Trovare file (in modo confuso o meno) è solo la punta dell'iceberg di ciò che può fare per uno sviluppatore. Ha integrato il supporto per ag, gite una miriade di altri programmi / utilità / plugin vim. La curva di apprendimento può essere un po 'ripida, ma non riesco a immaginare la mia vita senza di essa. La base di utenti è ampia e i bug vengono corretti immediatamente.

Ricerca dei risultati simile a Quickfix

Utilizzo:

Find my.regex

Risultato:

• si apre una nuova scheda
• ogni riga contiene un percorso relativo che corrisponde a una grep -Eregex
• colpire:
  • <enter>o <C-w>gfper aprire il file sulla riga corrente in una nuova scheda
  • gf per aprire il file nella scheda corrente e perdere l'elenco dei file

Trova invece tutti i file:

Find

Metodi alternativi:

• Gfind my.regex: cerca solo i file tracciati da Git ( git ls-files). Richiesta fuggitiva: https://github.com/tpope/vim-fugitive/issues/132#issuecomment-200749743
• Gtfind my.regex: like Gfind, ma cerca dal livello git Top invece che dalla directory corrente
• Locate somefile: locateversione

Codice:

function! Find(cmd)
  let l:files = system(a:cmd)
  if (l:files =~ '^\s*$')
    echomsg 'No matching files.'
    return
  endif
  tabedit
  set filetype=filelist
      set buftype=nofile
  " TODO cannot open two such file lists with this. How to get a nice tab label then?
  " http://superuser.com/questions/715928/vim-change-label-for-specific-tab
  "file [filelist]
  put =l:files
  normal ggdd
  nnoremap <buffer> <Enter> <C-W>gf
  execute 'autocmd BufEnter <buffer> lcd ' . getcwd()
endfunction
command! -nargs=1 Find call Find("find . -iname '*'" . shellescape('<args>') . "'*'")
command! -nargs=1 Gfind call Find('git ls-files | grep -E ' . shellescape('<args>'))
command! -nargs=1 Gtfind call Find('git rev-parse --show-toplevel && git ls-files | grep -E ' . shellescape('<args>'))
command! -nargs=1 Locate call Find('locate ' . shellescape('<args>'))

A seconda della tua situazione (cioè, supponendo che il seguente comando trovi solo un singolo file), forse usa un comando come:

:e `locate SomeUniqueFileName.java`

Questo farà sì che Vim apra, nella scheda corrente (il comando e) un file che è il risultato dell'esecuzione (in questo esempio),

locate SomeUniqueFileName.java

Nota che la magia qui è il backtick attorno al comando, che convertirà l'output del comando di shell in testo utilizzabile nel comando Vim.

Non è necessario un plug-in solo per questa funzione, è sufficiente lo snippet di codice riportato di seguito.

function! FindFiles()
    call inputsave()
    let l:dir = input("Find file in: ", expand("%:p:h"), "dir")
    call inputrestore()
    if l:dir != ""
        call inputsave()
        let l:file = input("File name: ")
        call inputrestore()
        let l:nf = 'find '.l:dir.' -type f -iname '.l:file.' -exec grep -nH -m 1 ".*" {} \;'
        lexpr system(l:nf)
    endif
endfunction
nnoremap <silent> <leader>fo :call FindFiles()<CR>

Correre:

:args `find . -name '*xml'`

Vim eseguirà il comando della shell in backtick, metterà l'elenco dei file in arglist e aprirà il primo file. Quindi è possibile utilizzare :argsper visualizzare l'elenco (cioè elencare i file trovati) :ne :Nper navigare avanti e indietro tra i file in arglist. Vedi https://vimhelp.org/editing.txt.html#%7Barglist%7D e https://vimhelp.org/editing.txt.html#backtick-expansion

Puoi trovare i file ricorsivamente nel tuo "percorso" con questo plugin . Supporta anche il completamento tramite tabulazione per il nome del file.

Lo strumento ag e il corrispondente plugin Ag vim risolvono perfettamente questo problema:

Per trovare un file usando un modello usa:

AgFile! pattern

Si aprirà la finestra di correzione rapida con i risultati in cui puoi scegliere.

È possibile aggiungere la combinazione di tasti vim per chiamare questo comando utilizzando la parola selezionata come modello.

nnoremap <silent> <C-h> :AgFile! '<C-R><C-W>'<CR>
vnoremap <silent> <C-h> y :AgFile! '<C-R>"'<CR>