Comment faire une recherche / remplacement récursif d'une chaîne avec awk ou sed?

Comment trouver et remplacer chaque occurrence de:

subdomainA.example.com

avec

subdomainB.example.com

dans chaque fichier texte sous l' /home/www/arborescence de répertoires récursivement?

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

-print0indique findd'imprimer chacun des résultats séparés par un caractère nul, plutôt qu'une nouvelle ligne. Dans le cas peu probable où votre répertoire contient des fichiers avec des retours à la ligne dans les noms, cela permet toujours de xargstravailler sur les noms de fichiers corrects.

\( -type d -name .git -prune \)est une expression qui ignore complètement tous les répertoires nommés .git. Vous pouvez facilement l'étendre, si vous utilisez SVN ou si vous avez d'autres dossiers que vous souhaitez conserver - il suffit de faire correspondre d'autres noms. C'est à peu près équivalent à -not -path .git, mais plus efficace, car plutôt que de vérifier chaque fichier du répertoire, il l'ignore complètement. le-o après est nécessaire en raison de la façon dont -prunefonctionne réellement.

Pour plus d'informations, voir man find.

Remarque : N'exécutez pas cette commande sur un dossier comprenant un dépôt git - les modifications apportées à .git pourraient corrompre votre index git.

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

Comparé à d'autres réponses ici, c'est plus simple que la plupart et utilise sed au lieu de perl, ce qui était ce que la question initiale demandait.

Le moyen le plus simple pour moi est

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

Tous les trucs sont presque les mêmes, mais j'aime celui-ci:

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

• find <mydir>: recherchez dans le répertoire.

• -type f:

  Le fichier est de type: fichier normal

