Machen Sie xargs, um den Befehl für jede Eingabezeile einmal auszuführen

Wie kann ich xargs ausführen des Befehls genau einmal für jede Zeile der Eingabe gegeben?
Es ist Standard-Verhalten ist zum aufteilen der Zeilen und führen Sie den Befehl einmal ein, passieren mehrere Zeilen für jede Instanz.

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

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

In diesem Beispiel finden die feeds die Eingabe von xargs mit einer langen Liste von Dateinamen. xargs dann teilt diese Liste in Teillisten und ruft rm einmal für jede Teilliste. Dies ist effizienter, als das funktional äquivalent version:

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

Weiß ich, dass finden, hat die "exec" - flag. Ich bin nur unter Angabe eines anschaulichen Beispiels aus der anderen Quelle.

InformationsquelleAutor der Frage Readonly | 2008-10-13

xargs

319

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

aus der man-page:

-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.

InformationsquelleAutor der Antwort Draemon

118

Scheint es mir, alle vorhandenen Antworten auf dieser Seite sind falsch, einschließlich der als korrekt markiert. Das ergibt sich aus der Tatsache, dass die Frage zweideutig formuliert.

Zusammenfassung: Wenn Sie wollen, um den Befehl auszuführen "genau einmal für jede Zeile der Eingabe gegeben," vorbei, die gesamte Zeile (ohne den Zeilenumbruch), um den Befehl als einzige argument, dann ist dies die beste UNIX-kompatiblen Art und Weise, es zu tun:
```
... | tr '\n' '\0' | xargs -0 -n1 ...
```
GNU xargs kann oder kann nicht nützliche Erweiterungen, die es ermöglichen, Sie zu tun, Weg mit traber Sie sind nicht verfügbar unter OS X und anderen UNIX-Systemen.

Nun für die lange Erklärung...

Gibt es zwei Fragen zu berücksichtigen, bei der Verwendung von xargs:
1. wie funktioniert es teilen Sie die Eingabe in "Argumente"; und
2. wie viele Argumente übergeben werden, die Kind-Befehl zu einem Zeitpunkt.
Testen xargs' Verhalten, wir brauchen ein Dienstprogramm, das zeigt, wie oft es ausgeführt wird, und mit wie vielen Argumenten. Ich weiß nicht, ob es ist ein standard-Werkzeug zu tun, aber wir können den code ganz einfach in der bash:
```
#!/bin/bash
echo -n "-> "; for a in "$@"; do echo -n "\"$a\" "; done; echo
```
Vorausgesetzt, Sie speichern Sie es als show im aktuellen Verzeichnis und machen es ausführbar, hier ist, wie es funktioniert:
```
$ ./show one two 'three and four'
-> "one" "two" "three and four" 
```
Nun, wenn die ursprüngliche Frage ist wirklich über Punkt 2. oben (wie ich denke, es ist, nach dem Lesen ein paar mal über) und es ist zu Lesen wie folgt (änderungen in Fettdruck):

Wie kann ich xargs ausführen des Befehls genau einmal für jedes argument input gegeben? Seine Standard-Verhalten ist zum aufteilen der Eingabe in Argumente und führen Sie den Befehl so wenige Male wie möglichvorbei an mehreren Argumente jeder Instanz.

dann ist die Antwort -n 1.

Vergleichen wir xargs' default-Verhalten, das teilt sich den Eingang um Leerzeichen und ruft den Befehl als wenige Male wie möglich:
```
$ echo one two 'three and four' | xargs ./show 
-> "one" "two" "three" "and" "four" 
```
und sein Verhalten mit -n 1:
```
$ echo one two 'three and four' | xargs -n 1 ./show 
-> "one" 
-> "two" 
-> "three" 
-> "and" 
-> "four" 
```
Wenn auf der anderen Seite, die ursprüngliche Frage war über Punkt 1. Eingabe aufspalten und es zu Lesen war wie dieser (viele Menschen hier scheinen zu denken, dass dies der Fall ist, oder verwirrend sind die zwei Probleme):

Wie kann ich xargs Befehl ausführen mit genau ein argument für jede Zeile der Eingabe gegeben? Seine Standard-Verhalten ist zum aufteilen der Zeilen um whitespace.

