Linux xargs Befehl: Befehlskonstruktion

Einführung

In diesem Lab werden Sie den leistungsstarken xargs-Befehl unter Linux erkunden. Der xargs-Befehl ist ein vielseitiges Werkzeug, mit dem Sie Befehle aus der Standardeingabe (Standard Input) erstellen und ausführen können. Er ist besonders nützlich, um Listen von Argumenten zu verarbeiten und diese in ausführbare Befehlszeilen umzuwandeln.

Während dieses Labs nutzen wir das Konzept der "Buchverarbeitung" als Beispielaufgabe. Es ist wichtig zu beachten, dass "Buchverarbeitung" kein spezifischer Linux-Befehl ist, sondern ein Platzhalter für jede beliebige Operation, die Sie auf einer Liste von Elementen ausführen möchten. In unseren Beispielen verwenden wir oft einfache Befehle wie echo oder touch, um diese Verarbeitung zu simulieren. In realen Szenarien würden Sie diese durch komplexere Befehle oder Skripte ersetzen, die für Ihre spezifische Aufgabe relevant sind.

Am Ende dieses Labs werden Sie in der Lage sein, Dateien effizient zu verwalten und sich wiederholende Aufgaben mit xargs zu automatisieren. Dieses Lab ist für Anfänger konzipiert. Machen Sie sich also keine Sorgen, wenn Sie neu in der Linux-Kommandozeile sind – wir führen Sie sorgfältig durch jeden Schritt.

Den xargs-Befehl verstehen

Beginnen wir damit, die grundlegende Verwendung des xargs-Befehls zu verstehen und zu klären, wann er ein nützliches Werkzeug ist. xargs ist besonders hilfreich, wenn Sie die Ausgabe eines Befehls nehmen und diese als Argumente für einen anderen Befehl verwenden möchten. Dies ist ein gängiges Szenario in der Shell-Skriptierung und bei Workflows auf der Kommandozeile.

Stellen Sie sich ein Szenario vor, in dem Sie eine Liste von Elementen haben und für jedes Element eine Aktion ausführen möchten. Während Sie in einem Skript eine for-Schleife verwenden könnten, bietet xargs oft einen prägnanteren und effizienteren Weg, dies zu erreichen – insbesondere bei großen Listen oder wenn der Zielbefehl mehrere Argumente gleichzeitig verarbeiten kann.

Nutzen wir ein einfaches Beispiel, um zu demonstrieren, wie xargs mit Eingaben aus einer Datei arbeitet. Schauen wir uns zunächst den Inhalt einer Datei an, die eine Liste von Früchten enthält:

cat ~/project/fruits.txt

Sie sollten die folgende Ausgabe sehen:

apple
orange
banana

Nun verwenden wir xargs, um den Inhalt dieser Datei per echo auszugeben. Dies simuliert, dass jede Zeile der Datei als Argument für den echo-Befehl verwendet wird.

cat ~/project/fruits.txt | xargs echo

Sie sollten die folgende Ausgabe sehen:

apple orange banana

In diesem Beispiel nimmt xargs die Eingabe von cat (jede Zeile der Datei) und verwendet sie als Argumente für den echo-Befehl. Der echo-Befehl simuliert hier unsere "Verarbeitungsoperation". Standardmäßig behandelt xargs jede Zeile als separates Argument und kombiniert sie zu einer einzigen Befehlsausführung.

Lassen Sie uns aufschlüsseln, was hier passiert:

1. cat ~/project/fruits.txt liest den Inhalt der Datei.
2. Das Symbol | (Pipe) leitet diese Ausgabe an den nächsten Befehl weiter.
3. xargs echo nimmt jede Zeile aus der Eingabe und verwendet sie als Argument für den echo-Befehl.

Dies ist nützlich, da es uns ermöglicht, mehrere Elemente in einem einzigen Befehl zu verarbeiten. Das kann viel effizienter sein, als jedes Element einzeln zu bearbeiten, besonders wenn der Zielbefehl mehrere Argumente verarbeiten kann. In der Praxis würden Sie echo durch den Befehl oder das Skript ersetzen, das Sie tatsächlich auf jedes Element Ihrer Liste anwenden müssen. Hier glänzt xargs: Es schließt die Lücke zwischen Befehlen, die Listen erzeugen, und Befehlen, die mit Argumenten arbeiten.

