Linux xargs Befehl: Befehlsaufbau

Einführung

In diesem Lab werden Sie den leistungsstarken xargs-Befehl in Linux erkunden. Der xargs-Befehl ist ein vielseitiges Werkzeug, mit dem Sie Befehle aus der Standardeingabe erstellen und ausführen können. Er ist besonders nützlich für die Verarbeitung von Argumentlisten und deren Umwandlung in Befehlszeilen.

In diesem Lab werden wir das Konzept der "Buchverarbeitung" als Beispielaufgabe verwenden. Es ist wichtig zu beachten, dass "Buchverarbeitung" kein spezifischer Linux-Befehl ist, sondern ein Platzhalter für jede 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, also keine Sorge, wenn Sie neu in Linux-Befehlen sind – wir werden Sie sorgfältig durch jeden Schritt führen.

Das xargs-Kommando verstehen

Beginnen wir damit, die grundlegende Verwendung des xargs-Befehls zu verstehen und wann er ein nützliches Werkzeug ist. xargs ist besonders hilfreich, wenn Sie die Ausgabe eines Befehls als Argumente für einen anderen Befehl verwenden müssen. Dies ist in Shell-Skripten und Befehlszeilen-Workflows üblich.

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

Lassen Sie uns ein einfaches Beispiel verwenden, um zu demonstrieren, wie xargs mit Eingaben aus einer Datei funktioniert. Zuerst betrachten wir den Inhalt einer Datei, 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. Dies simuliert, dass jede Zeile der Datei genommen und 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 "Verarbeitungs"-Operation. Standardmäßig behandelt xargs jede Zeile als separates Argument und kombiniert sie zu einer einzigen Befehlsausführung.

Lassen Sie uns aufschlüsseln, was hier geschieht:

1. cat ~/project/fruits.txt liest den Inhalt der Datei.
2. Das Symbol | (Pipe) 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 sein kann als die separate Verarbeitung jedes Elements, insbesondere wenn der Zielbefehl mehrere Argumente verarbeiten kann. 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. Hier glänzt xargs – es schlägt die Brücke zwischen Befehlen, die Listen erzeugen, und Befehlen, die auf Argumenten operieren.

Dateien mit xargs verarbeiten

Aufbauend auf unserem Verständnis, wie xargs Eingaben entgegennimmt und als Argumente verwendet, wollen wir eine praktischere Anwendung untersuchen: die Verarbeitung von Dateien. Stellen Sie sich vor, Sie sind ein Bibliothekar, der mit der Organisation eines digitalen Archivs beauftragt ist. Sie haben eine Liste von Buchtiteln und müssen für jedes Buch leere Dateien erstellen. Während eine einfache for-Schleife dies tun könnte, bietet xargs eine Alternative, insbesondere wenn die Dateiliste von einem anderen Befehl (wie find) generiert werden könnte.

Lassen Sie uns xargs verwenden, um diesen Prozess der Erstellung von Dateien aus einer Liste zu automatisieren. Zuerst betrachten wir den Inhalt einer Datei, die einige Buchtitel enthält:

cat ~/project/books.txt

Sie sollten Folgendes sehen:

The_Great_Gatsby
To_Kill_a_Mockingbird
1984

Nun verwenden wir xargs mit dem Befehl touch, um leere Dateien für jedes Buch zu erstellen. Wir werden die Option -I einführen, die entscheidend ist, wenn Sie das Eingabeargument an einer 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: Dies liest den Inhalt unserer Buchlistendatei.
• |: 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 weist xargs an, Vorkommnisse von {} im Befehl durch jede Eingabezeile zu ersetzen. Dies ist besonders nützlich, wenn der Befehl, den Sie ausführen, das Eingabeargument in der Mitte oder am Ende benötigt, anstatt es nur am Ende anzuhängen.
• touch ~/project/{}.txt: Dies ist der Befehl, den xargs für jede Eingabezeile ausführt. Das {} wird durch jeden Buchtitel ersetzt, und .txt wird angehängt, um den Dateinamen zu erstellen.