dann die Antwort ist mehr subtil.

Man würde denken, dass -L 1 behilflich sein könnte, aber es stellt sich heraus, es ändert sich nicht-argument-parsing. Es führt nur den Befehl einmal für jede Zeile eingeben, mit wie vielen Argumente, als die dort waren, auf, die Eingabe-Zeile:
```
$ echo $'one\ntwo\nthree and four' | xargs -L 1 ./show 
-> "one" 
-> "two" 
-> "three" "and" "four" 
```
Nicht nur das, aber wenn eine Zeile endet mit Leerzeichen, es wird an die nächste:
```
$ echo $'one \ntwo\nthree and four' | xargs -L 1 ./show 
-> "one" "two" 
-> "three" "and" "four" 
```
Klar, -L ist nicht über das ändern der Weise xargs teilt die Eingabe in Argumente.

Das einzige argument, das so nicht in ein cross-Plattform-Mode (ohne GNU-Erweiterungen) ist -0teilt den Eingang herum NUL-bytes.

Dann, es ist nur eine Frage der übersetzung Zeilenumbrüche zu NUL mit Hilfe von tr:
```
$ echo $'one \ntwo\nthree and four' | tr '\n' '\0' | xargs -0 ./show 
-> "one " "two" "three and four" 
```
Nun das argument parsing sieht alle Rechte, einschließlich der Leerzeichen.

Schließlich, wenn Sie kombinieren diese Technik mit -n 1 bekommen Sie genau einen Befehl-Ausführung pro Zeile eingeben, was die Eingabe, die Sie haben, die möglicherweise noch eine andere Sichtweise auf die ursprüngliche Frage (möglicherweise die meisten intuitiv, da der Titel):
```
$ echo $'one \ntwo\nthree and four' | tr '\n' '\0' | xargs -0 -n1 ./show 
-> "one " 
-> "two" 
-> "three and four" 
```
InformationsquelleAutor der Antwort Tobia
21

Wenn Sie möchten, führen Sie den Befehl für jeder Linie (d.h. Ergebnis) aus finddann was brauchen Sie, um die xargs?

Versuchen:

find Pfad -type f -exec Ihre-Befehl {} \;

wo die wörtliche {} wird ersetzt durch den Dateinamen und die wörtliche \; ist erforderlich für find zu wissen, dass der benutzerdefinierte Befehl endet dort.

EDIT:

(nach der Bearbeitung Ihrer Frage zu klären wissen Sie über -exec)

Vom man xargs:

-L max-Linien

Verwenden Sie bei den meisten max-Linien nichtleeren Eingabezeilen pro Kommandozeile. Trailing
Leerzeichen bewirken, dass eine input-Zeile werden logisch fortgesetzt auf der nächsten Zeile eingeben.
Impliziert -x.

