{"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":{"_seopress_robots_primary_cat":"none","_seopress_titles_title":"%%post_title%% %%sep%% %%sitetitle%%","_seopress_titles_desc":"In diesem Beitrag lernen Sie den Befehl xargs kennen, welcher unter UNIX- \/ Linux dazu verwendet wird, um Befehle mit Argumenten vom Standard-Input auszuf\u00fchren.","_seopress_robots_index":"","footnotes":""},"categories":[8],"tags":[],"class_list":["post-7620","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-administration"],"_links":{"self":[{"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/posts\/7620","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/comments?post=7620"}],"version-history":[{"count":147,"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/posts\/7620\/revisions"}],"predecessor-version":[{"id":8010,"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/posts\/7620\/revisions\/8010"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/media\/7884"}],"wp:attachment":[{"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/media?parent=7620"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/categories?post=7620"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/tags?post=7620"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}