¿Cómo hacer una búsqueda / reemplazo recursivo de una cadena con awk o sed?

¿Cómo encuentro y reemplazo cada aparición de:

subdomainA.example.com

con

subdomainB.example.com

en cada archivo de texto bajo el /home/www/árbol de directorios de forma recursiva?

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

-print0le dice findque imprima cada uno de los resultados separados por un carácter nulo, en lugar de una nueva línea. En el caso improbable de que su directorio tenga archivos con nuevas líneas en los nombres, esto todavía permite xargstrabajar con los nombres de archivo correctos.

\( -type d -name .git -prune \)es una expresión que omite completamente todos los directorios nombrados .git. Puede expandirlo fácilmente, si usa SVN o tiene otras carpetas que desea preservar, solo haga coincidir con más nombres. Es más o menos equivalente a -not -path .git, pero más eficiente, porque en lugar de verificar cada archivo en el directorio, lo omite por completo. El -oafter se requiere debido a cómo -prunefunciona realmente.

Para más información, ver man find.

Nota : No ejecute este comando en una carpeta que incluya un repositorio git; los cambios en .git podrían dañar su índice git.

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

En comparación con otras respuestas aquí, esto es más simple que la mayoría y usa sed en lugar de perl, que es lo que preguntó la pregunta original.

La forma más simple para mí es

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

Todos los trucos son casi iguales, pero me gusta este:

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

• find <mydir>: busca en el directorio.

• -type f:

  El archivo es de tipo: archivo normal