Dateien mit xargs verarbeiten

Aufbauend auf unserem Verständnis, wie xargs Eingaben als Argumente verwendet, untersuchen wir nun eine praktischere Anwendung: die Verarbeitung von Dateien. Stellen Sie sich vor, Sie sind ein Bibliothekar, der ein digitales Archiv organisieren soll. Sie haben eine Liste von Buchtiteln und müssen für jedes Buch eine leere Datei erstellen. Während eine einfache for-Schleife dies erledigen könnte, bietet xargs eine Alternative, insbesondere wenn die Dateiliste von einem anderen Befehl (wie find) generiert wird.

Verwenden wir xargs, um diesen Prozess der Dateierstellung aus einer Liste zu automatisieren. Schauen wir uns zuerst den Inhalt einer Datei mit Buchtiteln an:

cat ~/project/books.txt

Sie sollten sehen:

The_Great_Gatsby
To_Kill_a_Mockingbird
1984

Nun verwenden wir xargs zusammen mit dem touch-Befehl, um für jedes Buch eine leere Datei zu erstellen. Wir führen hierbei die Option -I ein. Diese ist entscheidend, wenn Sie das Eingabeargument an einer ganz bestimmten Position innerhalb des auszuführenden Befehls platzieren müssen.

cat ~/project/books.txt | xargs -I {} touch ~/project/{}.txt

Lassen Sie uns diesen Befehl aufschlüsseln:

• cat ~/project/books.txt: Liest den Inhalt unserer Bücherliste.
• |: Dieses Pipe-Symbol sendet die Ausgabe von cat an den nächsten Befehl.
• xargs: Unser Befehl zum Erstellen und Ausführen von Befehlen aus der Standardeingabe.
• -I {}: Diese Option weist xargs an, jedes Vorkommen von {} im Befehl durch die jeweilige Eingabezeile zu ersetzen. Dies ist besonders nützlich, wenn der auszuführende Befehl das Argument in der Mitte oder am Ende benötigt und nicht einfach nur hinten angehängt.
• touch ~/project/{}.txt: Dies ist der Befehl, den xargs für jede Eingabezeile ausführt. Das {} wird durch den jeweiligen Buchtitel ersetzt, und .txt wird angehängt, um den Dateinamen zu bilden.

Dieser Befehl nutzt die Option -I {}, um einen Platzhalter ({}) für jedes Eingabeelement zu definieren. Für jede Zeile in books.txt ersetzt xargs das {} durch den Buchtitel und führt den touch-Befehl aus. So wird effektiv eine Datei erstellt, die nach dem Buchtitel benannt ist und die Endung .txt hat.

Überprüfen wir, ob die Dateien erstellt wurden:

ls ~/project/*.txt

Sie sollten die folgende Ausgabe sehen:

/home/labex/project/1984.txt
/home/labex/project/The_Great_Gatsby.txt
/home/labex/project/To_Kill_a_Mockingbird.txt
/home/labex/project/books.txt
/home/labex/project/fruits.txt

Wie Sie sehen können, hat xargs für jeden Buchtitel eine neue .txt-Datei erstellt, zusätzlich zu unseren ursprünglichen Dateien books.txt und fruits.txt. Dies zeigt, wie xargs verwendet werden kann, um einen Befehl auf eine Liste von Elementen anzuwenden, was es zu einem mächtigen Werkzeug für Dateimanipulation und Automatisierung macht.

Argumente mit xargs begrenzen

Wenn unsere digitale Bibliothek wächst, könnten wir auf Situationen stoßen, in denen der Befehl, den wir ausführen möchten, ein Limit für die Anzahl der akzeptierten Argumente hat. Oder wir möchten Elemente einfach in kleineren Stapeln (Batches) verarbeiten, um eine bessere Kontrolle oder Ressourcenverwaltung zu ermöglichen. Die Option -n von xargs erlaubt es uns, die Anzahl der Argumente zu begrenzen, die an jede einzelne Befehlsausführung übergeben werden. Dies ist ein weiteres Szenario, in dem xargs eine feingranulare Kontrolle darüber bietet, wie Befehle basierend auf der Eingabe ausgeführt werden.

Schauen wir uns eine Datei mit weiteren Buchtiteln an:

cat ~/project/more_books.txt

Sie sollten sehen:

Pride_and_Prejudice
The_Catcher_in_the_Rye
The_Hobbit
Animal_Farm
Brave_New_World

Nun verwenden wir xargs mit der Option -n, um jeweils zwei Bücher gleichzeitig zu verarbeiten. Wir nutzen wieder echo, um die verarbeiteten Stapel zu visualisieren.

cat ~/project/more_books.txt | xargs -n 2 echo "Processing books:"

Sie sollten eine Ausgabe ähnlich dieser sehen:

Processing books: Pride_and_Prejudice The_Catcher_in_the_Rye
Processing books: The_Hobbit Animal_Farm
Processing books: Brave_New_World

Lassen Sie uns aufschlüsseln, was hier passiert:

• cat ~/project/more_books.txt: Liest den Inhalt unserer Bücherliste.
• |: Das Pipe-Symbol leitet die Ausgabe an den nächsten Befehl weiter.
• xargs -n 2: Dies weist xargs an, höchstens 2 Argumente pro Befehlsausführung zu verwenden. Das bedeutet, xargs gruppiert die Eingabezeilen in Zweier-Sets und führt den Zielbefehl für jede Gruppe aus.
• echo "Processing books:": Dies ist der Befehl, den xargs ausführt. Die Argumente (die Buchtitel) werden an diesen Befehl angehängt.

Dieser Befehl verarbeitet die Bücher paarweise, wobei das letzte Buch allein verarbeitet wird, wenn eine ungerade Anzahl von Titeln vorliegt. Die Option -n ist nützlich, wenn Sie Elemente in bestimmten Gruppengrößen verarbeiten möchten. Dies hilft bei der Verwaltung großer Listen oder bei Befehlen, die eine Obergrenze für Argumente haben. Es bietet eine Möglichkeit, eine große Aufgabe in kleinere, handlichere Teilaufgaben zu zerlegen, die nacheinander vom selben Befehl ausgeführt werden.

Parallele Verarbeitung mit xargs

Da unsere Bibliothek weiter expandiert, möchten wir die Dateiverarbeitung beschleunigen. Für Aufgaben, die voneinander unabhängig sind, kann die parallele Ausführung die Gesamtlaufzeit erheblich verkürzen. Die Option -P von xargs ermöglicht es uns, mehrere Instanzen des Zielbefehls gleichzeitig auszuführen. Dies kann die Leistung bei I/O-lastigen Operationen oder Aufgaben, die Wartezeiten beinhalten, deutlich verbessern. Dies ist ein entscheidender Vorteil von xargs gegenüber einer einfachen sequentiellen Verarbeitung mit einer for-Schleife.

Zuerst erstellen wir ein Skript, das die Verarbeitung eines Buches simuliert, indem es einen Zeitstempel zum Inhalt hinzufügt und eine Verzögerung einbaut. Diese Verzögerung hilft uns, die parallele Ausführung zu visualisieren.

cat ~/project/process_book.sh

Sie sollten sehen:

#!/bin/bash
echo "Processing $1 at $(date)" > ~/project/processed_$1
sleep 2 ## Simuliere etwas Verarbeitungszeit

Dieses Skript macht Folgendes:

1. Es nimmt einen Buchtitel als Argument entgegen ($1).
2. Es erstellt eine neue Datei, wobei "processed_" dem Buchtitel vorangestellt wird.
3. Es schreibt eine Nachricht in diese Datei, einschließlich des aktuellen Datums und der Uhrzeit.
4. Es wartet 2 Sekunden, um eine Verarbeitungszeit zu simulieren, wodurch die parallele Ausführung deutlicher wird.

Nun verwenden wir xargs mit der Option -P, um Bücher parallel zu verarbeiten. Wir nutzen auch wieder die Option -I, um jeden Buchtitel als Argument an unser Skript zu übergeben.

cat ~/project/more_books.txt | xargs -P 3 -I {} ~/project/process_book.sh {}

Lassen Sie uns diesen Befehl aufschlüsseln:

• cat ~/project/more_books.txt: Liest unsere Bücherliste.
• |: Das Pipe-Symbol sendet die Ausgabe an xargs.
• xargs -P 3: Dies weist xargs an, bis zu 3 Prozesse parallel auszuführen. xargs startet bis zu 3 Instanzen des Zielbefehls gleichzeitig, wobei jede ein oder mehrere Eingabeelemente verarbeitet.
• -I {}: Definiert {} als Platzhalter für jedes Eingabeelement, das als Argument an unser Skript übergeben wird.
• ~/project/process_book.sh {}: Dies ist der Befehl, der für jedes Buch ausgeführt wird, wobei {} durch den Buchtitel ersetzt wird.

Dieser Befehl beginnt mit der gleichzeitigen Verarbeitung von bis zu 3 Büchern. Nach der Ausführung können Sie den Inhalt der verarbeiteten Dateien überprüfen:

cat ~/project/processed_*

Sie sollten eine Ausgabe sehen, die zeigt, dass die Bücher zu leicht unterschiedlichen Zeiten verarbeitet wurden, was auf eine parallele Ausführung hindeutet. Die genauen Zeiten variieren, aber es könnte etwa so aussehen:

Processing Pride_and_Prejudice at Mon Aug 12 10:15:01 UTC 2024
Processing The_Catcher_in_the_Rye at Mon Aug 12 10:15:01 UTC 2024
Processing The_Hobbit at Mon Aug 12 10:15:01 UTC 2024
Processing Animal_Farm at Mon Aug 12 10:15:03 UTC 2024
Processing Brave_New_World at Mon Aug 12 10:15:03 UTC 2024

Beachten Sie, dass die ersten drei Bücher gleichzeitig mit der Verarbeitung beginnen und die letzten beiden etwa 2 Sekunden später starten (aufgrund des sleep 2 in unserem Skript). Dies demonstriert die parallele Verarbeitung in Aktion – ein signifikanter Vorteil von xargs zur Beschleunigung unabhängiger Aufgaben.

Kombination von xargs-Optionen

In der Praxis müssen Sie oft verschiedene xargs-Optionen kombinieren, um das gewünschte Verhalten zu erzielen. Für unsere letzte Aufgabe untersuchen wir, wie wir unsere Bücher in Stapeln verarbeiten und gleichzeitig die parallele Verarbeitung nutzen können. Wir verwenden einen etwas anderen Ansatz als ursprünglich vorgeschlagen, um den gegenseitigen Ausschluss der Optionen -n und -I bei direkter Verwendung mit einem einfachen Befehl zu umgehen. Stattdessen nutzen wir einen Shell-Befehl (sh -c) als Ziel für xargs. Dies ermöglicht es uns, mehrere durch -n übergebene Argumente innerhalb des Shell-Skripts zu handhaben.

Schauen wir uns unsere Liste klassischer Bücher an:

cat ~/project/classic_books.txt

Sie sollten sehen:

Moby_Dick
War_and_Peace
Ulysses
Don_Quixote
The_Odyssey
Madame_Bovary
Lolita
Hamlet
The_Iliad
Crime_and_Punishment

Nun verwenden wir xargs, um diese Bücher in 2er-Stapeln mit bis zu 3 parallelen Prozessen zu verarbeiten. Wir nutzen sh -c, um einen einfachen Befehl auszuführen, der den gerade verarbeiteten Stapel ausgibt.

cat ~/project/classic_books.txt | xargs -n 2 -P 3 sh -c 'echo "Processing batch: $@"' _

Lassen Sie uns diesen Befehl aufschlüsseln:

• cat ~/project/classic_books.txt: Liest unsere Liste klassischer Bücher.
• |: Das Pipe-Symbol sendet die Ausgabe an xargs.
• xargs: Unser Befehl zum Erstellen und Ausführen von Befehlen.
• -n 2: Diese Option weist xargs an, 2 Argumente (Buchtitel) pro Befehlsausführung zu verwenden. Diese zwei Argumente werden an den sh -c-Befehl übergeben.
• -P 3: Diese Option weist xargs an, bis zu 3 Prozesse parallel auszuführen. Jeder Prozess führt den sh -c-Befehl mit einem Stapel von 2 Buchtiteln aus.
• sh -c 'echo "Processing batch: $@"' _: Dies ist der Befehl, den xargs ausführt.
  • sh -c: Führt einen Befehls-String mithilfe der Shell aus.
  • 'echo "Processing batch: $@"': Der auszuführende Befehls-String. $@ innerhalb des Shell-Skripts wird zu allen an das Skript übergebenen Positionsparametern erweitert – in diesem Fall die von xargs bereitgestellten Argumente (die zwei Buchtitel).
  • _: Dies ist ein Platzhalter-Argument, das an sh -c übergeben wird. Es wird zum Wert von $0 innerhalb des Shell-Skripts. Wir verwenden es hier, weil sh -c erwartet, dass $0 gesetzt ist, und es die Ausgabe bei Verwendung von $@ nicht beeinflusst.

Sie sollten eine Ausgabe ähnlich dieser sehen:

Processing batch: Moby_Dick War_and_Peace
Processing batch: Ulysses Don_Quixote
Processing batch: The_Odyssey Madame_Bovary
Processing batch: Lolita Hamlet
Processing batch: The_Iliad Crime_and_Punishment

Dieser Befehl zeigt, wie wir eine große Anzahl von Elementen effizient in Stapeln verarbeiten und gleichzeitig die Vorteile der parallelen Verarbeitung nutzen können. In diesem Fall verarbeiten wir Bücher paarweise (wegen -n 2) und führen bis zu drei dieser Paar-Verarbeitungsbefehle gleichzeitig aus (wegen -P 3).

Der Vorteil dieses Ansatzes ist, dass Sie Elemente in überschaubaren Häppchen verarbeiten können, während die parallele Ausführung die Gesamtoperation beschleunigt. Dies ist besonders nützlich bei großen Datensätzen oder wenn Sie die Verarbeitungsgeschwindigkeit mit der Systemressourcenauslastung in Einklang bringen müssen. Durch die Verwendung von sh -c können wir die mehreren von -n übergebenen Argumente effektiv innerhalb einer einzigen Befehlsausführung handhaben, was xargs zu einem flexiblen Werkzeug für komplexe Workflows macht. In einem realen Szenario würden Sie den echo-Befehl durch ein komplexeres Skript ersetzen, das für die Verarbeitung eines Stapels von Elementen ausgelegt ist.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie den xargs-Befehl verwenden, um Dateiverwaltungsaufgaben zu automatisieren. Sie haben die grundlegende Verwendung kennengelernt, erfahren, wie man Dateien verarbeitet, Argumente begrenzt, parallele Verarbeitung durchführt und Optionen für eine effiziente Stapelverarbeitung kombiniert. Diese Fähigkeiten sind von unschätzbarem Wert, wenn Sie große Datenmengen handhaben oder sich wiederholende Aufgaben in Ihrer Linux-Umgebung automatisieren müssen.

Hier sind einige zusätzliche xargs-Optionen, die im Lab nicht behandelt wurden:

• -0: Verwendet das Null-Zeichen als Trennzeichen anstelle von Leerzeichen.
• -L: Verwendet maximal eine bestimmte Anzahl von nicht-leeren Eingabezeilen pro Befehlszeile.
• -s: Verwendet maximal eine bestimmte Anzahl von Zeichen pro Befehlszeile.
• -r: Führt den Befehl nicht aus, wenn die Standardeingabe leer ist.
• -a: Liest Elemente aus einer Datei anstatt aus der Standardeingabe.
• -E: Legt eine Zeichenfolge für das Dateiende (EOF) fest.

Denken Sie daran: Die Stärke von xargs liegt in seiner Flexibilität und der Fähigkeit, nahtlos mit anderen Linux-Befehlen zusammenzuarbeiten. Während Sie weiter mit Linux arbeiten, werden Sie viele weitere Situationen finden, in denen xargs Ihnen hilft, Aufgaben zu automatisieren und Ihre Produktivität zu steigern.