Dieser Befehl verwendet die Option -I {}, um einen Platzhalter ({}) für jedes Eingabeelement anzugeben. Für jede Zeile in books.txt ersetzt xargs {} durch den Buchtitel und führt den Befehl touch aus, wodurch effektiv eine Datei erstellt wird, die nach dem Buchtitel mit der Erweiterung .txt benannt ist.

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 Buchtitel eine neue .txt-Datei erstellt, zusammen mit 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 leistungsstarken Werkzeug für die Dateimanipulation und -automatisierung macht.

Argumente mit xargs begrenzen

Wenn unsere digitale Bibliothek wächst, können wir auf Situationen stoßen, in denen der Befehl, den wir ausführen möchten, eine Begrenzung für die Anzahl der Argumente hat, die er akzeptieren kann, oder wir möchten einfach Elemente in kleineren Batches verarbeiten, um eine bessere Kontrolle oder Ressourcenverwaltung zu gewährleisten. Die Option -n von xargs ermöglicht es uns, die Anzahl der Argumente zu begrenzen, die an jede Befehlsausführung übergeben werden. Dies ist ein weiteres Szenario, in dem xargs eine detaillierte Kontrolle darüber bietet, wie Befehle basierend auf der Eingabe ausgeführt werden.

Werfen wir einen Blick auf eine Datei mit mehr Buchtiteln:

cat ~/project/more_books.txt

Sie sollten Folgendes 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 zu verarbeiten. Wir verwenden wieder echo, um die verarbeiteten Batches 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 geschieht:

• cat ~/project/more_books.txt: Dies liest den Inhalt unserer Buchlistendatei.
• |: Dieses Pipe-Symbol sendet die Ausgabe von cat an den nächsten Befehl.
• xargs -n 2: Dies weist xargs an, maximal 2 Argumente pro Befehlsausführung zu verwenden. Das bedeutet, dass xargs die Eingabezeilen in Gruppen von zwei zusammenfasst und den Zielbefehl für jede Gruppe ausführt.
• echo "Processing books:": Dies ist der Befehl, den xargs ausführen wird. 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 es eine ungerade Anzahl von Titeln gibt. Die Option -n ist nützlich, wenn Sie Elemente in bestimmten Gruppengrößen verarbeiten möchten, was hilfreich sein kann, um große Listen zu verwalten oder für Befehle, die eine Begrenzung für die Anzahl der Argumente haben, die sie verarbeiten können. Es bietet eine Möglichkeit, eine große Aufgabe in kleinere, besser handhabbare Unteraufgaben aufzuteilen, die vom selben Befehl ausgeführt werden.

Parallele Verarbeitung mit xargs

Da unsere Bibliothek weiter wächst, möchten wir unsere Dateiverarbeitung beschleunigen. Für Aufgaben, die unabhängig voneinander sind, kann die parallele Ausführung die gesamte Ausführungszeit erheblich reduzieren. Die Option -P von xargs ermöglicht es uns, mehrere Instanzen des Zielbefehls gleichzeitig auszuführen, was die Leistung für E/A-gebundene Operationen oder Aufgaben, die Wartezeiten beinhalten, erheblich verbessern kann. Dies ist ein wesentlicher Vorteil von xargs gegenüber der einfachen sequenziellen Verarbeitung mit einer for-Schleife.

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

cat ~/project/process_book.sh

Sie sollten Folgendes 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 Buchtitel als Argument ($1).
2. Es erstellt eine neue Datei mit dem Präfix "processed_" vor dem Buchtitel.
3. Es schreibt eine Nachricht in diese Datei, einschließlich des aktuellen Datums und der Uhrzeit.
4. Es wartet 2 Sekunden, um etwas 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 verwenden 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: Dies liest unsere Bücherliste.
• |: Dieses 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 {}: Dies 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 werden soll, wobei {} durch den Buchtitel ersetzt wird.

Dieser Befehl beginnt mit der gleichzeitigen Verarbeitung von bis zu 3 Büchern. 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 hindeutet. Die genauen Zeiten variieren, aber Sie könnten so etwas 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 mit der Verarbeitung beginnen und die letzten beiden etwa 2 Sekunden später (aufgrund von sleep 2 in unserem Skript). Dies demonstriert die parallele Verarbeitung in Aktion, ein erheblicher Vorteil der Verwendung von xargs zur Beschleunigung unabhängiger Aufgaben.

