Como posso usar xargs para copiar arquivos com espaços e aspas em seus nomes?

Estou tentando copiar um monte de arquivos abaixo de um diretório e vários arquivos têm espaços e aspas simples em seus nomes. Quando tento encadear finde grepcom xargs, recebo o seguinte erro:

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

Alguma sugestão para um uso mais robusto do xargs?

Isso ocorre no Mac OS X 10.5.3 (Leopard) com BSD xargs.

Você pode combinar tudo isso em um único findcomando:

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

Isso manipulará nomes de arquivos e diretórios com espaços neles. Você pode usar -namepara obter resultados que diferenciam maiúsculas de minúsculas.

Nota: O --sinalizador transmitido para cpimpede o processamento de arquivos começando com -como opções.

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

Não sei se grepsuporta --null, nem se xargssuporta -0, no Leopard, mas no GNU é tudo de bom.

A maneira mais fácil de fazer o que o pôster original deseja é alterar o delimitador de qualquer espaço em branco para apenas o caractere de fim de linha como este:

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

Isso é mais eficiente, pois não executa o "cp" várias vezes:

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

Eu tive o mesmo problema. Aqui está como eu resolvi:

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

Eu costumava sedsubstituir cada linha de entrada pela mesma linha, mas cercada por aspas duplas. Na sedpágina de manual, " ... Um e comercial (` `& '') que aparece na substituição é substituído pela string correspondente ao RE ... " - nesse caso .*, a linha inteira.

Isso resolve o xargs: unterminated quoteerro.

Este método funciona no Mac OS X 10.7.5 (Lion):

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

Também testei a sintaxe exata que você postou. Isso também funcionou bem em 10.7.5.

Só não use xargs. É um programa interessante, mas não combina bem com findcasos não triviais.

Aqui está uma solução portátil (POSIX), ou seja, que não requer find, xargsou cpextensões específicas do GNU:

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

Observe o final em +vez do mais usual ;.

Esta solução:

• lida corretamente com arquivos e diretórios com espaços incorporados, novas linhas ou quaisquer caracteres exóticos.

• funciona em qualquer sistema Unix e Linux, mesmo aqueles que não fornecem o kit de ferramentas GNU.

• não usa o xargsque é um programa agradável e útil, mas requer muitos recursos de ajuste e fora do padrão para lidar adequadamente com a findsaída.

• também é mais eficiente (leia mais rápido ) que o aceito e a maioria, senão todas as outras respostas.

Observe também que, apesar do que é indicado em outras respostas ou comentários, a citação {}é inútil (a menos que você esteja usando o fishshell exótico ).

Procure usar a opção --null commandline para xargs com a opção -print0 em find.

Para quem confia em comandos, além de encontrar, por exemplo ls:

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

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

Acredito que isso funcione de maneira confiável para qualquer personagem, exceto o feed de linha (e eu suspeito que, se você tiver feeds de linha em seus nomes de arquivo, você tem problemas piores do que isso). Não requer o GNU findutils, apenas o Perl, por isso deve funcionar praticamente em qualquer lugar.

Eu descobri que a seguinte sintaxe funciona bem para mim.

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

Neste exemplo, estou procurando os maiores 200 arquivos com mais de 1.000.000 de bytes no sistema de arquivos montado em "/ usr / pcapps".

O liner de linha Perl entre "find" e "xargs" escapa / cita cada espaço em branco para que "xargs" passe qualquer nome de arquivo com espaços em branco incorporados para "ls" como um único argumento.

Desafio de quadros - você está perguntando como usar o xargs. A resposta é: você não usa xargs, porque não precisa.

O comentáriouser80168 descreve uma maneira de fazer isso diretamente com o cp, sem chamar o cp para cada arquivo:

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

Isso funciona porque:

• o cp -tsinalizador permite fornecer o diretório de destino próximo ao início de cp, e não perto do final. De man cp:

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

• O --sinalizador indica cppara interpretar tudo depois como um nome de arquivo, não um sinalizador; portanto, os arquivos que começam com -ou --não confundem cp; você ainda precisa disso porque os caracteres -/ --são interpretados por cp, enquanto outros caracteres especiais são interpretados pelo shell.

• A find -exec command {} +variante essencialmente faz o mesmo 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.

Ao usar isso em localizar diretamente, isso evita a necessidade de um pipe ou uma invocação de shell, para que você não precise se preocupar com caracteres desagradáveis ​​nos nomes de arquivos.

Esteja ciente de que a maioria das opções discutidas em outras respostas não é padrão em plataformas que não usam os utilitários GNU (Solaris, AIX, HP-UX, por exemplo). Consulte a especificação POSIX para obter o comportamento xargs 'padrão'.

