Faire en sorte que xargs exécute la commande une fois pour chaque ligne d'entrée

Question

Comment puis-je faire en sorte que xargs exécute la commande exactement une fois pour chaque ligne d'entrée donnée ? Le comportement par défaut de xargs est de découper les lignes et d'exécuter la commande une fois, en passant plusieurs lignes à chaque instance.

Desde http://en.wikipedia.org/wiki/Xargs :

find /path -type f -print0 | xargs -0 rm

Dans cet exemple, find alimente l'entrée de xargs avec une longue liste de noms de fichiers. xargs divise ensuite cette liste en sous-listes et appelle rm une fois pour chaque sous-liste. Ceci est plus efficace que cette version fonctionnellement équivalente :

find /path -type f -exec rm '{}' \ ;

Je sais que find a le drapeau "exec". Je ne fais que citer un exemple illustratif tiré d'une autre ressource.

Answer 1

Ce qui suit ne fonctionnera que si vous n'avez pas d'espaces dans votre saisie :

xargs -L 1
xargs --max-lines=1 # synonym for the -L option

de la page de manuel :

-L max-lines
          Use at most max-lines nonblank input lines per command line.
          Trailing blanks cause an input line to be logically continued  on
          the next input line.  Implies -x.

Answer 2

Il me semble que toutes les réponses existantes sur cette page sont fausses, y compris celle qui est marquée comme correcte. Cela vient du fait que la question est formulée de manière ambiguë.

Résumé :   Si vous voulez exécuter la commande "exactement une fois pour chaque ligne d'entrée," en passant la ligne entière (sans nouvelle ligne) à la commande comme un un seul argument, alors c'est la meilleure façon de le faire, compatible avec UNIX :

... | tr '\n' '\0' | xargs -0 -n1 ...

Si vous utilisez GNU xargs et n'ont pas besoin d'être compatibles avec tous les autres UNIX (FreeBSD, Mac OS X, etc.), vous pouvez alors utiliser l'option spécifique à GNU -d :

... | xargs -d\\n -n1 ...

Maintenant pour la longue explication

---

Il y a deux problèmes à prendre en compte lors de l'utilisation de xargs :

1. comment il divise l'entrée en "arguments" ; et
2. le nombre d'arguments à passer à la commande enfant à la fois.

Pour tester le comportement de xargs, nous avons besoin d'un utilitaire qui montre combien de fois il est exécuté et avec combien d'arguments. Je ne sais pas s'il existe un utilitaire standard pour faire cela, mais nous pouvons le coder assez facilement en bash :

#!/bin/bash
echo -n "-> "; for a in "$@"; do echo -n "\"$a\" "; done; echo

En supposant que vous l'ayez enregistré sous show dans votre répertoire courant et le rendre exécutable, voici comment cela fonctionne :

$ ./show one two 'three and four'
-> "one" "two" "three and four" 

Maintenant, si la question initiale porte réellement sur le point 2. ci-dessus (comme je le pense, après l'avoir relu plusieurs fois) et qu'elle doit être lue comme suit (les changements sont en gras) :

Comment puis-je faire en sorte que xargs exécute la commande exactement une fois pour chaque argument de l'apport donné ? Son comportement par défaut est de fragmenter le entrée dans les arguments et exécutez la commande le moins de fois possible en passant par plusieurs arguments à chaque instance.

alors la réponse est -n 1 .

Comparons le comportement par défaut de xargs, qui divise l'entrée autour des espaces blancs et appelle la commande aussi peu de fois que possible :

$ echo one two 'three and four' | xargs ./show 
-> "one" "two" "three" "and" "four" 

et son comportement avec -n 1 :

$ echo one two 'three and four' | xargs -n 1 ./show 
-> "one" 
-> "two" 
-> "three" 
-> "and" 
-> "four" 

Si, d'autre part, la question initiale portait sur le point 1. le fractionnement de l'entrée et qu'elle devait être lue comme ceci (beaucoup de personnes venant ici semblent penser que c'est le cas, ou confondent les deux problèmes) :

Comment puis-je faire en sorte que xargs exécute la commande avec exactement un argument pour chaque ligne d'entrée donnée ? Son comportement par défaut est de fragmenter les lignes autour des espaces blancs .

alors la réponse est plus subtile.

On pourrait penser que -L 1 pourrait être utile, mais il s'avère qu'elle ne change pas l'analyse des arguments. Elle n'exécute la commande qu'une fois pour chaque ligne d'entrée, avec autant d'arguments qu'il y en avait sur cette ligne d'entrée :

$ echo $'one\ntwo\nthree and four' | xargs -L 1 ./show 
-> "one" 
-> "two" 
-> "three" "and" "four" 

