¿Cómo puedo usar xargs para copiar archivos que tienen espacios y comillas en sus nombres?

Estoy tratando de copiar un montón de archivos debajo de un directorio y varios archivos tienen espacios y comillas simples en sus nombres. Cuando trato de encadenar findy grepcon xargs, me sale el siguiente error:

find .|grep "FooBar"|xargs -I{} cp "{}" ~/foo/bar
xargs: unterminated quote

¿Alguna sugerencia para un uso más robusto de xargs?

Esto está en Mac OS X 10.5.3 (Leopard) con BSD xargs.

Puedes combinar todo eso en un solo findcomando:

find . -iname "*foobar*" -exec cp -- "{}" ~/foo/bar \;

Esto manejará nombres de archivos y directorios con espacios en ellos. Puede usar -namepara obtener resultados sensibles a mayúsculas y minúsculas.

Nota: La --bandera pasada a cpevita que procese archivos que comienzan -como opciones.

find . -print0 | grep --null 'FooBar' | xargs -0 ...

No sé si los grepapoyos --null, ni si los xargsapoyos -0, en Leopard, pero en GNU, todo está bien.

La forma más fácil de hacer lo que quiere el póster original es cambiar el delimitador de cualquier espacio en blanco al carácter de final de línea como este:

find whatever ... | xargs -d "\n" cp -t /var/tmp

Esto es más eficiente ya que no ejecuta "cp" varias veces:

find -name '*FooBar*' -print0 | xargs -0 cp -t ~/foo/bar

Tuve el mismo problema. Así es como lo resolví:

find . -name '*FoooBar*' | sed 's/.*/"&"/' | xargs cp ~/foo/bar

Solía sedsustituir cada línea de entrada con la misma línea, pero rodeado de comillas dobles. Desde la sedpágina del manual, " ... Un ampersand (` `& '') que aparece en el reemplazo se reemplaza por la cadena que coincide con el RE ... " - en este caso .*, la línea completa.

Esto resuelve el xargs: unterminated quoteerror.

Este método funciona en Mac OS X v10.7.5 (Lion):

find . | grep FooBar | xargs -I{} cp {} ~/foo/bar

También probé la sintaxis exacta que publicaste. Eso también funcionó bien en 10.7.5.

Simplemente no lo uses xargs. Es un programa ordenado, pero no funciona bien findcuando se trata de casos no triviales.

Aquí hay una solución portátil (POSIX), es decir, una que no requiere find, xargso cpextensiones específicas de GNU:

find . -name "*FooBar*" -exec sh -c 'cp -- "$@" ~/foo/bar' sh {} +

Tenga en cuenta el final en +lugar de lo más habitual ;.

Esta solución:

• maneja correctamente archivos y directorios con espacios incrustados, nuevas líneas o cualquier personaje exótico.

• funciona en cualquier sistema Unix y Linux, incluso aquellos que no proporcionan el kit de herramientas GNU.

• no utiliza xargscuál es un programa agradable y útil, pero requiere demasiados ajustes y características no estándar para manejar correctamente la findsalida.

• También es más eficiente (leer más rápido ) que las respuestas aceptadas y la mayoría, si no todas, las demás.

Tenga en cuenta también que, a pesar de lo que se indica en algunas otras respuestas o comentarios, la cita {}es inútil (a menos que esté utilizando el fishshell exótico ).

Considere el uso de la opción de línea de comando --null para xargs con la opción -print0 en find.

Para aquellos que dependen de comandos, además de encontrar, por ejemplo ls:

find . | grep "FooBar" | tr \\n \\0 | xargs -0 -I{} cp "{}" ~/foo/bar

find | perl -lne 'print quotemeta' | xargs ls -d

Creo que esto funcionará de manera confiable para cualquier carácter, excepto el avance de línea (y sospecho que si tiene avances de línea en sus nombres de archivo, entonces tiene problemas peores que este). No requiere GNU findutils, solo Perl, por lo que debería funcionar prácticamente en cualquier lugar.

He descubierto que la siguiente sintaxis funciona bien para mí.

find /usr/pcapps/ -mount -type f -size +1000000c | perl -lpe ' s{ }{\\ }g ' | xargs ls -l | sort +4nr | head -200

En este ejemplo, estoy buscando los 200 archivos más grandes de más de 1,000,000 de bytes en el sistema de archivos montado en "/ usr / pcapps".

