Come lavorare in modo efficace con più file in Vim

Ho iniziato a usare Vim per sviluppare script Perl e sto iniziando a trovarlo molto potente.

Una cosa che mi piace è poter aprire più file contemporaneamente con:

vi main.pl maintenance.pl

e poi saltali tra loro con:

:n
:prev

e vedi quale file è aperto con:

:args

E per aggiungere un file, posso dire:

:n test.pl

che mi aspetto sarebbe quindi aggiunto al mio elenco di file, ma invece cancella il mio elenco di file corrente e quando scrivo :argsho solo test.plaperto.

Quindi, come posso aggiungere e rimuovere i file nel mio elenco args?

Perché non usare le schede (introdotte in Vim 7)? È possibile alternare tra le schede con :tabne :tabp, Con :tabe <filepath>è possibile aggiungere una nuova scheda; e con un normale :qo :wqsi chiude una scheda. Se si esegue il mapping :tabne :tabpai vostri F7/ F8chiavi si può facilmente passare da un file.

Se non ci sono che molti file o non si dispone Vim 7 si può anche dividere lo schermo in più file: :sp <filepath>. Quindi è possibile passare da una schermata divisa a Ctrl+ We quindi un tasto freccia nella direzione in cui si desidera spostarsi (o invece dei tasti freccia, wper la schermata iniziale e successiva W)

Listing

Per visualizzare un elenco dei buffer correnti, utilizzo:

:ls

Apertura

Per aprire un nuovo file, io uso

:e ../myFile.pl

con il completamento della scheda migliorato (inserisci il set wildmenutuo .vimrc).

Nota: puoi anche utilizzare ciò :findche cercherà per te una serie di percorsi, ma devi prima personalizzarli.

commutazione

Per passare tra tutti i file aperti, utilizzo

:b myfile

con completamento della scheda migliorato (ancora set wildmenu).

Nota: :b#sceglie l'ultimo file visitato, quindi è possibile utilizzarlo per passare rapidamente da un file all'altro.

Utilizzando windows

Ctrl-W se Ctrl-W vper dividere la finestra corrente in orizzontale e in verticale. Puoi anche usare :splite :vertical split( :spe :vs)

Ctrl-W wper passare tra le finestre aperte e Ctrl-W h(o jo ko l) per navigare tra le finestre aperte.

Ctrl-W cper chiudere la finestra corrente e Ctrl-W oper chiudere tutte le finestre tranne quella corrente.

L'avvio di vim con un flag -oo -Oapre ogni file nella sua divisione.

Con tutto ciò non ho bisogno di schede in Vim e le mie dita trovano i miei buffer, non i miei occhi.

Nota: se si desidera che tutti i file vadano nella stessa istanza di Vim, avviare Vim con l' --remote-silentopzione.

:ls

per un elenco di buffer aperti

• :bp buffer precedente
• :bn buffer successivo
• :bn( nun numero) passa all'ennesimo buffer
• :b <filename-part> con tasto tab che fornisce il completamento automatico (fantastico !!)

In alcune versioni di vim, bne bpsono in realtà bnexte bprevious, rispettivamente. Il completamento automatico della scheda è utile in questo caso.

O quando sei in modalità normale, usa ^per passare all'ultimo file su cui stavi lavorando.

Inoltre, puoi salvare sessioni di vim

:mksession! ~/today.ses

Il comando precedente salva i buffer e le impostazioni correnti del file aperto ~/today.ses. È possibile caricare quella sessione utilizzando

vim -S ~/today.ses

Nessun problema a ricordare da dove eri rimasto ieri. ;)

Per aggiungere argsall'elenco:

:argadd

Per eliminare argsdall'elenco:

:argdelete

Nel tuo esempio, potresti usare :argedittest.pl per aggiungere test.pl argsall'elenco e modificare il file in un solo passaggio.

:help args offre molti più dettagli e un uso avanzato

Uso i comandi buffer - :bn(buffer successivo), :bp(buffer precedente) :buffers(elenca buffer aperti) :b<n>(buffer aperto n) :bd(cancella buffer). :e <filename>si aprirà in un nuovo buffer.

