Linux xargs-Befehl: Befehlskonstruktion

Einführung

In diesem Lab werden Sie den leistungsstarken xargs-Befehl in Linux erkunden. Der xargs-Befehl ist ein vielseitiges Werkzeug, das es Ihnen ermöglicht, Befehle aus der Standardeingabe zu erstellen und auszuführen. Er ist besonders nützlich für die Verarbeitung von Argumentlisten und deren Umwandlung in Befehlszeilen.

Im Laufe dieses Labs werden wir das Konzept des "Verarbeitens von Büchern" als Beispielaufgabe verwenden. Es ist wichtig zu beachten, dass "Verarbeiten von Büchern" kein spezifischer Linux-Befehl ist, sondern eher ein Platzhalter für jede Operation, die Sie möglicherweise auf einer Liste von Elementen ausführen möchten. In unseren Beispielen werden wir oft einfache Befehle wie echo oder touch verwenden, 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 können Sie Dateien effizient verwalten und repetitive Aufgaben mit xargs automatisieren. Dieses Lab ist für Anfänger konzipiert, also keine Sorge, wenn Sie neu in der Welt der Linux-Befehle sind - wir werden Sie Schritt für Schritt begleiten.

Skills Graph

Das xargs-Kommando verstehen

Beginnen wir damit, die grundlegende Verwendung des xargs-Befehls zu verstehen. Wir werden ein einfaches Beispiel verwenden, um zu zeigen, wie xargs mit Eingaben aus einer Datei arbeitet.

Zunächst schauen wir uns 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 auszugeben:

cat ~/project/fruits.txt | xargs echo

Sie sollten die folgende Ausgabe sehen:

apple orange banana

In diesem Beispiel nimmt xargs die Eingabe von cat und verwendet sie als Argumente für den echo-Befehl. Der echo-Befehl simuliert hier unsere "Verarbeitungs"-Operation. Standardmäßig behandelt xargs jede Zeile als separates Argument und kombiniert sie zu einem einzigen Befehl.

Lassen Sie uns analysieren, was hier passiert:

1. cat ~/project/fruits.txt liest den Inhalt der Datei.
2. Das | (Pipe)-Symbol sendet diese Ausgabe an den nächsten Befehl.
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, was viel effizienter ist als die separate Verarbeitung jedes Elements. In realen Anwendungen würden Sie echo durch den Befehl oder das Skript ersetzen, das Sie für jedes Element in Ihrer Liste ausführen müssen.

Dateiverarbeitung mit xargs

Stellen Sie sich vor, Sie sind Bibliothekar und müssen ein digitales Archiv organisieren. Sie haben eine Liste von Büchertiteln und müssen für jedes Buch leere Dateien erstellen. Lassen Sie uns xargs verwenden, um diesen Prozess zu automatisieren.

Zunächst schauen wir uns den Inhalt einer Datei an, die einige Büchertitel enthält:

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 leere Dateien zu erstellen:

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

Lassen Sie uns diesen Befehl analysieren:

• cat ~/project/books.txt: Dies liest den Inhalt unserer Büchertitel-Datei.
• |: Dieses Pipe-Symbol sendet die Ausgabe von cat an den nächsten Befehl.
• xargs: Dies ist unser Befehl zum Erstellen und Ausführen von Befehlen aus der Standardeingabe.
• -I {}: Diese Option teilt xargs mit, dass es Vorkommen von {} im Befehl durch jede Eingabezeile ersetzen soll.
• touch ~/project/{}.txt: Dies ist der Befehl, den xargs für jede Eingabezeile ausführen wird. Das {} wird durch jeden Büchertitel ersetzt.

Dieser Befehl verwendet die -I {}-Option, um einen Platzhalter ({}) für jedes Eingabeelement anzugeben. Für jede Zeile in books.txt wird xargs {} durch den Büchertitel ersetzen und den touch-Befehl ausführen.

Lassen Sie uns überprüfen, 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 Büchertitel eine neue.txt-Datei erstellt, zusammen mit unseren ursprünglichen books.txt- und fruits.txt-Dateien.

