Modifier plusieurs fichiers

La commande suivante modifie correctement le contenu de 2 fichiers.

sed -i 's/abc/xyz/g' xaa1 xab1 

Mais ce que je dois faire est de changer dynamiquement plusieurs de ces fichiers et je ne connais pas les noms de fichiers. Je veux écrire une commande qui lira tous les fichiers du répertoire courant en commençant par xa*et seddevrait changer le contenu du fichier.

Mieux encore:

for i in xa*; do
    sed -i 's/asd/dfg/g' $i
done

car personne ne sait combien de fichiers il y a, et il est facile de dépasser les limites de la ligne de commande.

Voici ce qui se passe lorsqu'il y a trop de fichiers:

# grep -c aaa *
-bash: /bin/grep: Argument list too long
# for i in *; do grep -c aaa $i; done
0
... (output skipped)
#

Je suis surpris que personne n'ait mentionné l'argument -exec to find, qui est destiné à ce type de cas d'utilisation, bien qu'il lancera un processus pour chaque nom de fichier correspondant:

find . -type f -name 'xa*' -exec sed -i 's/asd/dsg/g' {} \;

Alternativement, on pourrait utiliser xargs, qui invoquera moins de processus:

find . -type f -name 'xa*' | xargs sed -i 's/asd/dsg/g'

Ou plus simplement, utilisez la + variante exec au lieu de ;in find pour permettre à find de fournir plus d'un fichier par appel de sous-processus:

find . -type f -name 'xa*' -exec sed -i 's/asd/dsg/g' {} +

Vous pouvez utiliser grep et sed ensemble. Cela vous permet de rechercher des sous-répertoires de manière récursive.

Linux: grep -r -l <old> * | xargs sed -i 's/<old>/<new>/g'
OS X: grep -r -l <old> * | xargs sed -i '' 's/<old>/<new>/g'

For grep:
    -r recursively searches subdirectories 
    -l prints file names that contain matches
For sed:
    -i extension (Note: An argument needs to be provided on OS X)

Ces commandes ne fonctionneront pas par défaut sed avec Mac OS X.

De man 1 sed:

-i extension
             Edit files in-place, saving backups with the specified
             extension.  If a zero-length extension is given, no backup 
             will be saved.  It is not recommended to give a zero-length
             extension when in-place editing files, as you risk corruption
             or partial content in situations where disk space is exhausted, etc.

A essayé

sed -i '.bak' 's/old/new/g' logfile*

et

for i in logfile*; do sed -i '.bak' 's/old/new/g' $i; done

Les deux fonctionnent bien.

@PaulR a posté ceci comme un commentaire, mais les gens devraient le voir comme une réponse (et cette réponse convient le mieux à mes besoins):

sed -i 's/abc/xyz/g' xa*

Cela fonctionnera pour une quantité modérée de fichiers, probablement de l'ordre de dizaines, mais probablement pas de l'ordre de millions .

Une autre façon plus polyvalente consiste à utiliser find:

sed -i 's/asd/dsg/g' $(find . -type f -name 'xa*')

J'utilise findpour une tâche similaire. C'est assez simple: vous devez le passer comme argument pour sedcomme ceci:

sed -i 's/EXPRESSION/REPLACEMENT/g' `find -name "FILE.REGEX"`

De cette façon, vous n'avez pas besoin d'écrire des boucles complexes, et il est simple de voir quels fichiers vous allez modifier, exécutez simplement findavant d'exécuter sed.

tu peux faire

' xxxx ' text u recherche et le remplacera par ' yyyy '

grep -Rn '**xxxx**' /path | awk -F: '{print $1}' | xargs sed -i 's/**xxxx**/**yyyy**/'

Si vous êtes capable d'exécuter un script, voici ce que j'ai fait pour une situation similaire:

En utilisant un dictionnaire / hashMap (tableau associatif) et des variables pour la sedcommande, nous pouvons parcourir le tableau pour remplacer plusieurs chaînes. L'inclusion d'un caractère générique dans le name_patternpermettra de remplacer sur place dans les fichiers par un modèle (cela pourrait être quelque chose comme name_pattern='File*.txt') dans un répertoire spécifique ( source_dir). Tous les changements sont écrits dans le logfiledans ledestin_dir

#!/bin/bash
source_dir=source_path
destin_dir=destin_path
logfile='sedOutput.txt'
name_pattern='File.txt'

echo "--Begin $(date)--" | tee -a $destin_dir/$logfile
echo "Source_DIR=$source_dir destin_DIR=$destin_dir "

declare -A pairs=( 
    ['WHAT1']='FOR1'
    ['OTHER_string_to replace']='string replaced'
)

for i in "${!pairs[@]}"; do
    j=${pairs[$i]}
    echo "[$i]=$j"
    replace_what=$i
    replace_for=$j
    echo " "
    echo "Replace: $replace_what for: $replace_for"
    find $source_dir -name $name_pattern | xargs sed -i "s/$replace_what/$replace_for/g" 
    find $source_dir -name $name_pattern | xargs -I{} grep -n "$replace_for" {} /dev/null | tee -a $destin_dir/$logfile
done

echo " "
echo "----End $(date)---" | tee -a $destin_dir/$logfile

Tout d'abord, le tableau de paires est déclaré, chaque paire est une chaîne de remplacement, puis WHAT1sera remplacée FOR1et OTHER_string_to replacesera remplacée string replaceddans le fichier File.txt. Dans la boucle le tableau est lu, le premier membre de la paire est récupéré en tant que replace_what=$iet le second en tant que replace_for=$j. La findcommande recherche dans le répertoire le nom de fichier (qui peut contenir un caractère générique) et la sed -icommande remplace dans le (s) même (s) fichier (s) ce qui a été précédemment défini. Enfin, j'ai ajouté un grepfichier redirigé vers le fichier journal pour enregistrer les modifications apportées au (x) fichier (s).

Cela a fonctionné pour moi GNU Bash 4.3 sed 4.2.2et basé sur la réponse de VasyaNovikov pour Loop over tuples in bash .