De plus, si une ligne se termine par un espace, elle est ajoutée à la suivante :

$ echo $'one \ntwo\nthree and four' | xargs -L 1 ./show 
-> "one" "two" 
-> "three" "and" "four" 

Clairement, -L ne consiste pas à changer la façon dont xargs divise l'entrée en arguments.

Le seul argument qui le fait de manière multiplateforme (à l'exception des extensions GNU) est le suivant -0 qui divise l'entrée autour des octets NUL.

Ensuite, il suffit de traduire les nouvelles lignes en NUL à l'aide de la fonction tr :

$ echo $'one \ntwo\nthree and four' | tr '\n' '\0' | xargs -0 ./show 
-> "one " "two" "three and four" 

Maintenant, l'analyse des arguments semble correcte, y compris l'espacement de fin de ligne.

Enfin, si vous combinez cette technique avec -n 1 vous obtenez exactement une exécution de commande par ligne d'entrée, quelle que soit l'entrée que vous avez, ce qui peut être encore une autre façon de voir la question originale (peut-être la plus intuitive, étant donné le titre) :

$ echo $'one \ntwo\nthree and four' | tr '\n' '\0' | xargs -0 -n1 ./show 
-> "one " 
-> "two" 
-> "three and four" 

Comme mentionné ci-dessus, si vous utilisez GNU xargs vous pouvez remplacer le tr avec l'option spécifique à GNU -d :

$ echo $'one \ntwo\nthree and four' | xargs -d\\n -n1 ./show 
-> "one " 
-> "two" 
-> "three and four"

Answer 3

Si vous voulez exécuter la commande pour chaque ligne (c'est-à-dire le résultat) provenant de find alors de quoi avez-vous besoin ? xargs pour ?

Essayez :

find chemin -type f -exec votre-commande {} \;

où le littéral {} est remplacé par le nom de fichier et le littéral \; est nécessaire pour find pour savoir que la commande personnalisée s'arrête là.

EDIT :

(après l'édition de votre question clarifiant que vous êtes au courant de -exec )

Desde man xargs :

-L lignes max.
Utilisez au maximum lignes max. lignes d'entrée non vierges par ligne de commande. Les blancs qui suivent blancs de queue font qu'une ligne d'entrée est logiquement poursuivie sur la ligne d'entrée suivante. Implique -x.

Notez que les noms de fichiers se terminant par des blancs vous causeront des problèmes si vous utilisez xargs :

$ mkdir /tmp/bax; cd /tmp/bax
$ touch a\  b c\  c
$ find . -type f -print | xargs -L1 wc -l
0 ./c
0 ./c
0 total
0 ./b
wc: ./a: No such file or directory

Donc si vous ne vous souciez pas de la -exec il est préférable d'utiliser l'option -print0 y -0 :

$ find . -type f -print0 | xargs -0L1 wc -l
0 ./c
0 ./c
0 ./b
0 ./a

Answer 4

Comment puis-je faire en sorte que xargs exécute la commande exactement une fois pour chaque ligne d'entrée donnée ?

-L 1 est la solution la plus simple, mais elle ne fonctionne pas si l'un des fichiers contient des espaces. Il s'agit d'une fonction clé de find -print0 argument - pour séparer les arguments par ' \0 au lieu d'un espace. Voici un exemple :

echo "file with space.txt" | xargs -L 1 ls
ls: file: No such file or directory
ls: with: No such file or directory
ls: space.txt: No such file or directory

Une meilleure solution consiste à utiliser tr pour convertir les nouvelles lignes en nullité ( \0 ), puis utilisez les caractères xargs -0 argument. Voici un exemple :

echo "file with space.txt" | tr '\n' '\0' | xargs -0 ls
file with space.txt

Si vous devez ensuite limiter le nombre d'appels, vous pouvez utiliser la fonction -n 1 pour faire un appel au programme pour chaque entrée :

echo "file with space.txt" | tr '\n' '\0' | xargs -0 -n 1 ls

Cela vous permet également de filtrer la sortie de find avant en convertissant les ruptures en nulles.

find . -name \*.xml | grep -v /target/ | tr '\n' '\0' | xargs -0 tar -cf xml.tar

Answer 5

Ces deux méthodes fonctionnent également, et fonctionneront pour d'autres commandes qui n'utilisent pas find !

xargs -I '{}' rm '{}'
xargs -i rm '{}'

exemple de cas d'utilisation :

find . -name "*.pyc" | xargs -i rm '{}'

supprimera tous les fichiers pyc sous ce répertoire, même si les fichiers pyc contiennent des espaces.