Begrenzung von Argumenten mit xargs

Mit dem Wachstum unserer digitalen Bibliothek möchten wir die Bücher in kleineren Batches verarbeiten. Die -n-Option von xargs ermöglicht es uns, die Anzahl der an jeden Befehlsaufruf übergebenen Argumente zu begrenzen.

Schauen wir uns eine Datei mit mehr Büchertiteln 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 -n-Option, um jeweils zwei Bücher zu verarbeiten:

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

Sie sollten eine Ausgabe ähnlich der folgenden 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 analysieren, was hier passiert:

• cat ~/project/more_books.txt: Dies liest den Inhalt unserer Büchertitel-Datei.
• |: Dieses Pipe-Symbol sendet die Ausgabe von cat an den nächsten Befehl.
• xargs -n 2: Dies teilt xargs mit, dass es maximal 2 Argumente pro Befehlsaufruf verwenden soll.
• echo "Processing books:": Dies ist der Befehl, den xargs ausführen wird, wobei die Büchertitel als zusätzliche Argumente übergeben werden.

Dieser Befehl verarbeitet die Bücher paarweise. Wenn die Anzahl der Titel ungerade ist, wird das letzte Buch allein verarbeitet. Die -n-Option ist nützlich, wenn Sie Elemente in bestimmten Gruppengrößen verarbeiten möchten. Dies kann hilfreich sein, um große Listen zu verwalten oder für Befehle, die eine Begrenzung bei der Anzahl der zu verarbeitenden Argumente haben.

Parallele Verarbeitung mit xargs

Da sich unsere Bibliothek weiter ausbaut, möchten wir die Dateiverarbeitung beschleunigen. Die -P-Option von xargs ermöglicht es uns, Befehle parallel auszuführen, was die Leistung bei I/O-beschränkten Operationen erheblich verbessern kann.

Zunächst erstellen wir ein Skript, das die Verarbeitung eines Buches simuliert, indem es einen Zeitstempel in dessen Inhalt einfügt:

cat ~/project/process_book.sh

Sie sollten sehen:

#!/bin/bash
echo "Processing $1 at $(date)" > ~/project/processed_$1
sleep 2 ## Simulate some processing time

Dieses Skript macht Folgendes:

1. Es nimmt einen Büchertitel als Argument ($1).
2. Es erstellt eine neue Datei mit dem Präfix "processed_" vor dem Büchertitel.
3. Es schreibt eine Nachricht in diese Datei, einschließlich des aktuellen Datums und der Uhrzeit.
4. Es wartet 2 Sekunden, um eine gewisse Verarbeitungszeit zu simulieren.

Nun verwenden wir xargs mit der -P-Option, um die Bücher parallel zu verarbeiten:

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

Lassen Sie uns diesen Befehl analysieren:

• cat ~/project/more_books.txt: Dies liest unsere Liste von Büchern.
• |: Dieses Pipe-Symbol sendet die Ausgabe an xargs.
• xargs -P 3: Dies teilt xargs mit, dass es bis zu 3 Prozesse parallel ausführen soll.
• -I {}: Dies definiert {} als Platzhalter für jedes Eingabeelement.
• ~/project/process_book.sh {}: Dies ist der Befehl, der für jedes Buch ausgeführt wird, wobei {} durch den Büchertitel ersetzt wird.

Dieser Befehl beginnt, bis zu 3 Bücher gleichzeitig zu verarbeiten. Nach der Ausführung des Befehls 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 hinweist. Die genauen Zeiten variieren, aber Sie könnten etwas wie Folgendes sehen:

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, wie die ersten drei Bücher gleichzeitig verarbeitet werden und die letzten beiden etwa 2 Sekunden später beginnen (aufgrund des sleep 2 in unserem Skript). Dies zeigt die parallele Verarbeitung in Aktion.

Kombination von xargs-Optionen