• -exec command {} +:

  Cette variante de l'action -exec exécute la commande spécifiée sur les fichiers sélectionnés, mais la ligne de commande est créée en ajoutant à la fin chaque nom de fichier sélectionné; le nombre total d'appels de la commande sera bien inférieur au nombre de fichiers correspondants. La ligne de commande est construite de la même manière que xargs construit ses lignes de commande. Une seule instance de `{} 'est autorisée dans la commande. La commande est exécutée dans le répertoire de départ.

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

Pour moi, la solution la plus simple à retenir est https://stackoverflow.com/a/2113224/565525 , à savoir:

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

REMARQUE : -i ''résout le problème OSXsed: 1: "...": invalid command code .

REMARQUE : s'il y a trop de fichiers à traiter, vous obtiendrez Argument list too long. Solution: utilisation find -execou xargssolution décrite ci-dessus.

Pour tous ceux qui utilisent Silver Searcher ( ag)

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

Étant donné qu'ag ignore les fichiers / dossiers git / hg / svn par défaut, cela peut être exécuté en toute sécurité dans un référentiel.

Un joli oneliner en plus. Utilisation de git grep.

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

Pour réduire les fichiers à sedparcourir récursivement , vous pouvez greppour votre instance de chaîne:

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

Si vous exécutez, man grepvous remarquerez que vous pouvez également définir un--exlude-dir="*.git" indicateur si vous souhaitez omettre de rechercher dans les répertoires .git, en évitant les problèmes d'index git comme d'autres l'ont poliment souligné.

Vous conduisant à:

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

Celui-ci est compatible avec les dépôts git, et un peu plus simple:

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'

(Merci à 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 listera tous les fichiers dans / home / www / (et ses sous-répertoires). L'indicateur "-exec" indique à find d'exécuter la commande suivante sur chaque fichier trouvé.

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

est la commande exécutée sur les fichiers (plusieurs à la fois). Le {}obtient remplacé par des noms de fichiers. Le +à la fin de la commande indique findde créer une commande pour de nombreux noms de fichiers.

Par le find page de manuel: "La ligne de commande est construite de la même manière que xargs construit ses lignes de commande."

Ainsi, il est possible d'atteindre votre objectif (et de gérer les noms de fichiers contenant des espaces) sans utiliser xargs -0, ou -print0.

J'en avais juste besoin et je n'étais pas satisfait de la vitesse des exemples disponibles. J'ai donc créé le mien:

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 est très efficace pour trouver des fichiers pertinents. Cette commande a remplacé ~ 145 000 fichiers par un jeu d'enfant alors que d'autres ont pris tellement de temps que je ne pouvais pas attendre qu'ils finissent.

Une méthode simple si vous devez exclure des répertoires ( --exclude-dir=.svn) et que vous pouvez également avoir des noms de fichier avec des espaces (en utilisant 0 octet avec grep -Zetxargs -0

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

Manière la plus simple de remplacer ( tous les fichiers, répertoire, récursif )

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

Remarque: Parfois, vous devrez peut-être ignorer certains fichiers cachés, c'est-à-dire que .gitvous pouvez utiliser la commande ci-dessus.

Si vous souhaitez inclure l'utilisation de fichiers cachés,

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

Dans les deux cas, la chaîne foosera remplacée par une nouvelle chaînebar

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

Je suppose que la plupart des gens ne savent pas qu'ils peuvent diriger quelque chose dans un "fichier en lecture" et cela évite ces désagréables arguments -print0, tout en prévoyant des espaces dans les noms de fichiers.

En ajoutant un echoavant le sed, vous pouvez voir quels fichiers vont changer avant de le faire.

Vous pouvez utiliser awk pour résoudre ce problème comme ci-dessous,

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

J'espère que cela vous aidera !!!

Essaye ça:

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

Selon cet article de blog:

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

Si cela ne vous dérange pas d'utiliser vimavec grepou des findoutils, vous pouvez suivre la réponse donnée par l'utilisateur Gert dans ce lien -> Comment faire un remplacement de texte dans une grande hiérarchie de dossiers? .

Voici l'affaire:

• grep récursivement pour la chaîne que vous souhaitez remplacer dans un certain chemin, et prenez uniquement le chemin complet du fichier correspondant. (ce serait le $(grep 'string' 'pathname' -Rl).

• (facultatif) si vous souhaitez effectuer une pré-sauvegarde de ces fichiers sur un répertoire centralisé, vous pouvez peut-être également utiliser ceci: cp -iv $(grep 'string' 'pathname' -Rl) 'centralized-directory-pathname'

• après cela, vous pouvez modifier / remplacer à volonté en vimsuivant un schéma similaire à celui fourni sur le lien donné:

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

Un peu vieille école mais cela fonctionnait sous OS X.

Il y a peu de ruses:

• Ne modifiera que les fichiers avec extension .sls dans le répertoire courant

• .doit être échappé pour assurersed ne pas les évaluer comme "n'importe quel caractère"

• ,est utilisé comme seddélimiteur au lieu de l'habituel/

Notez également qu'il s'agit de modifier un modèle Jinja pour passer un variabledans le chemin d'un import(mais cela est hors sujet).

Tout d'abord, vérifiez que votre commande sed fait ce que vous voulez (cela n'imprimera que les modifications sur stdout, cela ne changera pas les fichiers):

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

Modifiez la commande sed au besoin, une fois que vous êtes prêt à apporter des modifications:

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

Remarquez que -i ''dans la commande sed , je ne voulais pas créer une sauvegarde des fichiers originaux (comme expliqué dans les modifications sur place avec sed sur OS X ou dans le commentaire de Robert Lujo sur cette page).

Heureux les semeurs!

juste pour éviter de changer aussi

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

mais reste

• subdomainA.example.com.IsIt.good

(peut-être pas bon dans l'idée derrière la racine du domaine)

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

J'utilise juste des hauts:

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

Voici une version qui devrait être plus générale que la plupart; il ne nécessite pas find(en utilisant à la duplace), par exemple. Cela nécessite xargs, qui ne se trouvent que dans certaines versions de Plan 9 (comme 9front).

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

Si vous souhaitez ajouter des filtres comme les extensions de fichier, utilisez grep:

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

Pour Qshell (qsh) sur IBMi, pas bash comme balisé par OP.

Limitations des commandes qsh:

• find n'a pas l'option -print0
• xargs n'a pas l'option -0
• sed n'a pas l'option -i

Ainsi la solution dans 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

Mises en garde:

• La solution exclut la gestion des erreurs
• Not Bash comme taggé par OP

Si vous vouliez l'utiliser sans détruire complètement votre référentiel SVN, vous pouvez dire à 'find' d'ignorer tous les fichiers cachés en faisant:

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

Utilisation de la combinaison de grepetsed

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

Pour remplacer toutes les occurrences dans un référentiel git, vous pouvez utiliser:

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

Voir Liste des fichiers dans le dépôt git local? pour d'autres options pour répertorier tous les fichiers dans un référentiel. Les -zoptions indiquent à git de séparer les noms de fichiers par un octet zéro, ce qui garantit que xargs(avec l'option -0) peut séparer les noms de fichiers, même s'ils contiennent des espaces ou autres.

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

pour modifier plusieurs fichiers (et enregistrer une sauvegarde sous *.bak):

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

prendra tous les fichiers dans le répertoire et les remplacera |par x appelé «tarte Perl» (facile comme tarte)