Penso che potresti usare il comando sbagliato per guardare l'elenco dei file che hai aperto.

Prova a fare un :lsper vedere l'elenco dei file che hai aperto e vedrai:

   1 %a   "./checkin.pl"            line 1
  2 #    "./grabakamailogs.pl"     line 1
  3      "./grabwmlogs.pl"         line 0
  etc.

È quindi possibile rimbalzare attraverso i file facendo riferimento ad essi con i numeri elencati, ad esempio: 3b

oppure puoi dividere lo schermo inserendo il numero ma usando sb anziché semplicemente b.

A parte,% si riferisce al file attualmente visibile e # si riferisce al file alternativo.

È possibile alternare facilmente tra questi due file premendo Ctrl Shift 6

Modifica: come :lspuoi usare :regper vedere i contenuti attuali dei tuoi registri inclusi i registri 0-9 che contengono ciò che hai eliminato. Ciò è particolarmente utile se desideri riutilizzare del testo che hai precedentemente eliminato.

Vim (ma non il Vi originale) ha schede che trovo (in molti contesti) superiori ai buffer. Puoi dire :tabe [filename]di aprire un file in una nuova scheda. Per spostarsi tra le schede, fare clic sulla scheda o tramite le combinazioni di tasti [ n ] gte gT. Graphic Vim ha anche schede grafiche.

Molte risposte qui! Quello che uso senza reinventare la ruota: i plugin più famosi (che non moriranno presto e che sono usati da molte persone) per essere ultra veloci e geek.

• ctrlpvim / ctrlp.vim - per trovare il file per nome ricerca fuzzy per la sua posizione o solo il suo nome
• jlanzarotta / bufexplorer - per sfogliare i buffer aperti (quando non ricordi quanti file hai aperto e modificato di recente e non ricordi dove si trovano, probabilmente perché li hai cercati con Ag)
• rking / ag.vim per cercare i file rispetto a gitignore
• scrooloose / nerdtree per vedere la struttura della directory, cercare, aggiungere / cancellare / modificare i file

EDIT: Recentemente ho usato dyng / ctrlsf.vim per cercare con vista contestuale (come la ricerca sublime) e ho cambiato il motore da ag a ripgrep . Le prestazioni sono eccezionali.

EDIT2: insieme a CtrlSF puoi usare mg979 / vim-visual-multi , apportare modifiche a più file contemporaneamente e poi alla fine salvarli in una volta sola.

Cose come :ee :baddaccetteranno solo UN argomento, quindi i seguenti falliranno

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

Se si desidera aggiungere più file da VIM, utilizzare arga[dd]

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

Alcune risposte in questo thread suggeriscono di usare le schede e altri suggeriscono di usare il buffer per ottenere lo stesso risultato. Schede e buffer sono diversi. Consiglio vivamente di leggere questo articolo " Vim Tab madness - Buffers vs Tabs ".

Ecco un bel riassunto che ho tratto dall'articolo:

Sommario:

• Un buffer è il testo in memoria di un file.
• Una finestra è una finestra su un buffer.
• Una scheda è una raccolta di finestre.

Quando utilizzo più file in vim, utilizzo principalmente questi comandi (con ~ 350 file aperti):

• :b <partial filename><tab> (passa a un buffer)
• :bw (pulire il buffer, rimuovere un buffer)
• :e <file path> (modifica, apri un nuovo buffer>
• pltags - abilita il salto alle definizioni di subroutine / metodo

Aggiunta di un'altra risposta in quanto questa non è coperta da nessuna delle risposte

Per modificare tutti i buffer da tabvisualizzare.

 :tab sball

aprirà tutti i buffer alla vista tab. Quindi possiamo usare qualsiasi comando relativo alla scheda

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

dettagli a :help tab-page-commands .

Possiamo incaricare vim di aprire, come vista tab, più file di vim -p file1 file2. alias vim='vim -p'sarà utile.
La stessa cosa si può ottenere anche dopo aver seguito il comando automatico~/.vimrc

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

Comunque per rispondere alla domanda: per aggiungere all'elenco arg: arga file ,

Per eliminare dall'elenco arg: argd pattern

Più a :help arglist

Potresti voler usare i marchi globali Vim .

In questo modo puoi rimbalzare rapidamente tra i file e persino nella posizione contrassegnata nel file. Inoltre, i comandi da tastiera sono brevi: 'C mi porta al codice con cui sto lavorando, 'T mi porta al test unitario con cui sto lavorando.

Quando cambiate posto, anche il ripristino dei segni è rapido: mC segna il nuovo punto del codice, mT segna il nuovo punto del test.

Uso lo stesso file .vimrc per gVim e la riga di comando Vim. Tendo a usare le schede in gVim e nei buffer nella riga di comando Vim, quindi ho il mio .vimrc impostato per semplificare il lavoro con entrambi:

" 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

Ciò blocca le mappature esistenti per He L, ma rende il passaggio tra file estremamente rapido e semplice. Basta premere Hper il prossimo e Lper il precedente; indipendentemente dal fatto che tu stia utilizzando schede o buffer, otterrai i risultati desiderati.

Se hai intenzione di utilizzare più buffer, penso che la cosa più importante sia impostare nascosto in modo che ti consenta di cambiare buffer anche se hai modifiche non salvate in quello che stai lasciando.

Se si utilizzano solo i comandi integrati di VIM , il migliore che abbia mai visto per passare da un buffer multiplo all'altro è questo:

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

Esso combina perfettamente sia :lse :bcomandi - sfogliare tutti i buffer aperti e vi aspetta per inserire il comando per buffer di scambio.

Dato sopra mappato in vimrc, una volta digitato <Leader>f,

• Vengono visualizzati tutti i buffer aperti
• Puoi:
  • Digitare 23per andare al buffer 23,
  • Digitare #per passare al buffer alternativo / MRU,
  • Digita il nome parziale del file, quindi digita <Tab>o <C-i>per completare automaticamente,
  • O semplicemente <CR>o <Esc>per rimanere sul buffer corrente

Un'istantanea dell'output per la mappatura dei tasti sopra è:

: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'

Nell'istantanea sopra:

• Seconda colonna: %aper corrente, hper nascosto,# per precedente, vuoto per non è stato impostato su.
• Terza colonna: +per modificato.

Inoltre, consiglio vivamente set hidden. Vedere :help 'hidden'.

Uso quanto segue, questo ti dà molte funzionalità che ti aspetteresti di avere in altri editor come Sublime Text / Textmate

1. Usa buffer non "pagine di tab". I buffer hanno lo stesso concetto delle schede in quasi tutti gli altri editor.
2. Se si desidera che lo stesso aspetto di avere schede è possibile utilizzare il vim-compagnia aerea plugin con la seguente impostazione nel vostro .vimrc: let g:airline#extensions#tabline#enabled = 1. Ciò visualizza automaticamente tutti i buffer come intestazioni di tabulazione quando non sono aperte le pagine di tabulazione
3. Usa Tim Pope senza compromessi che dà [be]b per passare rispettivamente ai buffer precedenti / successivi (oltre a tutta una serie di altre chicche)
4. Avere set wildmenunel tuo .vimrcquindi quando si digita :b <file part>+Tab per un buffer si otterrà un elenco di possibili buffer che è possibile utilizzare le frecce sinistra / destra per scorrere
5. Usa il plugin vim-obsession di Tim Pope per archiviare sessioni che si adattano perfettamente alla compagnia aerea (ho avuto molto dolore con sessioni e plugin )
6. Usa Tim Pope's plugin vim-aceto di . Funziona con il nativo :Explorema rende molto più facile lavorare con. Basta digitare -per aprire Esplora risorse, che è la stessa chiave per accedere a una directory in Esplora risorse. Rende la navigazione più veloce (tuttavia con FZF lo uso raramente)
7. fzf (che può essere installato come plugin vim) è anche un potente fuzzy finder che puoi usare per cercare file (e anche buffer). fzf gioca anche molto bene con fd (una versione più veloce di find)
8. Usa Ripgrep con vim-ripgrep per cercare nella tua base di codice e quindi puoi usare :cdoi risultati per fare ricerca e sostituire

Il mio modo di lavorare efficacemente con più file è usare tmux.

Ti permette di dividere le finestre in verticale e in orizzontale, come in:

Ho funzionato in questo modo su entrambi i miei computer Mac e Linux e lo trovo migliore del meccanismo di commutazione del riquadro della finestra nativo fornito (su Mac). Trovo il passaggio più semplice e solo con tmux sono stato in grado di far funzionare la 'nuova pagina nella stessa directory corrente' sul mio mac (nonostante il fatto che ci siano opzioni per aprire nuovi riquadri nella stessa directory) che è un pezzo sorprendentemente critico. Un nuovo riquadro istantaneo nella posizione corrente è incredibilmente utile. Un metodo che esegue nuovi riquadri con le stesse combinazioni di tasti per entrambi i sistemi operativi è fondamentale per me e un bonus per tutti per la futura compatibilità personale. Oltre a più riquadri tmux, ho anche provato a utilizzare più schede, ad es e più nuove finestre, ad esempioe alla fine ho scoperto che più riquadri tmux sono i più utili per me. Sono molto "visivo" e mi piace tenere i miei vari contesti proprio di fronte a me, collegati insieme come riquadri.

tmux supporta anche i riquadri orizzontali e verticali che il più vecchio screennon ha funzionato (anche se iterm2 di mac sembra supportarlo, ma di nuovo, l'attuale impostazione della directory non ha funzionato per me). tmux 1.8

Uso la riga di comando e git molto, quindi ho questo alias nel mio bashrc:

alias gvim="gvim --servername \$(git rev-parse --show-toplevel || echo 'default') --remote-tab"

Questo aprirà ogni nuovo file in una nuova scheda su una finestra esistente e creerà una finestra per ogni repository git. Quindi, se apri due file dal repository A e 3 file dal repository B, finirai con due finestre, una per il repository A con due schede e una per repository B con tre schede.

Se il file che stai aprendo non è contenuto in un repository git, passerà a una finestra predefinita.

Per saltare tra le schede, utilizzo queste mappature:

nmap <C-p> :tabprevious<CR>
nmap <C-n> :tabnext<CR>

Per aprire più file contemporaneamente è necessario combinare questo con una delle altre soluzioni.

Uso più buffer impostati nascosti nel mio ~/.vimrcfile.

Lo script mini-buffer explorer è anche bello per ottenere un bel elenco compatto dei tuoi buffer. Quindi :b1o :b2... per passare al buffer appropriato o utilizzare Explorer mini-buffer e la scheda attraverso i buffer.

prova a seguire le mappe per comodità modificando più file

"Dividi finestre

nmap <leader>sh :leftabove vnew<CR>

nmap <leader>sl :rightbelow vnew<CR>

nmap <leader>sk :leftabove new<CR>

nmap <leader>sj :rightbelow new<CR>

"muoversi

nmap <C-j> <C-w>j

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

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

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

Ho realizzato un video molto semplice che mostra il flusso di lavoro che utilizzo. Fondamentalmente uso il plugin Ctrl-P Vim e ho mappato la navigazione del buffer sul tasto Invio.

In questo modo posso premere Invio in modalità normale, guardare l'elenco dei file aperti (che appare in una piccola nuova finestra nella parte inferiore dello schermo), selezionare il file che voglio modificare e premere di nuovo Invio. Per cercare rapidamente tra più file aperti, basta digitare parte del nome del file, selezionare il file e premere Invio.

Non ho molti file aperti nel video, ma diventa incredibilmente utile quando inizi ad averne molti.

Poiché il plug-in ordina i buffer utilizzando un ordinamento MRU, puoi semplicemente premere Invio due volte e passare al file più recente che stavi modificando.

Dopo l'installazione del plug-in, l'unica configurazione necessaria è:

nmap <CR> :CtrlPBuffer<CR>

Ovviamente puoi mapparlo su una chiave diversa, ma trovo che la mappatura per entrare sia molto utile.

Suggerirei di usare il plugin

NERDtree

Ecco il link github con le istruzioni.

Nerdtree

Uso vim-plug come gestore di plugin, ma puoi usare anche Vundle.

vim-plug

Vundle

Nel mio e in molti altri utenti di VIM, l'opzione migliore è,

• Apri il file usando,

: e nome_file.eestensione

E poi basta Ctrl + 6 per passare all'ultimo buffer. Oppure puoi sempre premere

: ls per elencare il buffer e quindi modificare il buffer usando b seguito dal numero del buffer.

• Facciamo una divisione verticale o orizzontale usando

: vsp per divisione verticale

: sp per divisione orizzontale

E poi <C-W><C-H/K/L/j>per cambiare la divisione funzionante.

Puoi ovviamente modificare qualsiasi file in qualsiasi numero di divisioni.

Quando ho iniziato a utilizzare VIM non mi rendevo conto che le schede dovevano essere utilizzate come layout di finestre diverse e il buffer ha il ruolo di modificare / passare più file tra di loro. In realtà nelle schede iniziali non c'erano nemmeno prima della v7.0 e ho appena aperto un VIM all'interno di una scheda terminale (al momento stavo usando gnome-terminal), e passare da una scheda all'altra usando i numeri alt +, dal momento che ho pensato di usare comandi come : buffers,: bn e: bp erano troppo per me. Quando è stato rilasciato VIM 7.0, trovo che sia più facile gestire molti file e passare a esso, ma recentemente mi sono appena reso conto che i buffer dovrebbero sempre essere la strada da percorrere, a meno che non sia una cosa: è necessario configurarlo per farlo funzionare correttamente.

Così ho provato vim-Airline e ho abilitato la barra di buffer visiva simile a una scheda, ma la grafica stava avendo problemi con il mio iTerm2, quindi ho provato un paio di altri e sembra che MBE funzioni al meglio per me. Ho anche impostato shift + h / l come scorciatoie, dal momento che quelli originali (spostandosi alla testa / coda della pagina corrente) non mi sono molto utili.

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

Sembra essere anche più semplice di gt e gT e: e è più facile di: anche tabnew. Trovo: bd non è così conveniente come: q (MBE ha qualche problema con esso) ma credo di poter vivere con tutti i file nel buffer.

se sei su osx e vuoi essere in grado di fare clic sulle tue schede, usa MouseTerm e SIMBL (presi da qui ). Inoltre, dai un'occhiata a questa discussione correlata .

La maggior parte delle risposte in questo thread stanno usando semplici comandi vim, il che va bene, ma ho pensato che avrei fornito una risposta estesa usando una combinazione di plugin e funzioni che trovo particolarmente utili (almeno alcuni di questi suggerimenti provengono dal file di Gary Bernhardt consigli di navigazione ):

1. Per alternare tra gli ultimi due file basta premere <leader>due volte. Consiglio di assegnare <leader>alla barra spaziatrice:

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

2. Per spostarsi rapidamente in un progetto, la risposta è una soluzione di corrispondenza fuzzy come CtrlP . Lo vincolo <leader>aper un rapido accesso.

3. Nel caso in cui voglio vedere una rappresentazione visiva dei buffer attualmente aperti utilizzo il plugin BufExplorer . Semplice ma efficace.

4. Se volessi sfogliare il file system, userei la riga di comando o un'utilità esterna (Quicklsilver, Afred ecc.) Ma per guardare l'attuale struttura del progetto NERD Tree è un classico. Non utilizzarlo però al posto di 2come metodo di ricerca dei file principale. Ti rallenterà davvero. Uso la rilegatura <leader>ff.

Questi dovrebbero essere sufficienti per trovare e aprire i file. Da lì, naturalmente, usa divisioni orizzontali e verticali. Per quanto riguarda le divisioni, trovo queste funzioni particolarmente utili:

1. Apri nuove divisioni in aree più piccole quando non c'è abbastanza spazio ed espanderle durante la navigazione. Fare riferimento qui per commenti su cosa fanno esattamente:

   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. Passa da una divisione all'altra 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>
   

Si può essere un pazzo assoluto e alias vimper vim -pl'aggiunta nella vostra .bashrc:

alias vim="vim -p"

Ciò comporterà l'apertura di più file dalla shell in schede, senza dover richiamare successivamente :tab ballda VIM.