Für unsere letzte Aufgabe werden wir untersuchen, wie wir unsere Bücher in Batches verarbeiten können, während wir dennoch die parallele Verarbeitung nutzen. Wir werden einen etwas anderen Ansatz als ursprünglich vorgeschlagen verwenden, um die gegenseitige Exklusivität der -n- und -I-Optionen zu vermeiden.

Schauen wir uns unsere Liste von Klassikbüchern 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 Batches zu je 2 Büchern mit bis zu 3 parallelen Prozessen zu verarbeiten:

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

Lassen Sie uns diesen Befehl analysieren:

• cat ~/project/classic_books.txt: Dies liest unsere Liste von Klassikbüchern.
• |: Dieses Pipe-Symbol sendet die Ausgabe an xargs.
• xargs: Dies ist unser Befehl zum Erstellen und Ausführen von Befehlen aus der Standardeingabe.
• -n 2: Diese Option teilt xargs mit, dass es 2 Argumente (Büchertitel) pro Befehlsaufruf verwenden soll.
• -P 3: Diese Option teilt xargs mit, dass es bis zu 3 Prozesse parallel ausführen soll.
• sh -c 'echo "Processing batch: $0 $1"': Dies ist der Befehl, den xargs ausführen wird. Er verwendet eine Shell, um die Büchertitel auszugeben. $0 und $1 repräsentieren die beiden von xargs übergebenen Büchertitel.

Sie sollten eine Ausgabe ähnlich der folgenden 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 Batches verarbeiten können, während wir dennoch die parallele Verarbeitung nutzen. In diesem Fall verarbeiten wir die Bücher paarweise (aufgrund von -n 2) und führen bis zu drei dieser Paar-Verarbeitungsbefehle parallel aus (aufgrund von -P 3).

Der Vorteil dieses Ansatzes besteht darin, dass Sie Elemente in handhabbaren Teilen verarbeiten können (in diesem Fall Paare von Büchern), während Sie dennoch die parallele Verarbeitung nutzen, um den gesamten Vorgang zu beschleunigen. Dies kann besonders nützlich sein, wenn Sie mit großen Datensätzen arbeiten oder wenn Sie die Verarbeitungsgeschwindigkeit mit der Systemressourcenauslastung ausgleichen müssen.

In einem realen Szenario könnten Sie den echo-Befehl durch ein komplexeres Verarbeitungsskript ersetzen. Beispielsweise könnten Sie unser früheres process_book.sh-Skript so modifizieren, dass es gleichzeitig zwei Bücher verarbeitet, und es dann anstelle des echo-Befehls verwenden.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie den xargs-Befehl verwenden können, um Dateiverwaltungstasks zu automatisieren. Sie haben seine Grundnutzung untersucht, gelernt, wie Sie Dateien verarbeiten, Argumente begrenzen, parallele Verarbeitung durchführen und Optionen kombinieren können, um effiziente Batch-Verarbeitung durchzuführen. Diese Fähigkeiten werden unschätzbar sein, wenn Sie große Datenmengen verarbeiten oder repetitive Aufgaben in Ihrer Linux-Umgebung automatisieren müssen.

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

• -0: Verwenden Sie das Nullzeichen als Trennzeichen anstelle von Leerzeichen.
• -L: Verwenden Sie maximal max-lines nicht-leere Eingabezeilen pro Befehlszeile.
• -s: Verwenden Sie maximal max-chars Zeichen pro Befehlszeile.
• -r: Führen Sie den Befehl nicht aus, wenn die Standardeingabe leer ist.
• -a: Lesen Sie Elemente aus einer Datei anstelle der Standardeingabe.
• -E: Setzen Sie die EOF-Zeichenkette.

Denken Sie daran, dass die Stärke von xargs in seiner Flexibilität und seiner Fähigkeit besteht, mit anderen Linux-Befehlen zusammenzuarbeiten. Wenn Sie weiterhin mit Linux arbeiten, werden Sie viele weitere Situationen finden, in denen xargs Ihnen helfen kann, Aufgaben zu automatisieren und Ihre Produktivität zu steigern.