Beachten Sie, dass Dateinamen mit der Endung-Rohlinge würde Ursache, die Sie beunruhigen, wenn Sie 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
```
Also, wenn Sie kümmern sich nicht um die -exec option, verwenden Sie besser -print0 und -0:
```
$ find . -type f -print0 | xargs -0L1 wc -l
0 ./c
0 ./c
0 ./b
0 ./a
```
InformationsquelleAutor der Antwort tzot
10

Ich weiß nicht, wie die -L beantworten, da es nicht mit Dateien mit Leerzeichen in Ihnen, das ist eine wichtige Funktion find -print0.
```
echo "file with space.txt" | xargs -L 1 ls
ls: file: No such file or directory
ls: space.txt: No such file or directory
ls: with: No such file or directory
```
Eine bessere Lösung ist die Verwendung tr zu konvertieren Zeilenumbrüche zu null (\0) Zeichen, und verwenden Sie dann die xargs -0 argument.
```
echo "file with space.txt" | tr '\n' '\0' | xargs -0 ls
file with space.txt
```
Weiteres problem bei der Verwendung von -L ist auch, dass es nicht ermöglichen, dass mehrere Argumente für jede xargs - Befehl aufrufen. Zum Beispiel, der derzeit akzeptierte Lösung nennen würde /bin/rm für jede der Zeilen, die eine Tonne von execs. Mithilfe der tr Befehl, dann wird der -n können verwendet werden, um die Anzahl der eingelesenen Zeilen aus der Eingabe für jeden Aufruf des Dienstprogramms.
```
find . -name \*.java | tr '\n' '\0' | xargs -0 wc
```
Dies erlaubt Ihnen auch zu filtern, die die Ausgabe von find vor Umwandlung der Brüche in null-Werte.
```
find . -name \*.xml | grep -v /workspace/| tr '\n' '\0' | xargs -0 tar -cf xml.tar
```
InformationsquelleAutor der Antwort Gray

Andere alternative...

find /path -type f | while read ln; do echo "processing $ln"; done

InformationsquelleAutor der Antwort Richard

4
```
find path -type f | xargs -L1 command 
```
ist alles, was Sie brauchen.

InformationsquelleAutor der Antwort
4

Diese beiden Möglichkeiten auch Arbeit, und die Arbeit wird für andere Befehle, die nicht mit suchen!
```
xargs -I '{}' rm '{}'
xargs -i rm '{}'
```
Anwendungsbeispiel:
```
find . -name "*.pyc" | xargs -i rm '{}
```
löscht alle pyc-Dateien unter diesem Verzeichnis, auch wenn die pyc-Dateien Leerzeichen enthalten.

InformationsquelleAutor der Antwort Alex Riedler
3

Den folgenden Befehl findet alle Dateien (-type f) im /path und dann kopieren Sie Sie mit cp den aktuellen Ordner. Beachten Sie die Verwendung, wenn -I % angeben, ein Platzhalter-Zeichen in der cp Befehlszeile so, dass Argumente, die platziert werden können, nachdem die Datei name.

find /path -type f -print0 | xargs -0 -I % cp % .

Getestet mit xargs (GNU findutils) 4.4.0

InformationsquelleAutor der Antwort

Begrenzen Sie die Anzahl der Zeilen oder Argumente (falls es gibt Leerzeichen zwischen jedem argument) mit der --max-lines oder --max-args flags.

  -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.

  --max-lines[=max-lines], -l[max-lines]
         Synonym  for  the -L option.  Unlike -L, the max-lines argument is optional.  If max-args is not specified, it defaults to one.  The -l option
         is deprecated since the POSIX standard specifies -L instead.

  --max-args=max-args, -n max-args
         Use at most max-args arguments per command line.  Fewer than max-args arguments will be used if the size (see  the  -s  option)  is  exceeded,
         unless the -x option is given, in which case xargs will exit.

InformationsquelleAutor der Antwort Readonly

0

Es scheint ich habe nicht genug Ruf, um einen Kommentar zu Tobia ' s Antwort obenso dass ich bin das hinzufügen dieser "Antwort" zu helfen, diejenigen von uns, die wollen, zu Experimentieren mit xargs auf die gleiche Weise auf Windows-Plattformen.

Hier ist eine windows-batch-Datei macht das gleiche wie Tobia ist schnell codiert "show" Skript:
```
@echo off
REM
REM  cool trick of using "set" to echo without new line
REM  (from:  http://www.psteiner.com/2012/05/windows-batch-echo-without-new-line.html)
REM
if "%~1" == "" (
    exit /b
)

<nul set /p=Args:  "%~1"
shift

:start
if not "%~1" == "" (
    <nul set /p=, "%~1"
    shift
    goto start
)
echo.
```
InformationsquelleAutor der Antwort CrashNeb
-1

In deinem Beispiel den Punkt der Rohrleitungen, die die Ausgabe von find, xargs ist, dass das standard-Verhalten von find-exec-option ausführen den Befehl einmal für jede Gefundene Datei. Wenn Sie finden, und Sie möchten die standard-Verhalten, dann ist die Antwort einfach - nicht verwenden, xargs, um mit zu beginnen.

InformationsquelleAutor der Antwort Sherm Pendley
-3

ausführen von ant-task sauber-alle auf jeden build.xml auf die aktuelle und sub-Ordner.
```
find . -name 'build.xml' -exec ant -f {} clean-all \;
```
InformationsquelleAutor der Antwort sergiofbsilva

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

EDIT: