Come fare una ricerca / sostituzione ricorsiva di una stringa con awk o sed?

Come trovo e sostituisco ogni ricorrenza di:

subdomainA.example.com

con

subdomainB.example.com

in ogni file di testo sotto l' /home/www/albero della directory ricorsivamente?

find /home/www \( -type d -name .git -prune \) -o -type f -print0 | xargs -0 sed -i 's/subdomainA\.example\.com/subdomainB.example.com/g'

-print0indica finddi stampare ciascuno dei risultati separati da un carattere null, anziché da una nuova riga. Nel caso improbabile che la tua directory contenga file con nuove righe nei nomi, ciò consente comunque di xargslavorare sui nomi di file corretti.

\( -type d -name .git -prune \)è un'espressione che ignora completamente tutte le directory denominate .git. Potresti facilmente espanderlo, se usi SVN o hai altre cartelle che vuoi conservare - basta abbinarle a più nomi. È approssimativamente equivalente a -not -path .git, ma più efficiente, perché invece di controllare ogni file nella directory, lo salta del tutto. Il -odopo è necessario a causa di come -prunefunziona effettivamente.

Per ulteriori informazioni, vedere man find.

Nota : non eseguire questo comando su una cartella che include un repository git: le modifiche a .git potrebbero danneggiare l'indice git.

find /home/www/ -type f -exec \
    sed -i 's/subdomainA\.example\.com/subdomainB.example.com/g' {} +

Rispetto ad altre risposte qui, questo è più semplice della maggior parte e utilizza sed invece di perl, che è ciò che la domanda originale ha posto.

Il modo più semplice per me è

grep -rl oldtext . | xargs sed -i 's/oldtext/newtext/g'

Tutti i trucchi sono quasi uguali, ma mi piace questo:

find <mydir> -type f -exec sed -i 's/<string1>/<string2>/g' {} +

• find <mydir>: cerca nella directory.

• -type f:

  Il file è di tipo: file normale