Também acho o comportamento de xargs pelo qual ele executa o comando pelo menos uma vez, mesmo sem entrada, ser um incômodo.

Eu escrevi minha própria versão privada do xargs (xargl) para lidar com os problemas de espaços nos nomes (apenas as novas linhas se separam - embora a combinação 'find ... -print0' e 'xargs -0' seja bastante interessante, pois os nomes dos arquivos não podem contém caracteres ASCII NUL '\ 0'. Meu xargl não é tão completo quanto deveria valer a pena ser publicado - especialmente porque o GNU tem instalações que são pelo menos tão boas.

Com o Bash (não POSIX), você pode usar a substituição de processo para obter a linha atual dentro de uma variável. Isso permite que você use aspas para escapar de caracteres especiais:

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

Para mim, eu estava tentando fazer algo um pouco diferente. Eu queria copiar meus arquivos .txt na minha pasta tmp. Os nomes de arquivo .txt contêm espaços e caracteres de apóstrofo. Isso funcionou no meu Mac.

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

Se as versões find e xarg em seu sistema não suportarem -print0e -0alternar (por exemplo, AIX find e xargs), você poderá usar este código de aparência terrível:

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

Aqui o sed cuidará de escapar dos espaços e das aspas para xargs.

Testado no AIX 5.3

Criei um pequeno script de invólucro portátil chamado "xargsL" em torno de "xargs", que soluciona a maioria dos problemas.

Ao contrário de xargs, xargsL aceita um nome de caminho por linha. Os nomes de caminho podem conter qualquer caractere, exceto (obviamente) nova linha ou bytes NUL.

Nenhuma citação é permitida ou suportada na lista de arquivos - seus nomes de arquivos podem conter todos os tipos de espaços em branco, barras invertidas, barras de reticulação, caracteres curinga do shell e similares - o xargsL os processará como caracteres literais, sem causar danos.

Como um recurso adicional de bônus, o xargsL não executará o comando uma vez se não houver entrada!

Observe a diferença:

$ true | xargs echo no data
no data

$ true | xargsL echo no data # No output

Quaisquer argumentos fornecidos ao xargsL serão passados ​​para o xargs.

Aqui está o 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

Coloque o script em algum diretório no seu $ PATH e não se esqueça de

$ chmod +x xargsL

o script lá para torná-lo executável.

A versão Perl do bill_starr não funcionará bem para novas linhas incorporadas (apenas lida com espaços). Para aqueles que, por exemplo, Solaris, onde você não possui as ferramentas GNU, uma versão mais completa pode ser (usando sed) ...

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

ajuste os argumentos find e grep ou outros comandos conforme necessário, mas o sed corrigirá suas novas linhas / espaços / guias.

Usei a resposta de Bill Star ligeiramente modificada no Solaris:

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

Isso colocará aspas em cada linha. Eu não usei a opção '-l', embora provavelmente ajude.

A lista de arquivos que eu estava indo embora poderia ter '-', mas não novas linhas. Eu não usei o arquivo de saída com outros comandos, pois quero revisar o que foi encontrado antes de começar a excluí-los massivamente via xargs.

Eu brinquei um pouco com isso, comecei a contemplar a modificação de xargs e percebi que, para o tipo de caso de uso que estamos falando aqui, uma simples reimplementação no Python é uma idéia melhor.

Por um lado, ter ~ 80 linhas de código para a coisa toda significa que é fácil descobrir o que está acontecendo, e se um comportamento diferente for necessário, você pode simplesmente invadir um novo script em menos tempo do que o necessário para obter uma resposta em algum lugar como Stack Overflow.

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

Com yargs como está escrito (e o Python 3 instalado), você pode digitar:

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

para copiar 203 arquivos de cada vez. (Aqui, 203 é apenas um espaço reservado, é claro, e usar um número estranho como 203 deixa claro que esse número não tem outro significado.)

Se você realmente deseja algo mais rápido e sem a necessidade de Python, tome zargs e yargs como protótipos e reescreva em C ++ ou C.

Você pode precisar grep o diretório Foobar como:

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

Se você estiver usando o Bash, poderá converter stdout em uma matriz de linhas mapfile:

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

Os benefícios são:

• É embutido, então é mais rápido.
• Execute o comando com todos os nomes de arquivo de uma só vez, para que seja mais rápido.

• Você pode acrescentar outros argumentos aos nomes dos arquivos. Para cp, você também pode:

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

  no entanto, alguns comandos não possuem esse recurso.

As desvantagens:

• Talvez não seja dimensionado bem se houver muitos nomes de arquivos. (O limite? Eu não sei, mas eu testei com um arquivo de lista de 10 MB, que inclui mais de 10000 nomes de arquivos sem problemas, no Debian)

Bem ... quem sabe se o Bash está disponível no OS X?