Kombinieren von xargs-Optionen

In realen Szenarien müssen Sie oft verschiedene xargs-Optionen kombinieren, um das gewünschte Verarbeitungsverhalten zu erzielen. Für unsere letzte Aufgabe werden wir untersuchen, wie wir unsere Bücher in Batches verarbeiten und gleichzeitig die parallele Verarbeitung nutzen können. Wir werden einen etwas anderen Ansatz als ursprünglich vorgeschlagen verwenden, um die gegenseitige Exklusivität der Optionen -n und -I zu vermeiden, wenn sie direkt mit einem einfachen Befehl verwendet werden. Stattdessen verwenden wir einen Shell-Befehl (sh -c) als Ziel für xargs, wodurch wir mehrere Argumente, die von -n übergeben werden, innerhalb des Shell-Skripts verarbeiten können.

Werfen wir einen Blick auf unsere Liste klassischer Bücher:

cat ~/project/classic_books.txt

Sie sollten Folgendes 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 von 2 mit bis zu 3 parallelen Prozessen zu verarbeiten. Wir verwenden sh -c, um einen einfachen Befehl auszuführen, der den verarbeiteten Batch 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: Dies liest unsere Liste klassischer Bücher.
• |: 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 weist xargs an, 2 Argumente (Buchtitel) pro Befehlsausführung zu verwenden. Diese beiden Argumente werden an den Befehl sh -c übergeben.
• -P 3: Diese Option weist xargs an, bis zu 3 Prozesse parallel auszuführen. Jeder Prozess führt den Befehl sh -c mit einem Batch von 2 Buchtiteln aus.
• sh -c 'echo "Processing batch: $@"' _: Dies ist der Befehl, den xargs ausführen wird.
  • sh -c: Führt eine Befehlszeichenfolge mit der Shell aus.
  • 'echo "Processing batch: $@"': Die auszuführende Befehlszeichenfolge. $@ innerhalb des Shell-Skripts wird zu allen Positions-Parametern erweitert, die an das Skript übergeben werden, was in diesem Fall die von xargs bereitgestellten Argumente sind (die beiden Buchtitel).
  • _: Dies ist ein Dummy-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 hat keinen Einfluss auf die Ausgabe, wenn $@ verwendet wird.

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 demonstriert, wie wir eine große Anzahl von Elementen in Batches effizient verarbeiten und gleichzeitig die Vorteile der parallelen Verarbeitung nutzen können. In diesem Fall verarbeiten wir Bücher paarweise (aufgrund von -n 2) und führen bis zu drei dieser paarweise verarbeitenden Befehle parallel aus (aufgrund von -P 3).

Der Vorteil dieses Ansatzes besteht darin, dass Sie Elemente in handhabbaren Teilen (in diesem Fall Buchpaare) verarbeiten und gleichzeitig die parallele Verarbeitung nutzen können, um den Gesamtbetrieb zu beschleunigen. Dies kann besonders nützlich sein, wenn Sie mit großen Datensätzen arbeiten oder wenn Sie die Verarbeitungsgeschwindigkeit mit der Nutzung von Systemressourcen in Einklang bringen müssen. Durch die Verwendung von sh -c können wir die von -n übergebenen mehreren Argumente effektiv innerhalb einer einzigen Befehlsausführung verarbeiten, wodurch xargs zu einem flexiblen Werkzeug für komplexe Verarbeitungs-Workflows wird. In einem realen Szenario könnten Sie den echo-Befehl durch ein komplexeres Verarbeitungsskript ersetzen, das für die Verarbeitung eines Batches von Elementen konzipiert ist.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie den Befehl xargs verwenden, um Aufgaben der Dateiverwaltung zu automatisieren. Sie haben seine grundlegende Verwendung erkundet, gelernt, 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 verarbeiten oder sich wiederholende 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 der Datei anstelle der Standardeingabe
• -E: Setzen Sie die EOF-Zeichenkette

Denken Sie daran, die Stärke von xargs liegt in seiner Flexibilität und seiner Fähigkeit, 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.