• -exec command {} +:

  Questa variante dell'azione -exec esegue il comando specificato sui file selezionati, ma la riga di comando viene creata aggiungendo alla fine ciascun nome di file selezionato; il numero totale di invocazioni del comando sarà molto inferiore al numero di file corrispondenti. La riga di comando è costruita nello stesso modo in cui xargs costruisce le sue righe di comando. Nel comando è consentita solo un'istanza di `{} '. Il comando viene eseguito nella directory iniziale.

cd /home/www && find . -type f -print0 |
  xargs -0 perl -i.bak -pe 's/subdomainA\.example\.com/subdomainB.example.com/g'

Per me la soluzione più semplice da ricordare è https://stackoverflow.com/a/2113224/565525 , ovvero:

sed -i '' -e 's/subdomainA/subdomainB/g' $(find /home/www/ -type f)

NOTA : -i ''risolve il problema OSXsed: 1: "...": invalid command code .

NOTA : se ci sono troppi file da elaborare, otterrai Argument list too long. Soluzione alternativa: utilizzo find -execo xargssoluzione sopra descritti.

Per chiunque usi Silver Searcher ( ag)

ag SearchString -l0 | xargs -0 sed -i 's/SearchString/Replacement/g'

Poiché ag ignora git / hg / svn file / cartelle per impostazione predefinita, è sicuro eseguirlo all'interno di un repository.

Una bella oneliner come extra. Usando git grep.

git grep -lz 'subdomainA.example.com' | xargs -0 perl -i'' -pE "s/subdomainA.example.com/subdomainB.example.com/g"

Per ridurre i file in modo ricorsivo sed, è possibile grepper l'istanza della stringa:

grep -rl <oldstring> /path/to/folder | xargs sed -i s^<oldstring>^<newstring>^g

Se corri man grepnoterai che puoi anche definire una --exlude-dir="*.git"bandiera se vuoi omettere di cercare nelle directory .git, evitando problemi di indice git come altri hanno cortesemente sottolineato.

Ti guida a:

grep -rl --exclude-dir="*.git" <oldstring> /path/to/folder | xargs sed -i s^<oldstring>^<newstring>^g

Questo è compatibile con i repository git e un po 'più semplice:

Linux:

git grep -l 'original_text' | xargs sed -i 's/original_text/new_text/g'

Mac:

git grep -l 'original_text' | xargs sed -i '' -e 's/original_text/new_text/g'

(Grazie a http://blog.jasonmeridth.com/posts/use-git-grep-to-replace-strings-in-files-in-your-git-repository/ )

find /home/www/ -type f -exec perl -i.bak -pe 's/subdomainA\.example\.com/subdomainB.example.com/g' {} +

find /home/www/ -type f elencherà tutti i file in / home / www / (e le sue sottodirectory). Il flag "-exec" indica a find di eseguire il seguente comando su ogni file trovato.

perl -i.bak -pe 's/subdomainA\.example\.com/subdomainB.example.com/g' {} +

è il comando eseguito sui file (molti alla volta). Il {}viene sostituito da nomi di file. Alla +fine del comando dice finddi creare un comando per molti nomi di file.

Per la findpagina man: "La riga di comando è costruita più o meno allo stesso modo in cui xargs costruisce le sue linee di comando."

Quindi è possibile raggiungere il tuo obiettivo (e gestire nomi di file contenenti spazi) senza usare xargs -0, o -print0.

Ne avevo solo bisogno e non ero contento della velocità degli esempi disponibili. Quindi ho pensato al mio:

cd /var/www && ack-grep -l --print0 subdomainA.example.com | xargs -0 perl -i.bak -pe 's/subdomainA\.example\.com/subdomainB.example.com/g'

Ack-grep è molto efficiente nella ricerca di file rilevanti. Questo comando ha sostituito ~ 145 000 file con un gioco da ragazzi, mentre altri hanno impiegato così tanto tempo che non potevo aspettare fino al termine.

Un metodo semplice se è necessario escludere directory ( --exclude-dir=.svn) e potrebbe anche avere nomi di file con spazi (utilizzando 0Byte con grep -Zexargs -0

grep -rlZ oldtext . --exclude-dir=.svn | xargs -0 sed -i 's/oldtext/newtext/g'

Il modo più semplice per sostituire ( tutti i file, directory, ricorsivo )

find . -type f -not -path '*/\.*' -exec sed -i 's/foo/bar/g' {} +

Nota: a volte potrebbe essere necessario ignorare alcuni file nascosti, ad esempio .gitè possibile utilizzare il comando sopra.

Se si desidera includere l'uso di file nascosti,

find . -type f  -exec sed -i 's/foo/bar/g' {} +

In entrambi i casi la stringa fooverrà sostituita con una nuova stringabar

grep -lr 'subdomainA.example.com' | while read file; do sed -i "s/subdomainA.example.com/subdomainB.example.com/g" "$file"; done

Immagino che la maggior parte delle persone non sappia di poter reindirizzare qualcosa in un "file di lettura" e questo evita quegli argomenti cattivi -print0, salvando gli spazi nei nomi dei file.

L'aggiunta ulteriore di echoprima di sed ti consente di vedere quali file cambieranno prima di farlo.

Puoi usare awk per risolverlo come di seguito,

for file in `find /home/www -type f`
do
   awk '{gsub(/subdomainA.example.com/,"subdomainB.example.com"); print $0;}' $file > ./tempFile && mv ./tempFile $file;
done

spero che questo ti possa aiutare !!!

Prova questo:

sed -i 's/subdomainA/subdomainB/g' `grep -ril 'subdomainA' *`

#!/usr/local/bin/bash -x

find * /home/www -type f | while read files
do

sedtest=$(sed -n '/^/,/$/p' "${files}" | sed -n '/subdomainA/p')

    if [ "${sedtest}" ]
    then
    sed s'/subdomainA/subdomainB/'g "${files}" > "${files}".tmp
    mv "${files}".tmp "${files}"
    fi

done

Secondo questo post del blog:

find . -type f | xargs perl -pi -e 's/oldtext/newtext/g;'

Se non ti dispiace usare viminsieme a grepo findstrumenti, potresti seguire la risposta data dall'utente Gert in questo link -> Come fare una sostituzione del testo in una gerarchia di cartelle grandi? .

Ecco l'accordo:

• ricorsivamente grep per la stringa che si desidera sostituire in un determinato percorso e prendere solo il percorso completo del file corrispondente. (quello sarebbe il $(grep 'string' 'pathname' -Rl).

• (facoltativo) se si desidera effettuare un pre-backup di tali file su una directory centralizzata, è possibile utilizzare anche questo: cp -iv $(grep 'string' 'pathname' -Rl) 'centralized-directory-pathname'

• successivamente puoi modificare / sostituire a piacimento vimseguendo uno schema simile a quello fornito sul link indicato:

  • :bufdo %s#string#replacement#gc | update

Un po 'vecchia scuola ma questo ha funzionato su OS X.

Ci sono alcuni trucchi:

• Modifica solo i file con estensione .slsnella directory corrente

• .deve essere evitato per assicurarsi sedche non li valuti come "qualsiasi carattere"

• ,è usato come seddelimitatore invece del solito/

Nota anche che serve per modificare un modello Jinja per passare a variablenel percorso di un import(ma questo è fuori tema).

Innanzitutto, verifica che il tuo comando sed faccia quello che vuoi (questo stamperà solo le modifiche a stdout, non cambierà i file):

for file in $(find . -name *.sls -type f); do echo -e "\n$file: "; sed 's,foo\.bar,foo/bar/\"+baz+\"/,g' $file; done

Modifica il comando sed quando necessario, quando sei pronto per apportare modifiche:

for file in $(find . -name *.sls -type f); do echo -e "\n$file: "; sed -i '' 's,foo\.bar,foo/bar/\"+baz+\"/,g' $file; done

Nota -i ''nel comando sed , non volevo creare un backup dei file originali (come spiegato in Modifiche sul posto con sed su OS X o nel commento di Robert Lujo in questa pagina).

Felice gente seding!

solo per evitare di cambiare anche

• NearlysubdomainA.example.com
• subdomainA.example.comp.other

ma comunque

• subdomainA.example.com.IsIt.good

(forse non buono nell'idea alla base della radice del dominio)

find /home/www/ -type f -exec sed -i 's/\bsubdomainA\.example\.com\b/\1subdomainB.example.com\2/g' {} \;

Uso solo top:

find . -name '*.[c|cc|cp|cpp|m|mm|h]' -print0 |  xargs -0 tops -verbose  replace "verify_noerr(<b args>)" with "__Verify_noErr(<args>)" \
replace "check(<b args>)" with "__Check(<args>)" 

Ecco una versione che dovrebbe essere più generale della maggior parte; non richiede find(usando duinvece), per esempio. Richiede xargs, che si trovano solo in alcune versioni di Plan 9 (come 9front).

 du -a | awk -F' '  '{ print $2 }' | xargs sed -i -e 's/subdomainA\.example\.com/subdomainB.example.com/g'

Se vuoi aggiungere filtri come le estensioni dei file usa grep:

 du -a | grep "\.scala$" | awk -F' '  '{ print $2 }' | xargs sed -i -e 's/subdomainA\.example\.com/subdomainB.example.com/g'

Per Qshell (qsh) su IBMi, non bash come taggato da OP.

Limitazioni dei comandi qsh:

• find non ha l'opzione -print0
• xargs non ha l'opzione -0
• sed non ha l'opzione -i

Quindi la soluzione in qsh:

    PATH='your/path/here'
    SEARCH=\'subdomainA.example.com\'
    REPLACE=\'subdomainB.example.com\'

    for file in $( find ${PATH} -P -type f ); do

            TEMP_FILE=${file}.${RANDOM}.temp_file

            if [ ! -e ${TEMP_FILE} ]; then
                    touch -C 819 ${TEMP_FILE}

                    sed -e 's/'$SEARCH'/'$REPLACE'/g' \
                    < ${file} > ${TEMP_FILE}

                    mv ${TEMP_FILE} ${file}
            fi
    done

Avvertenze:

• La soluzione esclude la gestione degli errori
• Non Bash come taggato da OP

Se vuoi usarlo senza distruggere completamente il tuo repository SVN, puoi dire 'trova' per ignorare tutti i file nascosti facendo:

find . \( ! -regex '.*/\..*' \) -type f -print0 | xargs -0 sed -i 's/subdomainA.example.com/subdomainB.example.com/g'

Usando la combinazione di grepesed

for pp in $(grep -Rl looking_for_string)
do
    sed -i 's/looking_for_string/something_other/g' "${pp}"
done

Per sostituire tutte le occorrenze in un repository git è possibile utilizzare:

git ls-files -z | xargs -0 sed -i 's/subdomainA\.example\.com/subdomainB.example.com/g'

Vedi Elenca i file nel repository git locale? per altre opzioni per elencare tutti i file in un repository. Le -zopzioni dicono a git di separare i nomi dei file con zero byte, il che assicura che xargs(con l'opzione -0) è possibile separare i nomi dei file, anche se contengono spazi o quant'altro.

perl -p -i -e 's/oldthing/new_thingy/g' `grep -ril oldthing *`

per modificare più file (e salvare un backup come *.bak):

perl -p -i -e "s/\|/x/g" *

prenderà tutti i file nella directory e sostituirà |con x chiamato "Perl pie" (facile come una torta)