{"id":7620,"date":"2021-07-20T13:08:22","date_gmt":"2021-07-20T13:08:22","guid":{"rendered":"https:\/\/profi-tutorials.de\/linux\/?p=7620"},"modified":"2021-07-20T13:08:23","modified_gmt":"2021-07-20T13:08:23","slug":"befehl-xargs","status":"publish","type":"post","link":"https:\/\/profi-tutorials.de\/linux\/administration\/befehl-xargs\/","title":{"rendered":"Der Befehl xargs"},"content":{"rendered":"

In diesem Beitrag lernen Sie den Befehl xargs kennen, welcher verwendet wird, um Befehle mit Argumenten auszuführen, welche vom Standard-Input gelesen werden. Viele Befehle lassen sich unter Linux- \/ UNIX standardmäßig sowohl auf einzelnen Dateien, als auch auf Listen von Dateien anwenden – ist dies nicht möglich, kann der Befehl xargs eingesetzt werden. Ein weiterer Anwendungsfall für xargs ist zudem die Parallelisierung mehrerer Befehle, zum Beispiel rsync, um eine bessere Ausnutzung der Ressourcen des Systems zu ermöglichen.<\/p>\n

Zu Beginn wird die allgemeine Syntax<\/a> des Befehls xargs gezeigt. Anschließend folgen die wichtigsten Optionen des Befehls mitsamt einiger Beispiele.<\/p>\n

Allgemeine Syntax<\/h2>\n

xargs <\/strong>wird neben verschiedenen verfügbaren Optionen ein Befehl übergeben, welcher dann mit den eingelesenen Argumenten ausgeführt wird. Der Befehl kann dabei ganz normal mitsamt beliebiger initialer Argumente angegeben werden – xargs <\/strong>wird die aus dem Standard-Input stdin <\/strong>eingelesenen Argumente dann standardmäßig jeweils am Ende des Befehls anfügen. Die allgemeine Syntax lautet somit folgendermaßen:<\/p>\n

xargs [Optionen] [Befehl [Initiale Argumente]]<\/pre>\n
Beispiel: xargs ohne Optionen<\/h5>\n
In diesem Beispiel wird der Befehl <\/span>xargs ohne jegliche Optionen eingesetzt, um die mit dem <\/span>find-Befehl gefundenen Dateien im aktuellen Arbeitsverzeichnis (und Unterverzeichnissen) alle an den Befehl <\/span>ls zu übergeben. Dieser sortiert die Dateien mithilfe der <\/span>Option -S nach ihrer Größe und gibt sie schließlich an den Befehl <\/span>head weiter, welcher nur die ersten 5 Zeilen ausgibt.<\/span><\/h6>\n
Eingabe:<\/h6>\n
find .\/ -type f | xargs ls -lhS | head -5<\/p>\n
Ausgabe:<\/h6>\n
Die größten fünf im Arbeitsverzeichnis sowie den entsprechenden Unterverzeichnissen vorhandenen Dateien werden ausgegeben.<\/p>\n
\"befehl-xargs-beispiel-1\"<\/span><\/p>\n
Wichtige Optionen<\/h2>\n
In diesem Abschnitt werden die wichtigsten Optionen des Befehls xargs <\/strong>vorgestellt. Einige Beispiele zeigen dabei auch die praktische Anwendung der jeweiligen Optionen.<\/p>\n
-a – Einlesen aus Datei<\/h3>\n
Anstelle des Standard-Input stdin <\/strong>kann auch eine Datei zum Einlesen von Argumenten verwendet werden. Hierzu wird die Option -a<\/strong> verwendet und die entsprechende Datei als Parameter angegeben:<\/p>\n
xargs -a [Datei] [Befehl [Initiale Argumente]]<\/pre>\n
Bei Verwendung dieser Option verbleibt der Standard-Input-Stream stdin <\/strong>unverändert, wenn Befehle ausgeführt werden. Andernfalls wird stdin <\/strong>von \/dev\/null<\/strong> umgeleitet.<\/p>\n
Beispiel: Einlesen aus Datei<\/h5>\n
Hier sollen die Argumente von <\/span>xargs aus einer Datei eingelesen werden. Jede Zeile der Eingabedatei stellt in diesem Fall eine Datei dar, welche auch hier wieder mit <\/span>ls ausgegeben werden soll.<\/span><\/h6>\n
Inhalt \/home\/hellberg\/linux-grundlagen.txt:<\/h6>\n
\/home\/hellberg\/profi-tutorials\/linux\/grundlagen\/befehl-sudo.txt<\/p>\n
\/home\/hellberg\/profi-tutorials\/linux\/netzwerke\/befehl-scp.txt<\/p>\n
\/home\/hellberg\/profi-tutorials\/linux\/administration\/befehl-top.txt<\/p>\n
Eingabe:<\/h6>\n
xargs -a \/home\/hellberg\/linux-grundlagen.txt ls -lh<\/p>\n
Nach Ausführung:<\/h6>\n
\"befehl-xargs-beispiel-2\"<\/span><\/p>\n
-0 – NULL-Zeichen als Delimiter<\/h3>\n
Die eingelesenen Argumente werden aufgrund des NULL-Zeichens<\/strong> anstelle von Leerzeichen getrennt. Außerdem werden jegliche Anführungszeichen sowie Rückschrägstrich-Maskierungen nicht als Sonderzeichen interpretiert – alle Zeichen werden damit wörtlich genommen. Die End-of-File-Zeichenkette (EOF) wird deaktiviert und wie jedes andere Argument interpretiert.<\/p>\n
xargs -0 [Befehl [Initiale Argumente]]<\/pre>\n
-d – Delimiter spezifizieren<\/h3>\n
Mit dieser Option kann ein Zeichen spezifiziert werden, welches anstelle des standardmäßigen Leerzeichens \/ Zeilenumbruchs als Delimiter<\/a> verwendet werden soll. Genau wie auch bei der Option -0<\/strong> werden alle Zeichen wörtlich genommen und die End-of-File-Zeichenkette deaktiviert.<\/p>\n
xargs -d [Zeichen] [Befehl [Initiale Argumente]]<\/pre>\n
Angegeben werden kann ein einzelnes Zeichen, ein Escape-Zeichen im C-Stil (etwa “n”<\/strong>) oder ein oktaler oder hexadezimaler Escape-Code. Multibyte-Zeichen werden nicht unterstützt.<\/p>\n
Beispiel: Delimiter spezifizieren<\/h5>\n
Dieses Beispiel zeigt, wie mit der <\/span>Option -d ein Delimiter zur Trennung einzelner Argumente spezifiziert wird. In diesem Fall wird der Delimiter <\/span>“;” gewählt, um eine durch Semikola getrennte Liste von Home-Verzeichnissen Zeile für Zeile mit <\/span>echo in die Ausgabe zu schreiben. Zusätzlich wird hier die <\/span>Option -n verwendet, um die Anzahl Argumente pro Kommandozeile bzw. <\/span>echo-Befehl auf eines zu beschränken.<\/span><\/h6>\n
Eingabe:<\/h6>\n
printf “\/home\/hellberg;\/home\/admina;\/home\/bibo” | xargs -n 1 -d “;” echo<\/p>\n
Ausgabe:<\/h6>\n
Die drei in den Standard-Input von xargs <\/strong>gegebenen Home-Verzeichnisse werden nun zeilenweise ausgegeben.<\/p>\n
\/home\/hellberg<\/p>\n
\/home\/admina<\/p>\n
\/home\/bibo<\/p>\n
-E – EOF-Marker spezifizieren<\/h3>\n
Der End-of-File-Marker (EOF) wird mit dieser Option auf die angegebene Zeichenkette<\/a> gesetzt. Tritt der spezifizierte EOF-Marker als Eingabezeile auf, so wird die verbleibende Eingabe ignoriert.<\/p>\n
xargs -E [Zeichenkette] [Befehl [Initiale Argumente]]<\/pre>\n
Wird keine Zeichenkette angegeben, so gibt es keinen logischen EOF-Marker – dies ist die Standardeinstellung seit GNU xargs <\/strong>der Version 4.2.9. Wird neben -E<\/strong> auch die Option -d<\/strong> oder -0<\/strong> verwendet, so wird die hier angegebene Zeichenkette nicht gesondert behandelt, sodass stets die gesamte Eingabe gelesen wird.<\/p>\n
Beispiel: EOF-Marker spezifizieren<\/h5>\n
Mithilfe der <\/span>Option -E wird hier die Zeichenkette <\/span>“ENDE” als EOF-Marker spezifiziert. Die Argumente für <\/span>xargs werden aus dem Standard-Input eingelesen und stammen aus der Ausgabe des Befehls <\/span>cat, welcher auf der Datei <\/span>“hellberg.txt” ausgeführt wird. Mit <\/span>echo werden die eingelesenen Argumente dann ausgegeben.<\/span><\/h6>\n
Inhalt hellberg.txt:<\/h6>\n
hellberg<\/p>\n
admina<\/p>\n
bibo<\/p>\n
ENDE<\/p>\n
hedv<\/p>\n
Eingabe:<\/h6>\n
cat hellberg.txt | xargs -E “ENDE” echo<\/p>\n
Nach Ausführung:<\/h6>\n
Es werden nun ausschließlich die ersten drei Zeilen der Eingabe hintereinander, auf einer Zeile ausgegeben. Das Wort<\/a> “hedv”<\/strong>, welches erst hinter dem EOF-Marker “ENDE”<\/strong> auftritt, wird von xargs <\/strong>ignoriert.<\/p>\n
hellberg admina bibo<\/p>\n
-I – Platzhalter ersetzen<\/h3>\n
Die Option -I<\/strong> wird verwendet, um eine Platzhalter-Zeichenkette festzulegen, welche in den initialen Argumenten des xargs’<\/strong> übergebenen Befehls durch die vom Standard-Input gelesenen Argumente ersetzt wird. Die Option impliziert zudem die Optionen -x<\/strong> und “-l 1”<\/strong>.<\/p>\n
xargs -I [Zeichenkette] [Befehl [Initiale Argumente]]<\/pre>\n
Leerzeichen, welche nicht in Anführungszeichen eingefasst sind, werden nicht zur Trennung der Argumente verwendet – stattdessen wird die Eingabe ausschließlich an Zeilenumbrüchen getrennt.<\/p>\n
Beispiel: Platzhalter ersetzen<\/h5>\n
Mit der Option -I<\/strong> wird in diesem Beispiel ein Platzhalter<\/a> zur Ersetzung in den initialen Argumenten des xargs’<\/strong> übergebenen Befehls spezifiziert. Der hier verwendete find<\/strong>-Befehl sucht alle Dateien im Verzeichnis profi-tutorials\/<\/strong> des aktuellen Arbeitsverzeichnisses sowie seinen Unterverzeichnissen – diese werden an xargs <\/strong>übergeben und dort mit dem Befehl cp <\/strong>in ein Verzeichnis \/daten\/sicherung\/<\/strong> kopiert.<\/p>\n
Die Option -n<\/strong> für xargs <\/strong>wird zusätzlich verwendet, um pro cp<\/strong>-Befehl jeweils nur ein eingelesenes Argument einzusetzen.<\/p>\n
Eingabe:<\/h6>\n
find profi-tutorials\/ -type f | xargs -n 1 -I {} cp {} \/daten\/sicherung\/<\/p>\n
Ausgabe:<\/h6>\n
Direkt im Verzeichnis \/daten\/sicherung\/<\/strong> befinden sich nun Kopien aller Dateien, welche sich auch in profi-tutorials\/<\/strong> sowie Unterverzeichnissen befinden.<\/p>\n
-L – Maximale Zeilen<\/h3>\n
Das mit dieser Option festgelegte Limit bestimmt, wie viele nichtleere Eingabezeilen maximal pro Kommandozeile verwendet werden. Die Option -x<\/strong> wird impliziert.<\/p>\n
xargs -L [Anzahl] [Befehl [Initiale Argumente]]<\/pre>\n
-n – Maximale Argumente<\/h3>\n
Hiermit wird die maximale Anzahl Argumente festgelegt, die pro Kommandozeile verwendet werden. Wird die durch die Option -s<\/strong> festgelegte maximale Kommandozeilenlänge überschritten, so verwendet xargs <\/strong>automatisch weniger als die angegebene Anzahl Argumente – außer die Option -x<\/strong> wurde angegeben, welche xargs <\/strong>dann beenden lässt.<\/p>\n
xargs -n [Anzahl] [Befehl [Initiale Argumente]]<\/pre>\n
Beispiel: Maximale Argumente<\/h5>\n
Mithilfe der <\/span>Option -n wird die verwendete Anzahl Argumente pro Kommandozeile in diesem Beispiel auf eines begrenzt. Die Ausgabe des Befehls <\/span>ls erfolgt standardmäßig auf einer Zeile – hier soll mit <\/span>xargs und dem Befehl <\/span>echo, welcher jeweils ein Argument erhält, ein Eintrag pro Zeile ausgegeben werden.<\/span><\/h6>\n
Eingabe:<\/h6>\n
ls | xargs -n 1 echo<\/p>\n
Ausgabe:<\/h6>\n
befehle-systemkontrolle.txt<\/p>\n
befehl-hdparm.txt<\/p>\n
befehl-top.txt<\/p>\n
hardware-informationen-auslesen.txt<\/p>\n
-p – Interaktive Ausführung<\/h3>\n
Unter Verwendung dieser Option wird eine Eingabeaufforderung vor jeder Befehlsausführung gestartet, welche den Benutzer abfragt, ob die jeweilige Befehlszeile ausgeführt werden soll. Der Befehl wird nur dann ausgeführt, wenn die Antwort des Benutzers mit “y”<\/strong> oder “Y”<\/strong> beginnt. Die Option -t<\/strong> wird impliziert.<\/p>\n
xargs -p [Befehl [Initiale Argumente]]<\/pre>\n
-r – Keine Ausführung bei leerem stdin<\/h3>\n
Bei Verwendung dieser Option wird der Befehl nicht ausgeführt, wenn der Standard-Input stdin <\/strong>komplett leer ist. Standardmäßig wird der Befehl mindestens einmal ausgeführt, selbst wenn es keine Eingabe gibt.<\/p>\n
xargs -r [Befehl [Initiale Argumente]]<\/pre>\n
-s – Kommandozeilenlänge limitieren<\/h3>\n
Diese Option wird verwendet, um eine maximale Kommandozeilenlänge festzulegen, welche den Befehl selbst, die initialen Argumente und jegliche terminierenden Nullzeichen am Ende der Argument-Zeichenkette umfasst.<\/p>\n
xargs -s [Anzahl Zeichen] [Befehl [Initiale Argumente]]<\/pre>\n
–show-limits – Limits ausgeben<\/h3>\n
Mithilfe dieser Option können die Limits der Kommandozeilenlänge, welche durch das Betriebssystem<\/a>, xargs’<\/strong> Wahl der Puffergröße und die Option -s<\/strong> festgelegt werden, ausgegeben werden.<\/p>\n
xargs --show-limits [Befehl [Initiale Argumente]]<\/pre>\n
Soll xargs <\/strong>bei der Ausgabe keinen Befehl ausführen, so kann \/dev\/null<\/strong> als Eingabe dienen und zusätzlich zudem die Option -r<\/strong> gewählt werden.<\/p>\n
xargs -a \/dev\/null -r --show-limits<\/pre>\n
Beispiel: Limits ausgeben<\/h5>\n
Dieses Beispiel zeigt, wie mithilfe der <\/span>Option –show-limits verschiedene Größen und Begrenzungen ausgegeben werden. Die Verwendung der Datei <\/span>\/dev\/null als Eingabe sowie die <\/span>Option -r sorgen dafür, dass <\/span>xargs keine Aktionen ausführt.<\/span><\/h6>\n
Eingabe:<\/h6>\n
xargs -a \/dev\/null -r –show-limits<\/p>\n
Ausgabe:<\/h6>\n
Die Ausgabe umfasst Informationen zum von den Umgebungsvariablen<\/a> belegten Speicher (1)<\/strong>, der maximal in POSIX erlaubten Argumentlänge (2, 3)<\/strong> der tatsächlich nutzbaren maximalen Befehlslänge (4)<\/strong>, der Größe des verwendeten Befehlspuffers (5)<\/strong> sowie dem maximalen Parallelismus (6)<\/strong>.<\/p>\n
\"befehl-xargs-beispiel-3\"<\/span><\/p>\n
-t – Kommandozeilen ausgeben<\/h3>\n
Wird diese Option angegeben, so wird jede Kommandozeile vor ihrer Ausführung im Standard-Error-Output stderr <\/strong>ausgegeben.<\/p>\n
xargs -t [Befehl [Initiale Argumente]]<\/pre>\n
-x – Beenden bei Limit-Überschreitung<\/h3>\n
xargs <\/strong>wird bei Verwendung dieser Option beendet, wenn die maximale Kommandozeilenlänge überschritten wird.<\/p>\n
xargs -x [Befehl [Initiale Argumente]]<\/pre>\n
-P – Maximale Anzahl Prozesse<\/h3>\n
Mithilfe der Option -P<\/strong> kann die Befehlsausführung von xargs <\/strong>parallelisiert und somit eine gewisse Nebenläufigkeit erreicht werden. Die Option gibt dabei die maximale Anzahl der durch xargs <\/strong>gestarteten Prozesse an, die zu einem Zeitpunkt gleichzeitig laufen dürfen. Standardwert ist entsprechend der standardmäßigen seriellen Ausführung 1. Wird der Wert 0 angegeben, so versucht xargs <\/strong>so viele Prozesse wie möglich gleichzeitig auszuführen.<\/p>\n
xargs -P [Anzahl] [Befehl [Initiale Argumente]]<\/pre>\n
Beispiel: Maximale Anzahl Prozesse<\/h5>\n
Die maximale Anzahl Prozesse wird in diesem Beispiel mit der <\/span>Option -P auf den Wert 4 gesetzt, um eine Parallelität bei dem Herunterladen vieler kleiner Dateien mit dem Befehl <\/span>wget hervorzurufen. Die URLs, welche den <\/span>wget-Befehlen übergeben werden sollen, sind in der Datei <\/span>“profi-tutorials-urls.txt” im aktuellen Arbeitsverzeichnis aufgelistet – sie enthält insgesamt 87 Zeilen.<\/span><\/h6>\n
Der Befehl <\/span>time <\/strong>wird jeweils verwendet, um die Ausführungszeit von <\/span>xargs <\/strong>zu messen und auszugeben.<\/span><\/p>\n
Eingabe:<\/h6>\n
Zunächst sollen einem einzigen wget<\/strong>-Befehl alle 87 URLs übergeben werden, sodass auch nur ein Prozess gestartet wird.<\/p>\n
time xargs -a profi-tutorials-urls.txt wget -P \/tmp\/<\/p>\n
Ausgabe:<\/h6>\n
Der Ausgabe ist zu entnehmen, dass ein einzelner wget<\/strong>-Prozess in diesem Fall etwa 14,3 Sekunden<\/strong> zum Herunterladen aller 87 Dateien benötigt.<\/p>\n
\"befehl-xargs-beispiel-4\"<\/span><\/p>\n
Eingabe:<\/h6>\n
Dem Befehl xargs <\/strong>wird nun zusätzlich die Option -P<\/strong> mit dem Parameter 4 übergeben, um die parallele Ausführung von bis zu 4 wget<\/strong>-Prozessen zu ermöglichen. Weiterhin wird mit der Option -n<\/strong> die maximale Anzahl Argumente pro wget<\/strong>-Befehl auf 20 gesetzt, um den durch das Starten neuer wget<\/strong>-Prozesse erzeugten Overhead möglichst zu minimieren.<\/p>\n
time xargs -a profi-tutorials-urls.txt -n 20 -P 4 wget -P \/tmp\/<\/p>\n
Ausgabe:<\/h6>\n
Bei paralleler Ausführung der wget<\/strong>-Befehle wurden nur noch etwa 8,2 Sekunden<\/strong> zum Herunterladen der 87 Dateien benötigt – dies entspricht in diesem Beispiel einer Zeitersparnis von ca. 42%<\/strong>.<\/p>\n
\"befehl-xargs-beispiel-5\"<\/span><\/p>\n
Exit-Codes<\/h2>\n
Die folgende Tabelle zeigt die verschiedenen Exit-Codes<\/strong> sowie die jeweils angezeigten Status <\/strong>des Befehls xargs<\/strong>.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n
Exit-Code<\/strong><\/th>\nStatus<\/th>\n<\/tr>\n<\/thead>\n
0<\/td>\nAusführung erfolgreich<\/td>\n<\/tr>\n
123<\/td>\nEin beliebiger Aufruf des gegebenen Befehls wurde mit dem Exit-Code 1-125 beendet<\/td>\n<\/tr>\n
124<\/td>\nDer gegebene Befehl wurde mit dem Exit-Code 255 beendet<\/td>\n<\/tr>\n
125<\/td>\nDer gegebene Befehl wurde von einem Signal beendet<\/td>\n<\/tr>\n
126<\/td>\nDer gegebene Befehl kann nicht ausgeführt werden<\/td>\n<\/tr>\n
127<\/td>\nDer gegebene Befehl wurde nicht gefunden<\/td>\n<\/tr>\n
128+<\/td>\nWerden von der Shell verwendet, um anzuzeigen, dass ein Programm aufgrund eines fatalen Signals abgebrochen wurde<\/td>\n<\/tr>\n
1<\/td>\nEin anderer Fehler ist aufgetreten (Catchall)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Abonniere JETZT unseren Newsletter!<\/p>\n
Verpasse nie wieder neue<\/strong> Beiträge und exklusive Insider-Only-Inhalte!<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
In diesem Beitrag lernen Sie den Befehl xargs kennen, welcher verwendet wird, um Befehle mit Argumenten auszuf\u00fchren, welche vom Standard-Input gelesen werden. Viele Befehle lassen sich unter Linux- \/ UNIX standardm\u00e4\u00dfig sowohl auf einzelnen Dateien, als auch auf Listen von Dateien anwenden – ist dies nicht m\u00f6glich, kann der Befehl xargs eingesetzt werden. Ein weiterer […]<\/p>\n","protected":false},"author":2,"featured_media":7884,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":"","tve_updated_post":"
\t
In diesem Beitrag lernen Sie den Befehl xargs kennen, welcher verwendet wird, um Befehle mit Argumenten auszuf\u00fchren, welche vom Standard-Input gelesen werden. Viele Befehle lassen sich unter Linux- \/ UNIX standardm\u00e4\u00dfig sowohl auf einzelnen Dateien, als auch auf Listen von Dateien anwenden - ist dies nicht m\u00f6glich, kann der Befehl xargs eingesetzt werden. Ein weiterer Anwendungsfall f\u00fcr xargs ist zudem die Parallelisierung mehrerer Befehle, zum Beispiel rsync, um eine bessere Ausnutzung der Ressourcen des Systems zu erm\u00f6glichen.<\/p>
Zu Beginn wird die allgemeine Syntax des Befehls xargs gezeigt. Anschlie\u00dfend folgen die wichtigsten Optionen des Befehls mitsamt einiger Beispiele.<\/p><\/div>
\n\t
\n\t\tInhaltsverzeichnis<\/span>\n\t\t
Allgemeine Syntax<\/a><\/div>
Wichtige Optionen<\/a><\/div>
-a - Einlesen aus Datei<\/a><\/div>
-0 - NULL-Zeichen als Delimiter<\/a><\/div>
-d - Delimiter spezifizieren<\/a><\/div>
-E - EOF-Marker spezifizieren<\/a><\/div>
-I - Platzhalter ersetzen<\/a><\/div>
-L - Maximale Zeilen<\/a><\/div>
-n - Maximale Argumente<\/a><\/div>
-p - Interaktive Ausf\u00fchrung<\/a><\/div>
-r - Keine Ausf\u00fchrung bei leerem stdin<\/a><\/div>
-s - Kommandozeilenl\u00e4nge limitieren<\/a><\/div>
--show-limits - Limits ausgeben<\/a><\/div>
-t - Kommandozeilen ausgeben<\/a><\/div>
-x - Beenden bei Limit-\u00dcberschreitung<\/a><\/div>
-P - Maximale Anzahl Prozesse<\/a><\/div><\/div>
Exit-Codes<\/a><\/div><\/div><\/div>\n\t<\/div>\n<\/div>
Allgemeine Syntax<\/h2>
xargs <\/strong>wird neben verschiedenen verf\u00fcgbaren Optionen ein Befehl \u00fcbergeben, welcher dann mit den eingelesenen Argumenten ausgef\u00fchrt wird. Der Befehl kann dabei ganz normal mitsamt beliebiger initialer Argumente angegeben werden - xargs <\/strong>wird die aus dem Standard-Input stdin <\/strong>eingelesenen Argumente dann standardm\u00e4\u00dfig jeweils am Ende des Befehls anf\u00fcgen. Die allgemeine Syntax lautet somit folgenderma\u00dfen:<\/p>
[code]xargs [Optionen] [Befehl [Initiale Argumente]][\/code]<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: xargs ohne Optionen<\/h5><\/div>
\n\t
\n<\/div>
In diesem Beispiel wird der Befehl <\/span>xargs ohne jegliche Optionen eingesetzt, um die mit dem <\/span>find-Befehl gefundenen Dateien im aktuellen Arbeitsverzeichnis (und Unterverzeichnissen) alle an den Befehl <\/span>ls zu \u00fcbergeben. Dieser sortiert die Dateien mithilfe der <\/span>Option -S nach ihrer Gr\u00f6\u00dfe und gibt sie schlie\u00dflich an den Befehl <\/span>head weiter, welcher nur die ersten 5 Zeilen ausgibt.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
find .\/ -type f | xargs ls -lhS | head -5<\/p><\/div>
Ausgabe:<\/h6>
Die gr\u00f6\u00dften f\u00fcnf im Arbeitsverzeichnis sowie den entsprechenden Unterverzeichnissen vorhandenen Dateien werden ausgegeben.<\/p><\/div>
\"befehl-xargs-beispiel-1\"<\/span><\/div><\/div>\n<\/div>
Wichtige Optionen<\/h2>
In diesem Abschnitt werden die wichtigsten Optionen des Befehls xargs <\/strong>vorgestellt. Einige Beispiele zeigen dabei auch die praktische Anwendung der jeweiligen Optionen.<\/p>
-a - Einlesen aus Datei<\/h3>
Anstelle des Standard-Input stdin <\/strong>kann auch eine Datei zum Einlesen von Argumenten verwendet werden. Hierzu wird die Option -a<\/strong> verwendet und die entsprechende Datei als Parameter angegeben:<\/p>
[code]xargs -a [Datei] [Befehl [Initiale Argumente]][\/code]<\/p>
Bei Verwendung dieser Option verbleibt der Standard-Input-Stream stdin <\/strong>unver\u00e4ndert, wenn Befehle ausgef\u00fchrt werden. Andernfalls wird stdin <\/strong>von \/dev\/null<\/strong> umgeleitet.<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Einlesen aus Datei<\/h5><\/div>
\n\t
\n<\/div>
Hier sollen die Argumente von <\/span>xargs aus einer Datei eingelesen werden. Jede Zeile der Eingabedatei stellt in diesem Fall eine Datei dar, welche auch hier wieder mit <\/span>ls ausgegeben werden soll.<\/span><\/h6><\/div>
Inhalt \/home\/hellberg\/linux-grundlagen.txt:<\/h6><\/div>
\/home\/hellberg\/profi-tutorials\/linux\/grundlagen\/befehl-sudo.txt<\/p>
\/home\/hellberg\/profi-tutorials\/linux\/netzwerke\/befehl-scp.txt<\/p>
\/home\/hellberg\/profi-tutorials\/linux\/administration\/befehl-top.txt<\/p><\/div>
Eingabe:<\/h6><\/div>
xargs -a \/home\/hellberg\/linux-grundlagen.txt ls -lh<\/p><\/div>
Nach Ausf\u00fchrung:<\/h6><\/div>
\"befehl-xargs-beispiel-2\"<\/span><\/div><\/div>\n<\/div>
-0 - NULL-Zeichen als Delimiter<\/h3>
Die eingelesenen Argumente werden aufgrund des NULL-Zeichens<\/strong> anstelle von Leerzeichen getrennt. Au\u00dferdem werden jegliche Anf\u00fchrungszeichen sowie R\u00fcckschr\u00e4gstrich-Maskierungen nicht als Sonderzeichen interpretiert - alle Zeichen werden damit w\u00f6rtlich genommen. Die End-of-File-Zeichenkette (EOF) wird deaktiviert und wie jedes andere Argument interpretiert.<\/p>
[code]xargs -0 [Befehl [Initiale Argumente]][\/code]<\/p>
-d - Delimiter spezifizieren<\/h3>
Mit dieser Option kann ein Zeichen spezifiziert werden, welches anstelle des standardm\u00e4\u00dfigen Leerzeichens \/ Zeilenumbruchs als Delimiter verwendet werden soll. Genau wie auch bei der Option -0<\/strong> werden alle Zeichen w\u00f6rtlich genommen und die End-of-File-Zeichenkette deaktiviert.<\/p>
[code]xargs -d [Zeichen] [Befehl [Initiale Argumente]][\/code]<\/p>
Angegeben werden kann ein einzelnes Zeichen, ein Escape-Zeichen im C-Stil (etwa \"\\n\"<\/strong>) oder ein oktaler oder hexadezimaler Escape-Code. Multibyte-Zeichen werden nicht unterst\u00fctzt.<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Delimiter spezifizieren<\/h5><\/div>
\n\t
\n<\/div>
Dieses Beispiel zeigt, wie mit der <\/span>Option -d ein Delimiter zur Trennung einzelner Argumente spezifiziert wird. In diesem Fall wird der Delimiter <\/span>\";\" gew\u00e4hlt, um eine durch Semikola getrennte Liste von Home-Verzeichnissen Zeile f\u00fcr Zeile mit <\/span>echo in die Ausgabe zu schreiben. Zus\u00e4tzlich wird hier die <\/span>Option -n verwendet, um die Anzahl Argumente pro Kommandozeile bzw. <\/span>echo-Befehl auf eines zu beschr\u00e4nken.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
printf \"\/home\/hellberg;\/home\/admina;\/home\/bibo\" | xargs -n 1 -d \";\" echo<\/p><\/div>
Ausgabe:<\/h6>
Die drei in den Standard-Input von xargs <\/strong>gegebenen Home-Verzeichnisse werden nun zeilenweise ausgegeben.<\/p><\/div>
\/home\/hellberg<\/p>
\/home\/admina<\/p>
\/home\/bibo<\/p><\/div><\/div>\n<\/div>
-E - EOF-Marker spezifizieren<\/h3>
Der End-of-File-Marker (EOF) wird mit dieser Option auf die angegebene Zeichenkette gesetzt. Tritt der spezifizierte EOF-Marker als Eingabezeile auf, so wird die verbleibende Eingabe ignoriert.<\/p>
[code]xargs -E [Zeichenkette] [Befehl [Initiale Argumente]][\/code]<\/p>
Wird keine Zeichenkette angegeben, so gibt es keinen logischen EOF-Marker - dies ist die Standardeinstellung seit GNU xargs <\/strong>der Version 4.2.9. Wird neben -E<\/strong> auch die Option -d<\/strong> oder -0<\/strong> verwendet, so wird die hier angegebene Zeichenkette nicht gesondert behandelt, sodass stets die gesamte Eingabe gelesen wird.<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: EOF-Marker spezifizieren<\/h5><\/div>
\n\t
\n<\/div>
Mithilfe der <\/span>Option -E wird hier die Zeichenkette <\/span>\"ENDE\" als EOF-Marker spezifiziert. Die Argumente f\u00fcr <\/span>xargs werden aus dem Standard-Input eingelesen und stammen aus der Ausgabe des Befehls <\/span>cat, welcher auf der Datei <\/span>\"hellberg.txt\" ausgef\u00fchrt wird. Mit <\/span>echo werden die eingelesenen Argumente dann ausgegeben.<\/span><\/h6><\/div>
Inhalt hellberg.txt:<\/h6><\/div>
hellberg<\/p>
admina<\/p>
bibo<\/p>
ENDE<\/p>
hedv<\/p><\/div>
Eingabe:<\/h6><\/div>
cat hellberg.txt | xargs -E \"ENDE\" echo<\/p><\/div>
Nach Ausf\u00fchrung:<\/h6>
Es werden nun ausschlie\u00dflich die ersten drei Zeilen der Eingabe hintereinander, auf einer Zeile ausgegeben. Das Wort \"hedv\"<\/strong>, welches erst hinter dem EOF-Marker \"ENDE\"<\/strong> auftritt, wird von xargs <\/strong>ignoriert.<\/p><\/div>
hellberg admina bibo<\/p><\/div><\/div>\n<\/div>
-I - Platzhalter ersetzen<\/h3>
Die Option -I<\/strong> wird verwendet, um eine Platzhalter-Zeichenkette festzulegen, welche in den initialen Argumenten des xargs'<\/strong> \u00fcbergebenen Befehls durch die vom Standard-Input gelesenen Argumente ersetzt wird. Die Option impliziert zudem die Optionen -x<\/strong> und \"-l 1\"<\/strong>.<\/p>
[code]xargs -I [Zeichenkette] [Befehl [Initiale Argumente]][\/code]<\/p>
Leerzeichen, welche nicht in Anf\u00fchrungszeichen eingefasst sind, werden nicht zur Trennung der Argumente verwendet - stattdessen wird die Eingabe ausschlie\u00dflich an Zeilenumbr\u00fcchen getrennt.<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Platzhalter ersetzen<\/h5><\/div>
\n\t
\n<\/div>
\t
Mit der Option -I<\/strong> wird in diesem Beispiel ein Platzhalter zur Ersetzung in den initialen Argumenten des xargs'<\/strong> \u00fcbergebenen Befehls spezifiziert. Der hier verwendete find<\/strong>-Befehl sucht alle Dateien im Verzeichnis profi-tutorials\/<\/strong> des aktuellen Arbeitsverzeichnisses sowie seinen Unterverzeichnissen - diese werden an xargs <\/strong>\u00fcbergeben und dort mit dem Befehl cp <\/strong>in ein Verzeichnis \/daten\/sicherung\/<\/strong> kopiert.<\/p>
Die Option -n<\/strong> f\u00fcr xargs <\/strong>wird zus\u00e4tzlich verwendet, um pro cp<\/strong>-Befehl jeweils nur ein eingelesenes Argument einzusetzen.<\/p><\/div>
Eingabe:<\/h6><\/div>
find profi-tutorials\/ -type f | xargs -n 1 -I {} cp {} \/daten\/sicherung\/<\/p><\/div>
Ausgabe:<\/h6>
Direkt im Verzeichnis \/daten\/sicherung\/<\/strong> befinden sich nun Kopien aller Dateien, welche sich auch in profi-tutorials\/<\/strong> sowie Unterverzeichnissen befinden.<\/p><\/div><\/div>\n<\/div>
-L - Maximale Zeilen<\/h3>
Das mit dieser Option festgelegte Limit bestimmt, wie viele nichtleere Eingabezeilen maximal pro Kommandozeile verwendet werden. Die Option -x<\/strong> wird impliziert.<\/p>
[code]xargs -L [Anzahl] [Befehl [Initiale Argumente]][\/code]<\/p>
-n - Maximale Argumente<\/h3>
Hiermit wird die maximale Anzahl Argumente festgelegt, die pro Kommandozeile verwendet werden. Wird die durch die Option -s<\/strong> festgelegte maximale Kommandozeilenl\u00e4nge \u00fcberschritten, so verwendet xargs <\/strong>automatisch weniger als die angegebene Anzahl Argumente - au\u00dfer die Option -x<\/strong> wurde angegeben, welche xargs <\/strong>dann beenden l\u00e4sst.<\/p>
[code]xargs -n [Anzahl] [Befehl [Initiale Argumente]][\/code]<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Maximale Argumente<\/h5><\/div>
\n\t
\n<\/div>
Mithilfe der <\/span>Option -n wird die verwendete Anzahl Argumente pro Kommandozeile in diesem Beispiel auf eines begrenzt. Die Ausgabe des Befehls <\/span>ls erfolgt standardm\u00e4\u00dfig auf einer Zeile - hier soll mit <\/span>xargs und dem Befehl <\/span>echo, welcher jeweils ein Argument erh\u00e4lt, ein Eintrag pro Zeile ausgegeben werden.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
ls | xargs -n 1 echo<\/p><\/div>
Ausgabe:<\/h6><\/div>
befehle-systemkontrolle.txt<\/p>
befehl-hdparm.txt<\/p>
befehl-top.txt<\/p>
hardware-informationen-auslesen.txt<\/p><\/div><\/div>\n<\/div>
-p - Interaktive Ausf\u00fchrung<\/h3>
Unter Verwendung dieser Option wird eine Eingabeaufforderung vor jeder Befehlsausf\u00fchrung gestartet, welche den Benutzer abfragt, ob die jeweilige Befehlszeile ausgef\u00fchrt werden soll. Der Befehl wird nur dann ausgef\u00fchrt, wenn die Antwort des Benutzers mit \"y\"<\/strong> oder \"Y\"<\/strong> beginnt. Die Option -t<\/strong> wird impliziert.<\/p>
[code]xargs -p [Befehl [Initiale Argumente]][\/code]<\/p>
-r - Keine Ausf\u00fchrung bei leerem stdin<\/h3>
Bei Verwendung dieser Option wird der Befehl nicht ausgef\u00fchrt, wenn der Standard-Input stdin <\/strong>komplett leer ist. Standardm\u00e4\u00dfig wird der Befehl mindestens einmal ausgef\u00fchrt, selbst wenn es keine Eingabe gibt.<\/p>
[code]xargs -r [Befehl [Initiale Argumente]][\/code]<\/p>
-s - Kommandozeilenl\u00e4nge limitieren<\/h3>
Diese Option wird verwendet, um eine maximale Kommandozeilenl\u00e4nge festzulegen, welche den Befehl selbst, die initialen Argumente und jegliche terminierenden Nullzeichen am Ende der Argument-Zeichenkette umfasst.<\/p>
[code]xargs -s [Anzahl Zeichen] [Befehl [Initiale Argumente]][\/code]<\/p>
--show-limits - Limits ausgeben<\/h3>
Mithilfe dieser Option k\u00f6nnen die Limits der Kommandozeilenl\u00e4nge, welche durch das Betriebssystem, xargs'<\/strong> Wahl der Puffergr\u00f6\u00dfe und die Option -s<\/strong> festgelegt werden, ausgegeben werden.<\/p>
[code]xargs --show-limits [Befehl [Initiale Argumente]][\/code]<\/p>
Soll xargs <\/strong>bei der Ausgabe keinen Befehl ausf\u00fchren, so kann \/dev\/null<\/strong> als Eingabe dienen und zus\u00e4tzlich zudem die Option -r<\/strong> gew\u00e4hlt werden.<\/p>
[code]xargs -a \/dev\/null -r --show-limits[\/code]<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Limits ausgeben<\/h5><\/div>
\n\t
\n<\/div>
Dieses Beispiel zeigt, wie mithilfe der <\/span>Option --show-limits verschiedene Gr\u00f6\u00dfen und Begrenzungen ausgegeben werden. Die Verwendung der Datei <\/span>\/dev\/null als Eingabe sowie die <\/span>Option -r sorgen daf\u00fcr, dass <\/span>xargs keine Aktionen ausf\u00fchrt.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
xargs -a \/dev\/null -r --show-limits<\/p><\/div>
Ausgabe:<\/h6>
Die Ausgabe umfasst Informationen zum von den Umgebungsvariablen belegten Speicher (1)<\/strong>, der maximal in POSIX erlaubten Argumentl\u00e4nge (2, 3)<\/strong> der tats\u00e4chlich nutzbaren maximalen Befehlsl\u00e4nge (4)<\/strong>, der Gr\u00f6\u00dfe des verwendeten Befehlspuffers (5)<\/strong> sowie dem maximalen Parallelismus (6)<\/strong>.<\/p><\/div>
\"befehl-xargs-beispiel-3\"<\/span><\/div><\/div>\n<\/div>
-t - Kommandozeilen ausgeben<\/h3>
Wird diese Option angegeben, so wird jede Kommandozeile vor ihrer Ausf\u00fchrung im Standard-Error-Output stderr <\/strong>ausgegeben.<\/p>
[code]xargs -t [Befehl [Initiale Argumente]][\/code]<\/p>
-x - Beenden bei Limit-\u00dcberschreitung<\/h3>
xargs <\/strong>wird bei Verwendung dieser Option beendet, wenn die maximale Kommandozeilenl\u00e4nge \u00fcberschritten wird.<\/p>
[code]xargs -x [Befehl [Initiale Argumente]][\/code]<\/p>
-P - Maximale Anzahl Prozesse<\/h3>
Mithilfe der Option -P<\/strong> kann die Befehlsausf\u00fchrung von xargs <\/strong>parallelisiert und somit eine gewisse Nebenl\u00e4ufigkeit erreicht werden. Die Option gibt dabei die maximale Anzahl der durch xargs <\/strong>gestarteten Prozesse an, die zu einem Zeitpunkt gleichzeitig laufen d\u00fcrfen. Standardwert ist entsprechend der standardm\u00e4\u00dfigen seriellen Ausf\u00fchrung 1. Wird der Wert 0 angegeben, so versucht xargs <\/strong>so viele Prozesse wie m\u00f6glich gleichzeitig auszuf\u00fchren.<\/p>
[code]xargs -P [Anzahl] [Befehl [Initiale Argumente]][\/code]<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Maximale Anzahl Prozesse<\/h5><\/div>
\n\t
\n<\/div>
Die maximale Anzahl Prozesse wird in diesem Beispiel mit der <\/span>Option -P auf den Wert 4 gesetzt, um eine Parallelit\u00e4t bei dem Herunterladen vieler kleiner Dateien mit dem Befehl <\/span>wget hervorzurufen. Die URLs, welche den <\/span>wget-Befehlen \u00fcbergeben werden sollen, sind in der Datei <\/span>\"profi-tutorials-urls.txt\" im aktuellen Arbeitsverzeichnis aufgelistet - sie enth\u00e4lt insgesamt 87 Zeilen.<\/span><\/h6>
Der Befehl <\/span>time <\/strong>wird jeweils verwendet, um die Ausf\u00fchrungszeit von <\/span>xargs <\/strong>zu messen und auszugeben.<\/span><\/p><\/div>
Eingabe:<\/h6>
Zun\u00e4chst sollen einem einzigen wget<\/strong>-Befehl alle 87 URLs \u00fcbergeben werden, sodass auch nur ein Prozess gestartet wird.<\/p><\/div>
time xargs -a profi-tutorials-urls.txt wget -P \/tmp\/<\/p><\/div>
Ausgabe:<\/h6>
Der Ausgabe ist zu entnehmen, dass ein einzelner wget<\/strong>-Prozess in diesem Fall etwa 14,3 Sekunden<\/strong> zum Herunterladen aller 87 Dateien ben\u00f6tigt.<\/p><\/div>
\"befehl-xargs-beispiel-4\"<\/span><\/div>
Eingabe:<\/h6>
Dem Befehl xargs <\/strong>wird nun zus\u00e4tzlich die Option -P<\/strong> mit dem Parameter 4 \u00fcbergeben, um die parallele Ausf\u00fchrung von bis zu 4 wget<\/strong>-Prozessen zu erm\u00f6glichen. Weiterhin wird mit der Option -n<\/strong> die maximale Anzahl Argumente pro wget<\/strong>-Befehl auf 20 gesetzt, um den durch das Starten neuer wget<\/strong>-Prozesse erzeugten Overhead m\u00f6glichst zu minimieren.<\/p><\/div>
time xargs -a profi-tutorials-urls.txt -n 20 -P 4 wget -P \/tmp\/<\/p><\/div>
Ausgabe:<\/h6>
Bei paralleler Ausf\u00fchrung der wget<\/strong>-Befehle wurden nur noch etwa 8,2 Sekunden<\/strong> zum Herunterladen der 87 Dateien ben\u00f6tigt - dies entspricht in diesem Beispiel einer Zeitersparnis von ca. 42%<\/strong>.<\/p><\/div>
\"befehl-xargs-beispiel-5\"<\/span><\/div><\/div>\n<\/div>
Exit-Codes<\/h2>
Die folgende Tabelle zeigt die verschiedenen Exit-Codes<\/strong> sowie die jeweils angezeigten Status <\/strong>des Befehls xargs<\/strong>.<\/p><\/div>
Exit-Code<\/strong><\/p><\/div><\/th>
Status<\/p><\/div><\/th><\/tr><\/thead>
0<\/p><\/div><\/td>
Ausf\u00fchrung erfolgreich<\/p><\/div><\/td><\/tr>
123<\/p><\/div><\/td>
Ein beliebiger Aufruf des gegebenen Befehls wurde mit dem Exit-Code 1-125 beendet<\/p><\/div><\/td><\/tr>
124<\/p><\/div><\/td>
Der gegebene Befehl wurde mit dem Exit-Code 255 beendet<\/p><\/div><\/td><\/tr>
125<\/p><\/div><\/td>
Der gegebene Befehl wurde von einem Signal beendet<\/p><\/div><\/td><\/tr>
\t
126<\/p><\/div><\/td>
\t
Der gegebene Befehl kann nicht ausgef\u00fchrt werden<\/p><\/div><\/td><\/tr>
\t
127<\/p><\/div><\/td>
\t
Der gegebene Befehl wurde nicht gefunden<\/p><\/div><\/td><\/tr>
\t
128+<\/p><\/div><\/td>
\t
Werden von der Shell verwendet, um anzuzeigen, dass ein Programm aufgrund eines fatalen Signals abgebrochen wurde<\/p><\/div><\/td><\/tr>
\t
1<\/p><\/div><\/td>
\t
Ein anderer Fehler ist aufgetreten (Catchall)<\/p><\/div><\/td><\/tr><\/tbody><\/table><\/div>
\n\t
<\/div>\n\t
Abonniere JETZT unseren Newsletter!<\/p><\/div>
\n\t
\n<\/div>
Verpasse nie wieder neue<\/strong> Beitr\u00e4ge und exklusive Insider-Only-Inhalte!<\/strong><\/p><\/div>
\n\t
<\/div>
<\/div>