Sto cercando il modo migliore per eseguire la ricerca e la sostituzione (con conferma) in tutti i file di progetto in Vim. Per "file di progetto" intendo i file nella directory corrente, alcuni dei quali non devono essere aperti.

Un modo per farlo potrebbe essere semplicemente aprire tutti i file nella directory corrente:

:args ./**

e poi fai la ricerca e sostituisci su tutti i file aperti:

:argdo %s/Search/Replace/gce

Tuttavia, quando lo faccio, l'utilizzo della memoria di Vim passa da un paio di dozzine di MB a oltre 2 GB, il che non funziona per me.

Ho anche installato il plugin EasyGrep , ma non funziona quasi mai: o non trova tutte le occorrenze o si blocca finché non premo CtrlC. Finora il mio modo preferito per eseguire questa operazione è ack-grep per il termine di ricerca, utilizzando la sua finestra di correzione rapida apri qualsiasi file che contiene il termine e non è stato aperto prima, e infine :bufdo %s/Search/Replace/gce.

Sto cercando un buon plugin funzionante che possa essere utilizzato per questo, o in alternativa un comando / sequenza di comandi che sarebbe più semplice di quello che sto usando ora.

Greplace funziona bene per me.

C'è anche una versione pronta per i patogeni su GitHub.

L'altra grande opzione qui è semplicemente non usare vim:

sed -i 's/pattern/replacement/' <files>

o se hai un modo per generare un elenco di file, forse qualcosa del genere:

find . -name *.cpp | xargs sed -i 's/pattern/replacement/'
grep -rl 'pattern1' | xargs sed -i 's/pattern2/replacement/'

e così via!

MODIFICA: usa il cfdocomando invece di cdoridurre in modo significativo la quantità di comandi che verranno eseguiti per ottenere ciò (perché cdoesegue i comandi su ogni elemento mentre cfdoesegue i comandi su ogni file)

Grazie al cdocomando aggiunto di recente , ora puoi farlo in due semplici comandi usando qualunque grepstrumento tu abbia installato. Nessun plugin aggiuntivo richiesto !:

1. :grep <search term>
2. :cdo %s/<search term>/<replace term>/gc
3. (If you want to save the changes in all files) :cdo update

( cdoesegue il comando dato a ciascun termine nell'elenco quickfix, che il tuo grepcomando popola.)

(Rimuovere calla fine del 2 ° comando se si desidera sostituire ogni termine di ricerca senza confermare ogni volta)

Ho deciso di utilizzare ack e Perl per risolvere questo problema in modo da sfruttare le più potenti espressioni regolari Perl complete piuttosto che il sottoinsieme GNU.

ack -l 'pattern' | xargs perl -pi -E 's/pattern/replacement/g'

Spiegazione

ack

ACK è un fantastico strumento di riga di comando che è un mix di grep, finde completa le espressioni regolari Perl (non solo il sottoinsieme GNU). È scritto in puro Perl, è veloce, ha l'evidenziazione della sintassi, funziona su Windows ed è più amichevole per i programmatori rispetto ai tradizionali strumenti da riga di comando. Installalo su Ubuntu con sudo apt-get install ack-grep.

xargs

Xargs è un vecchio strumento da riga di comando unix. Legge gli elementi dallo standard input ed esegue il comando specificato seguito dagli elementi letti per lo standard input. Quindi, in pratica, l'elenco dei file generati da ack viene aggiunto alla fine del perl -pi -E 's/pattern/replacemnt/g'comando.

perl -pi

Perl è un linguaggio di programmazione. L'opzione -p fa sì che Perl crei un ciclo attorno al programma che itera sugli argomenti del nome del file. L'opzione -i fa in modo che Perl modifichi il file sul posto. Puoi modificarlo per creare backup. L'opzione -E fa in modo che Perl esegua l'unica riga di codice specificata come programma. Nel nostro caso il programma è solo una sostituzione di regex Perl. Per ulteriori informazioni sulle opzioni della riga di comando Perl perldoc perlrun. Per ulteriori informazioni su Perl, vedere http://www.perl.org/ .

forse fai questo:

:noautocmd vim /Search/ **/*
:set hidden
:cfirst
qa
:%s//Replace/gce
:cnf
q
1000@a
:wa

Spiegazione:

• :noautocmd vim /Search/ **/*⇒ cercare ( vimè l'abbreviazione di vimgrep) pattern in tutti i file in tutte le sottodirectory del cwd senza attivare autocmds ( :noautocmd), per motivi di velocità.
• :set hidden ⇒ consenti di avere buffer modificati non visualizzati in una finestra (potrebbe essere nel tuo vimrc)
• :cfirst ⇒ vai al primo risultato della ricerca
• qa ⇒ avviare la registrazione di una macro nel registro a
• :%s//Replace/gce⇒ sostituire tutte le occorrenze dell'ultimo modello di ricerca (ancora /Search/in quel momento) con Replace:
  • più volte sulla stessa riga ( gbandiera)
  • con conferma utente ( cflag)
  • senza errore se non è stato trovato alcun pattern ( eflag)
• :cnf⇒ passare al file successivo nell'elenco creato dal vimcomando
• q ⇒ interrompere la registrazione della macro
• 1000@a ⇒ riprodurre la macro memorizzata nel registro per 1000 volte
• :wa ⇒ salva tutti i buffer modificati

* MODIFICA * Vim 8 vie:

A partire da Vim 8 c'è un modo migliore per farlo, poiché :cfdoitera su tutti i file nell'elenco quickfix:

:noautocmd vim /Search/ **/*
:set hidden
:cfdo %s//Replace/gce
:wa

Popola :argsda un comando di shell

È possibile (su alcuni sistemi operativi ¹ )) fornire i file :argstramite un comando di shell.

Ad esempio, se hai installato ack ² ,

:args `ack -l pattern`

chiederà a ack di restituire un elenco di file contenenti "pattern" e di inserirli nell'elenco degli argomenti.

O con il semplice grep, immagino che sarebbe:

:args `grep -lr pattern .`  

Puoi quindi usare semplicemente :argdocome descritto dall'OP:

:argdo %s/pattern/replacement/gce

Popolare :argsdall'elenco di correzione rapida

Controlla anche la risposta di nelstrom a una domanda correlata che descrive un semplice comando definito dall'utente che popola l'arglist dall'elenco corrente di quickfix. Funziona alla grande con molti comandi e plugin il cui output finisce nella lista di quickfix ( :vimgrep, :Ack³ , :Ggrep⁴ ).

La sequenza per eseguire una ricerca a livello di progetto potrebbe quindi essere eseguita con:

:vimgrep /pattern/ **/*
:Qargs 
:argdo %s/findme/replacement/gc

dove :Qargsè la chiamata al comando definito dall'utente che popola l'arglist dall'elenco quickfix.

Nella discussione successiva troverai anche collegamenti a semplici plug-in che riducono questo flusso di lavoro a 2 o 3 comandi.

link

1. : h {arglist} - vimdoc.sourceforge.net/htmldoc/editing.html#{arglist}
2. ack - betterthangrep.com/
3. ack.vim - github.com/mileszs/ack.vim
4. fuggitivo - github.com/tpope/vim-fugitive

Un'altra opzione nel 2016, il plugin far.vim :

Se non ti dispiace introdurre la dipendenza esterna, ho preparato un plugin ctrlsf.vim (dipende da ack o ag ) per fare il lavoro.

Può formattare e visualizzare i risultati della ricerca da ack / ag e sincronizzare le modifiche nel buffer dei risultati con i file effettivi sul disco.

Forse la seguente demo spiega di più

1. :grep <search term> (or whatever you use to populate the quickfix window)
2. :cfdo %s/<search term>/<replace term>/g | update

Il passaggio 1 popola l'elenco di correzione rapida con gli elementi desiderati. In questo caso, viene propagato con i termini di ricerca che desideri modificare tramite grep.

cfdoesegue il comando seguente su ogni file nell'elenco quickfix. Digita :help cfdoper i dettagli.

s/<search term>/<replace term>/gsostituisce ogni termine. /gsignifica sostituire ogni occorrenza nel file.

| update salva il file dopo ogni sostituzione.

L'ho messo insieme sulla base di questa risposta e dei suoi commenti, ma ho ritenuto che meritasse una sua risposta poiché è tutto in un unico posto.

Fondamentalmente, volevo la sostituzione in un unico comando e, cosa più importante, all'interno di vim stesso

Sulla base della risposta di @Jefromi ho creato una scorciatoia da tastiera, che avevo impostato nel mio file .vimrc come questo

nmap <leader>r :!grep -r -l  * \| xargs sed -i -e 's///g'

ora da vim, con un colpo di leader + r ottengo il comando caricato in vim, che modifico come sotto,

:!grep -r -l <find> <file pattern> | xargs sed -i -e 's/<find>/<replace>/g'

Quindi, eseguo la sostituzione con un singolo comando e, cosa più importante, all'interno di vim stesso