• -exec command {} +:

  Esta variante de la acción -exec ejecuta el comando especificado en los archivos seleccionados, pero la línea de comando se crea agregando cada nombre de archivo seleccionado al final; El número total de invocaciones del comando será mucho menor que el número de archivos coincidentes. La línea de comando se construye de la misma manera que xargs construye sus líneas de comando. Solo se permite una instancia de `{} 'dentro del comando. El comando se ejecuta en el directorio de inicio.

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

Para mí, la solución más fácil de recordar es https://stackoverflow.com/a/2113224/565525 , es decir:

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

NOTA : -i ''resuelve el problema de OSXsed: 1: "...": invalid command code .

NOTA : Si hay demasiados archivos para procesar, obtendrá Argument list too long. La solución alternativa: uso find -execo xargssolución descrita anteriormente.

Para cualquiera que use el buscador plateado ( ag)

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

Dado que ag ignora los archivos / carpetas git / hg / svn de forma predeterminada, es seguro ejecutarlo dentro de un repositorio.

Un buen oneliner como extra. Usando git grep.

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

Para reducir los archivos de forma recursiva sed, podría greppara su instancia de cadena:

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

Si ejecuta man grep, notará que también puede definir un--exlude-dir="*.git" indicador si desea omitir la búsqueda a través de directorios .git, evitando problemas de índice git como otros han señalado cortésmente.

Llevándote a:

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

Este es compatible con repositorios git, y un poco más 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'

(Gracias 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 enumerará todos los archivos en / home / www / (y sus subdirectorios). El indicador "-exec" le dice a find que ejecute el siguiente comando en cada archivo encontrado.

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

es el comando que se ejecuta en los archivos (muchos a la vez). El {}se reemplaza por nombres de archivo. Al +final del comando le indica findque cree un comando para muchos nombres de archivo.

Por el find página de manual: "La línea de comando se construye de la misma manera que xargs construye sus líneas de comando".

Por lo tanto, es posible lograr su objetivo (y manejar nombres de archivos que contienen espacios) sin usar xargs -0, o -print0.

Solo necesitaba esto y no estaba contento con la velocidad de los ejemplos disponibles. Entonces se me ocurrió el mío:

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 es muy eficiente para encontrar archivos relevantes. Este comando reemplazó ~ 145 000 archivos con una brisa, mientras que otros tardaron tanto que no podía esperar hasta que terminaran.

Un método sencillo si necesita excluir directorios ( --exclude-dir=.svn) y también puede tener nombres de archivo con espacios (usando 0Byte con grep -Zyxargs -0

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

La forma más simple de reemplazar ( todos los archivos, directorio, recursivo )

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

Nota: a veces es posible que deba ignorar algunos archivos ocultos, es decir .git, puede usar el comando anterior.

Si desea incluir el uso de archivos ocultos,

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

En ambos casos, la cadena foose reemplazará por una nueva.bar

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

Supongo que la mayoría de las personas no saben que pueden canalizar algo en un "archivo mientras se lee" y evita esos desagradables argumentos -print0, mientras preseleccionan espacios en los nombres de archivo.

Además, agregar un echoantes del sed le permite ver qué archivos cambiarán antes de hacerlo realmente.

Puede usar awk para resolver esto de la siguiente manera,

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

Espero que esto te ayudará !!!

Prueba esto:

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

Según esta publicación de blog:

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

Si no le importa usar vimjunto con grepo findherramientas, puede seguir la respuesta dada por el usuario Gert en este enlace -> ¿Cómo hacer un reemplazo de texto en una jerarquía de carpetas grandes?.

Aquí está el trato:

• grep recursivamente para la cadena que desea reemplazar en una ruta determinada, y tome solo la ruta completa del archivo coincidente. (ese sería el $(grep 'string' 'pathname' -Rl).

• (opcional) si desea hacer una copia de seguridad previa de esos archivos en el directorio centralizado, puede usar esto también: cp -iv $(grep 'string' 'pathname' -Rl) 'centralized-directory-pathname'

• después de eso, puede editar / reemplazar a voluntad vimsiguiendo un esquema similar al proporcionado en el enlace proporcionado:

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

Un poco vieja escuela, pero esto funcionó en OS X.

Hay algunos trucos:

• Solo editará archivos con extensión .sls bajo el directorio actual

• .debe escaparse para garantizarsed que no los evalúa como "cualquier personaje"

• ,se usa como seddelimitador en lugar del habitual/

También tenga en cuenta que esto es para editar una plantilla Jinja para pasar un variableen la ruta de un import(pero esto está fuera de tema).

Primero, verifique que su comando sed haga lo que desea (esto solo imprimirá los cambios en stdout, no cambiará los archivos):

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

Edite el comando sed según sea necesario, una vez que esté listo para realizar cambios:

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

Tenga -i ''en cuenta que en el comando sed , no quería crear una copia de seguridad de los archivos originales (como se explica en Ediciones in situ con sed en OS X o en el comentario de Robert Lujo en esta página).

¡Felices amigos!

solo para evitar cambiar también

• NearlysubdomainA.example.com
• subdominioA.example.comp.other

pero aún

• subdominioA.example.com.IsIt.good

(tal vez no sea bueno en la idea detrás del dominio raíz)

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

Solo uso tops:

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

Aquí hay una versión que debería ser más general que la mayoría; no requiere find(usando en su dulugar), por ejemplo. Requiere xargs, que solo se encuentran en algunas versiones del Plan 9 (como 9front).

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

Si desea agregar filtros como extensiones de archivo, use grep:

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

Para Qshell (qsh) en IBMi, no bash como lo etiqueta OP

Limitaciones de los comandos qsh:

• find no tiene la opción -print0
• xargs no tiene la opción -0
• sed no tiene la opción -i

Así, la solución en 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

Advertencias:

• La solución excluye el manejo de errores
• No Bash como etiquetado por OP

Si desea utilizar esto sin destruir por completo su repositorio SVN, puede decirle a 'buscar' que ignore todos los archivos ocultos haciendo lo siguiente:

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

Usando la combinación de grepysed

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

Para reemplazar todas las ocurrencias en un repositorio de git puede usar:

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

Ver Lista de archivos en el repositorio local de git? para otras opciones para enumerar todos los archivos en un repositorio. Las -zopciones le dicen a git que separe los nombres de los archivos con un byte cero, lo que asegura que xargs(con la opción -0) puede separar los nombres de los archivos, incluso si contienen espacios o no.

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

para cambiar varios archivos (y guardar una copia de seguridad como *.bak):

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

tomará todos los archivos en el directorio y los reemplazará |con x llamado "pastel de Perl" (fácil como un pastel)