El delineador de línea Perl entre "find" y "xargs" escapa / cita cada espacio en blanco para que "xargs" pase cualquier nombre de archivo con espacios en blanco incrustados a "ls" como argumento único.

Reto de marco: estás preguntando cómo usar xargs La respuesta es: no usas xargs, porque no lo necesitas.

El comentario deuser80168 describe una forma de hacer esto directamente con cp, sin llamar a cp para cada archivo:

find . -name '*FooBar*' -exec cp -t /tmp -- {} +

Esto funciona porque:

• la cp -tbandera permite dar el directorio de destino cerca del principio cp, en lugar de cerca del final. De man cp:

   -t, --target-directory=DIRECTORY
         copy all SOURCE arguments into DIRECTORY

• La --bandera le dice cpque interprete todo después como un nombre de archivo, no como una bandera, por lo que los archivos que comienzan con -o --no confunden cp; aún necesita esto porque los caracteres -/ --son interpretados por cp, mientras que cualquier otro carácter especial es interpretado por el shell.

• La find -exec command {} +variante esencialmente hace lo mismo que xargs. De man find:

   -exec command {} +                                                     
         This  variant  of the -exec action runs the specified command on
         the selected files, but the command line is built  by  appending
         each  selected file name at the end; the total number of invoca‐
         matched  files.   The command line is built in much the same way
         that xargs builds its command lines.  Only one instance of  `{}'
         is  allowed  within the command, and (when find is being invoked
         from a shell) it should be quoted (for example, '{}') to protect
         it  from  interpretation  by shells.  The command is executed in
         the starting directory.  If any invocation  returns  a  non-zero
         value  as exit status, then find returns a non-zero exit status.
         If find encounters an error, this can sometimes cause an immedi‐
         ate  exit, so some pending commands may not be run at all.  This
         variant of -exec always returns true.

Al usar esto en find directamente, esto evita la necesidad de una tubería o una invocación de shell, por lo que no necesita preocuparse por los caracteres desagradables en los nombres de archivo.

Tenga en cuenta que la mayoría de las opciones discutidas en otras respuestas no son estándar en plataformas que no utilizan las utilidades GNU (Solaris, AIX, HP-UX, por ejemplo). Ver el POSIX especificación para el comportamiento xargs 'estándar'.

También encuentro que el comportamiento de xargs por el cual ejecuta el comando al menos una vez, incluso sin entrada, es una molestia.

Escribí mi propia versión privada de xargs (xargl) para tratar los problemas de espacios en los nombres (solo las nuevas líneas se separan, aunque la combinación 'find ... -print0' y 'xargs -0' es bastante clara dado que los nombres de archivos no pueden contienen caracteres ASCII NUL '\ 0'. Mi xargl no está tan completo como debería valer la pena publicar, especialmente porque GNU tiene instalaciones que son al menos tan buenas.

Con Bash (no POSIX) puede usar la sustitución de procesos para obtener la línea actual dentro de una variable. Esto le permite usar comillas para escapar de caracteres especiales:

while read line ; do cp "$line" ~/bar ; done < <(find . | grep foo)

Para mí, estaba tratando de hacer algo un poco diferente. Quería copiar mis archivos .txt en mi carpeta tmp. Los nombres de archivo .txt contienen espacios y caracteres de apóstrofe. Esto funcionó en mi Mac.

$ find . -type f -name '*.txt' | sed 's/'"'"'/\'"'"'/g' | sed 's/.*/"&"/'  | xargs -I{} cp -v {} ./tmp/

Si las versiones find y xarg en su sistema no son compatibles -print0y -0cambian (por ejemplo, AIX find y xargs), puede usar este código de aspecto terrible:

 find . -name "*foo*" | sed -e "s/'/\\\'/g" -e 's/"/\\"/g' -e 's/ /\\ /g' | xargs cp /your/dest

Aquí sed se encargará de escapar de los espacios y las comillas para xargs.

Probado en AIX 5.3

Creé un pequeño script de contenedor portátil llamado "xargsL" alrededor de "xargs" que aborda la mayoría de los problemas.

Al contrario de xargs, xargsL acepta un nombre de ruta por línea. Los nombres de ruta pueden contener cualquier carácter excepto (obviamente) nueva línea o bytes NUL.

No se permite ni admite el uso de comillas en la lista de archivos: sus nombres de archivo pueden contener todo tipo de espacios en blanco, barras diagonales inversas, comillas invertidas, caracteres comodín de shell y similares: xargsL los procesará como caracteres literales, sin causar daño.

Como una característica adicional, ¡xargsL no ejecutará el comando una vez si no hay entrada!

Tenga en cuenta la diferencia:

$ true | xargs echo no data
no data

$ true | xargsL echo no data # No output

Cualquier argumento dado a xargsL se pasará a xargs.

Aquí está el script de shell POSIX "xargsL":

#! /bin/sh
# Line-based version of "xargs" (one pathname per line which may contain any
# amount of whitespace except for newlines) with the added bonus feature that
# it will not execute the command if the input file is empty.
#
# Version 2018.76.3
#
# Copyright (c) 2018 Guenther Brunthaler. All rights reserved.
#
# This script is free software.
# Distribution is permitted under the terms of the GPLv3.

set -e
trap 'test $? = 0 || echo "$0 failed!" >& 2' 0

if IFS= read -r first
then
        {
                printf '%s\n' "$first"
                cat
        } | sed 's/./\\&/g' | xargs ${1+"$@"}
fi

Ponga el script en algún directorio en su $ PATH y no olvide

$ chmod +x xargsL

el script allí para hacerlo ejecutable.

La versión Perl de bill_starr no funcionará bien para líneas nuevas incrustadas (solo hace frente a espacios). Para aquellos en, por ejemplo, Solaris donde no tiene las herramientas GNU, una versión más completa podría ser (usando sed) ...

find -type f | sed 's/./\\&/g' | xargs grep string_to_find

ajuste los argumentos find y grep u otros comandos según lo requiera, pero sed arreglará sus nuevas líneas / espacios / pestañas incrustadas.

Solía respuesta de Bill estrella ligeramente modificada en Solaris:

find . -mtime +2 | perl -pe 's{^}{\"};s{$}{\"}' > ~/output.file

Esto pondrá comillas alrededor de cada línea. No utilicé la opción '-l' aunque probablemente ayudaría.

Sin embargo, la lista de archivos a la que iba podría tener '-', pero no nuevas líneas. No he usado el archivo de salida con ningún otro comando, ya que quiero revisar lo que se encontró antes de comenzar a eliminarlos masivamente a través de xargs.

Jugué un poco con esto, comencé a contemplar la modificación de xargs y me di cuenta de que para el tipo de caso de uso del que estamos hablando aquí, una simple reimplementación en Python es una mejor idea.

Por un lado, tener ~ 80 líneas de código para todo significa que es fácil darse cuenta de lo que está sucediendo, y si se requiere un comportamiento diferente, puede piratearlo en un nuevo script en menos tiempo del necesario para obtenerlo. una respuesta en algún lugar como Stack Overflow.

Ver https://github.com/johnallsup/jda-misc-scripts/blob/master/yargs y https://github.com/johnallsup/jda-misc-scripts/blob/master/zargs.py .

Con los hilos como están escritos (y Python 3 instalado) puede escribir:

find .|grep "FooBar"|yargs -l 203 cp --after ~/foo/bar

hacer la copia de 203 archivos a la vez. (Aquí 203 es solo un marcador de posición, por supuesto, y el uso de un número extraño como 203 deja en claro que este número no tiene otra importancia).

Si realmente quieres algo más rápido y sin la necesidad de Python, toma zargs e hilos como prototipos y reescribe en C ++ o C.

Puede que necesite grep directorio de Foobar como:

find . -name "file.ext"| grep "FooBar" | xargs -i cp -p "{}" .

Si está utilizando Bash, puede convertir stdout en una matriz de líneas de la siguiente manera mapfile:

find . | grep "FooBar" | (mapfile -t; cp "${MAPFILE[@]}" ~/foobar)

Los beneficios son:

• Está integrado, por lo que es más rápido.
• Ejecute el comando con todos los nombres de archivo al mismo tiempo, por lo que es más rápido.

• Puede agregar otros argumentos a los nombres de archivo. Para cp, usted también puede:

  find . -name '*FooBar*' -exec cp -t ~/foobar -- {} +
  

  sin embargo, algunos comandos no tienen esa característica.

Las desventajas:

• Tal vez no escale bien si hay demasiados nombres de archivo. (¿El límite? No lo sé, pero lo probé con un archivo de lista de 10 MB que incluye más de 10000 nombres de archivos sin problemas, en Debian)

Bueno ... ¿quién sabe si Bash está disponible en OS X?