Bash Xargs kommandieren auf die harte Tour mit gutem Beispiel

Wenn Sie gerade erst anfangen, die Bash-Programmierung auf die harte Tour zu lernen, erzählt Ihnen niemand etwas über den Befehl xargs. Seitdem hast du es geschafft, genug Xargs aufzusammeln, um durchzukommen, ohne zu viel zu brechen. Jetzt fragst du dich ― Was ist mit all den anderen Optionen? Darf ich das machen? Was ist, wenn ich möchte… ?

Inzwischen haben Sie wahrscheinlich ein gutes Verständnis dafür, wie man Befehle in bash ausführt. Aber was ist, wenn Sie Befehlsströme nacheinander oder manchmal parallel ausführen möchten?? Hier finden wir uns mit xargs.

Hier hoffen wir, all diese Fragen und mehr zu bash und dem xargs-Befehl beispielhaft beantworten zu können.

Was ist xargs in bash?

xargs ist ein externer Befehl, der verwendet wird, um Konvertieren Sie die Standardeingabe in Befehlszeilenargumente das soll für „erweiterte Argumente“ stehen.” Es wurde hauptsächlich für die Verwendung mit Befehlen entwickelt, die nicht für die Verarbeitung von Pipe-Eingaben oder Standardeingaben wie rm, cp, echo erstellt wurden ¹ und andere externe Befehle akzeptieren nur Argumente als Parameter.

¹ Obwohl die meisten Systeme mit einem echo-Befehl ausgestattet sind, ist echo eine eingebaute Bash; Das heißt, es sei denn, das Kommando echo wird aufgerufen, das eingebaute Echo wird verwendet. In ähnlicher Weise erkennen Bash-Build-Ins keine Pipe-Eingabe.

Xargs-Optionen mit Bash-Beispielen

Lassen Sie uns xargs und seine Optionen mit Beispielen in der bash durchgehen. Neben der herkömmlichen Behandlung von Befehlszeilenoptionen, die von xargs erwartet werden, werden die Optionen nach Objekten gruppiert, z. B. zum Abrufen von Informationen oder zum Ändern des Verhaltens.

Xargs-Info

Hier sind Optionen mit Informationen zu xargs.

Xargs-Hilfe

xargs --help
Verwendung: xargs [OPTION]… COMMAND [INITIAL-ARGS]…
Führen Sie COMMAND mit den Argumenten INITIAL-ARGS und weiteren Argumenten aus, die aus der Eingabe gelesen werden.
Obligatorische und optionale Argumente für lange Optionen sind ebenfalls
obligatorisch oder optional für die entsprechende Kurzoption.
-0, --null                   Elemente werden durch eine Null und kein Leerzeichen getrennt;
deaktiviert die Verarbeitung von Anführungszeichen und umgekehrten Schrägstrichen und
logische EOF-Verarbeitung
-a, --arg-file=DATEI          Argumente aus DATEI lesen, keine Standardeingabe
-d, --delimiter=CHARACTER    Elemente im Eingabestream werden durch CHARACTER . getrennt,
nicht durch Leerzeichen; deaktiviert Anführungszeichen und Backslash
Verarbeitung und logische EOF-Verarbeitung
-E END                       logischen EOF-String festlegen; wenn END als Zeile auftritt
der Eingabe, der Rest der Eingabe wird ignoriert
(wird ignoriert, wenn -0 oder -d angegeben wurde)
-e, --eof[=END]              entspricht -E END, wenn END angegeben ist;
andernfalls gibt es keine Datei-Ende-Zeichenfolge
-I R                         wie --replace=R
-i, --replace[=R]            Ersetze R in INITIAL-ARGS durch gelesene Namen names
von Standardeingabe; wenn R nicht spezifiziert ist,
annehmen
-L, --max-lines=MAX-LINES    höchstens MAX-LINES nicht-leere Eingabezeilen pro . verwenden
Befehlszeile
-l[MAX-LINES]                ähnlich wie -L, aber standardmäßig höchstens eins non-
leere Eingabezeile, wenn MAX-LINES nicht angegeben ist
-n, --max-args=MAX-ARGS      höchstens MAX-ARGS-Argumente pro Befehlszeile verwenden
-P, --max-procs=MAX-PROCS    die meisten MAX-PROCS-Prozesse gleichzeitig ausführen
-p, --interactive            Eingabeaufforderung vor dem Ausführen von Befehlen
--process-slot-var=VAR   Umgebungsvariable VAR in untergeordneten Prozessen festlegen
-r, --no-run-if-empty        Wenn keine Argumente vorhanden sind, führen Sie COMMAND nicht aus;
Wenn diese Option nicht angegeben ist, ist COMMAND
mindestens einmal laufen
-s, --max-chars=MAX-CHARS    Länge der Befehlszeile auf MAX-CHARS begrenzen
--show-limits            Grenzen für die Befehlszeilenlänge anzeigen
-t, --verbose                Befehle ausgeben, bevor sie ausgeführt werden
-x, --exit                   beenden, wenn die Größe (siehe -s) überschritten wird
--help                   diese Hilfe anzeigen und beenden
--version                Versionsinformationen ausgeben und beenden

Lesen Sie die xargs-Hilfe als Kurzreferenz zur Verwendung und den Optionen von xargs.

Xargs-Version

xargs --version
xargs (GNU findutils) 4.6.0

Xargs-Grenzen

Auch xargs hat seine Grenzen. Die Option -show-limits für xargs zeigt Grenzwerte an, die von xargs verwendet werden, bevor die Befehle ausgeführt werden. Die tatsächlichen Grenzen hängen von Ihrer Umgebung ab. Für die meisten Benutzer reicht dies jedoch aus. Die Grenzen können über die Kommandozeile angepasst werden, siehe Beispiele.

Beispiel) Ihre Umgebung xargs-Grenzwerte

xargs --show-limits
Ihre Umgebungsvariablen belegen 6234 Byte
POSIX-Obergrenze der Argumentlänge (dieses System): 23718
POSIX kleinste zulässige Obergrenze der Argumentlänge (alle Systeme): 4096
Maximale Befehlslänge, die wir tatsächlich verwenden könnten: 17484
Größe des tatsächlich verwendeten Befehlspuffers: 23718
Maximale Parallelität (--max-procs darf nicht größer sein): 2147483647

Die Ausführung von xargs wird jetzt fortgesetzt und versucht, seine Eingabe zu lesen und Befehle auszuführen; Wenn dies nicht der Fall ist, geben Sie bitte den Tastenanschlag für das Dateiende ein.

Achtung: echo wird mindestens einmal ausgeführt. Wenn Sie das nicht möchten, drücken Sie die Unterbrechungstaste.

Beachten Sie, dass der Befehl, der als Folge von xargs ausgeführt wird, echo ist, der Standardbefehl von xargs.

Beispiel) Xargs-Grenzen mit angepasster Befehlspuffergrenze

xargs --show-limits -s 1
Ihre Umgebungsvariablen belegen 9479 Byte
POSIX-Obergrenze der Argumentlänge (dieses System): 20473
POSIX kleinste zulässige Obergrenze der Argumentlänge (alle Systeme): 4096
Maximale Befehlslänge, die wir tatsächlich verwenden könnten: 10994
Größe des Befehlspuffers, den wir tatsächlich verwenden: 1
Maximale Parallelität (--max-procs darf nicht größer sein): 2147483647
…
Achtung: echo wird mindestens einmal ausgeführt. Wenn das nicht passieren soll,
Drücken Sie dann die Unterbrechungstaste.
xargs: Ein einzelnes Argument kann nicht in die Größenbeschränkung der Argumentliste passen

Beachten Sie, dass unten nach Warnungen, falls vorhanden, Fehler angezeigt werden. Wir haben einen Fehler " xargs: kann einzelnes Argument nicht in die Größenbeschränkung der Argumentliste passen", was nur bedeutet, dass wir versuchen, außerhalb der zulässigen Befehlspuffergröße zu arbeiten, die auf ein Zeichen festgelegt ist.

Der Befehlspuffer enthält den Befehl gefolgt von allen Argumenten einschließlich Leerzeichen.
Im Fall des Befehls in diesem Beispiel der xargs-Option ist der Befehlspuffer buffer

"Echo"

die 4 Zeichen enthält.
Also müssen wir die Befehlspuffergröße wie folgt auf einen Wert größer oder gleich 5 setzen. Beachten Sie, dass der Verbrauch des Befehlspuffers length_of_command + length_args_inklusive_spaces_plus_one + 1 . entspricht.

xargs --show-limits -s 5

# Nicht mehr "xargs: kann kein einzelnes Argument in die Größenbeschränkung der Argumentliste passen" Error

Aber was ist, wenn unser Befehl Argumente hat??

ja | xargs -t --show-limits -t -s 6 # wird mit der folgenden Ausgabe ausgeführt
Echo du
…

Xargs ausführlich

links | xargs -t other_xargs_options_if_any | rhs

Die Option -t kann verwendet werden, um von xargs ausgeführte Befehle als Ausgabe an fd2 anzuzeigen, Standardfehler. Das heißt, xargs -t kann aufgehoben werden, indem der Standardfehler wie folgt nach /dev/null umgeleitet wird.

xargs -t 2>/dev/null

Beispiel) Ja einmal

ja | Kopf -n 5 | xargs -t wahr
wahr y y y y y

Beispiel) Ja 5 mal

ja | Kopf -n 5 | xargs -t -I wahr
wahr y
wahr y
wahr y
wahr y
wahr y

Xargs-Verhalten

Kein Befehl ist ohne Optionen zum Ändern des Laufzeitverhaltens vollständig. Xargs ist nicht anders. Hier sind die Optionen, mit denen Sie das Verhalten ändern können.

Xargs null

links | xargs -0 other_xargs_options_if_any | rhs

Die Option -0 kann verwendet werden, um xargs anzuweisen, null anstelle von Leerzeichen zu verwenden. Es deaktiviert auch Anführungszeichen und Escape-Sequenzen.

Xargs-Null-Anwendungsfall

Die für xargs null vorgesehene Verwendung ist für die Behandlung von Fällen vorgesehen, z. B. wenn Elemente Leerzeichen enthalten, z. B. Dateien mit Leerzeichen oder Zeilenumbrüchen.

Angenommen, Sie haben ein Verzeichnis „a b c“ mit Leerzeichen in einem Verzeichnisnamen.

ls "a b c"
de/ fg/ h/ 'i j k l'/

Sie möchten einen Befehl für jedes Verzeichnis in „a b c“ mit dem Befehl find ausführen.

Sie können Folgendes versuchen:

finde "a b c" -typ d | xargs du -d 0 -h
du: kann nicht auf 'a' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'b' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'c' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'a' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'b' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'c/de' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'a' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'b' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'c/fg' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'a' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'b' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'c/h' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'a' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'b' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'c/i' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'j' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'k' zugreifen: Keine solche Datei oder kein Verzeichnis
du: kann nicht auf 'l' zugreifen: Keine solche Datei oder kein Verzeichnis

Es funktioniert falsch, weil unsere Verzeichnisnamen mit Leerzeichen übersät sind. Das war nicht deine Absicht.

Sie können dies beheben, indem Sie xargs-Ersatz hinzufügen, d.e -I wie folgt.

finde "a b c" -typ d | xargs -i du -d 0 -h
0       a b c
0       a b c/de
0       a b c/fg
0       a b c/h
0       a b c/i j k l

Es funktioniert korrekt, wenn xargs Replacement verwendet wird. Beachten Sie, dass wir -i verwendet haben, was eine Abkürzung für -I ist.

Eine andere Möglichkeit, das gleiche Ergebnis zu erzielen, ist die Verwendung von xargs null, -null in Kombination mit der find -print0-Option wie folgt.

finde "a b c" -type d -print0 | xargs --null -i du -d 0 -h
0       a b c
0       a b c/de
0       a b c/fg
0       a b c/h
0      a b c/i j k l

Groß! Jetzt haben wir mehr als eine Möglichkeit, uns tief in das Dateisystem-Universum einzudringen, ohne uns Sorgen machen zu müssen, dass wir auf unserer Reise mit Weltraumschrott kollidieren. Direkt am.

Xargs interaktiv

Vielleicht vertrauen Sie xargs nicht, alle Befehle ohne Bestätigung auszuführen without. In diesem Fall ist xargs interactive oder -p die Option, die Sie wie folgt steuern müssen, welche Befehle von xargs ausgeführt werden.

finde "a b c" -type d -print0 | xargs --null -i -p du -d 0 -h
du -d 0 -h a b c ?…
du -d 0 -h a b c/de ?…
du -d 0 -h a b c/fg ?… ja
0 a b c/fg
du -d 0 -h a b c/h ?… Ja
0 a b c/h
du -d 0 -h a b c/i j k l ?… Nein

Hier wird jeder Befehl ausgeführt, der mit 'y' oder 'Y' beginnt. Andernfalls werden Befehle ignoriert.

Xargs-Datei

Sie haben bereits eine Datei, arg-Datei, die in xargs eingelesen werden kann. Ihr Programm wartet möglicherweise irgendwo in einem Verzeichnis darauf, dass jemand anderes oder eine andere Instanz von Ihnen eine arg-Datei ablegt. In diesem Fall können Sie die Datei als Option für xargs mit -a arg-file angeben, anstatt cat file | cat verwenden zu müssen xargs… Xargs-Dateibeispiele folgen.

Lassen Sie uns zum Spaß Ihre Desktop-Bereinigungsroutinen in eine Arg-Datei umwandeln, die wir verwenden können.

ls cleanup-desktop | tee arg-Datei
190605_cleanup_desktop_files_sh.TXT
190605_cleanup_desktop_lnk_files_sh.TXT
190605_cleanup_desktop_un_files_sh.TXT

Jede Datei enthält eine Routine, die mit bash ausgeführt werden kann. Das heißt, der Befehl, den wir verwenden werden, ist bash.

Lassen Sie uns die Bereinigungsroutinen mit xargs ausführen.

xargs -a arg-Datei -i -P 99 bash -c ' echo ; . bereinigung-desktop/ ; '
190605_cleanup_desktop_files_sh.TXT
190605_cleanup_desktop_lnk_files_sh.TXT
190605_cleanup_desktop_un_files_sh.TXT

Und es funktioniert!
Nur für den Fall, dass wir eine arg-Datei angeben müssen, anstatt eine Pipe-Eingabe zu verwenden, ist die Dateioption xargs praktisch.

Xargs ersetzen

lhs_if_any | xargs -i other_args_etc | rhs_if_any

Zu guter Letzt können Sie mit xargs replace -i die volle Kontrolle über das Befehlsformat übernehmen, bevor es ausgeführt wird. Jedes Zeichen kann verwendet werden. Gemäß der Konvention verwenden die meisten Bash-Programmierer jedoch dieses oder dieses %. Beachten Sie, dass die Standardeinstellung ist. -Ich sage xargs, dass Sie die Standardeinstellung verwenden werden. Und es gilt als Kurzschrift. -Ich gefolgt von einem Ersatzzeichen Ihrer Wahl sagt xargs, welches Zeichen Sie verwenden werden. Vermeiden Sie gängige Zeichen wie den Buchstaben a. Das wird Ihren Code mehr brechen als jedes Leerzeichen oder jede neue Zeile.

Xargs parallel

lhs_if_any | xargs -P n_ge_1 other_args_etc | rhs_if_any

Xargs parallel -P ermöglicht die gleichzeitige Ausführung von Befehlen statt nacheinander. Siehe xargs limits -show-limits für gültige Argumente für n_ge_1 oder Parallelität. Zum Beispiel, wenn

Maximale Parallelität (--max-procs darf nicht größer sein): 2147483647

Sie können -P 2147483647 ohne Fehler einstellen. In der Praxis finden Sie möglicherweise eine schönere Einstellung wie -P 99, die die Gesamtleistung verbessert, ohne den Aufwand für die Verwaltung gleichzeitiger Prozesse zu erhöhen.

Es folgen Beispiele, die zeigen, wie die Verwendung von xargs parallel die Leistung verbessern kann.

Beispiel) Zählen in Sequenz versus parallel mit xargs

Mal sehen, was passiert, wenn wir mit xargs nacheinander zählen time.

Zeitecho 1… 1000 | xargs '-d ' -i bash -c 'echo '
…
998
999
1000
echt    1 m13 .927s
Nutzer    0 m6 .994s
sys     0m15.184s

Sehen Sie nun, was passiert, wenn wir mit xargs parallel die Zeit zählen.

Zeitecho 1… 1000 | xargs -P 200 '-d ' -i bash -c 'echo '
…
998
999
1000
echt    0m13.554s
Nutzer    0 m6 .446s
sys     0m14.293s

Eine signifikante Leistungssteigerung wird beobachtet, wenn xargs parallel verwendet wird, um einfache Befehle ohne gemeinsame Ressourcen auszuführen.

Beispiel) Vergleich der Reihenfolge und des Timings von xargs parallel

Mal sehen, was passiert, wenn ein Befehl CPU-Zeit verbraucht.

Zeitecho 1… 10 | xargs '-d ' -i bash -c 'schlafen $(( $RANDOM % 2 )) ; Echo '
1
2
3
4
5
6
7
8
9
10
echt    0m5.601s
Benutzer    0m0.180s
sys     0m0.334s

Beachten Sie, dass alle Befehle der Reihe nach abgeschlossen sind.

Sehen Sie jetzt, was passiert, wenn derselbe Befehl parallel ausgeführt wird.

Zeitecho 1… 10 | xargs -P 10 '-d ' -i bash -c 'schlafen $(( $RANDOM % 2 )) ; Echo '
3
4
6
7
8
1
2
5
9
10
echt    0m1.257s
Benutzer    0m0.060s
sys     0m0.225s
Befehle 1, 2, 5 und 9 gingen schlafen. Allerdings konnten wir die
Zeit bis zum Abschluss um bis zu 78 Prozent.

Xargs paralleles Fazit

Einfaches Hinzufügen von xargs parallel als Befehlszeilenoption kann die Leistung verzehnfachen. Sie sollten jedoch vorsichtig vorgehen, wenn Sie auftragsabhängige Prozeduren verwenden oder wenn Befehle Ressourcen gemeinsam nutzen.

Xargs-Trennzeichen

lhs_if_any | xargs '-dc' other_args_etc | rhs_if_any

Mit Xargs delimiter -d können Sie das Elementtrennzeichen auf ein beliebiges Zeichen c setzen, genauso wie Trennzeichen im Cut-Befehl festgelegt werden.

Standardmäßig ist -dc auf Leerzeichen gesetzt, das durch das Zeilenumbruchzeichen -d\x0a . erzeugt wird.
Bei Verwendung von xargs null -0 wird -dc auf das Nullzeichen -d\x00 . gesetzt.

Zum Beispiel können Sie das Trennzeichen auf ein Leerzeichen setzen, d.h.e. -dc ist '-d ' in einer Befehlszeile oder Ihrem Bash-Skript.

Sie können das Trennzeichen auf das Komma setzen, d.h.e. -dc ist '-d'.

Mit der Trennzeichenoption in xargs -d können Sie das Elementtrennzeichen auf ein beliebiges Zeichen setzen.

Bash xargs-Beispiele

Hier behandeln wir Beispielanwendungen des xargs-Befehls in der bash, einschließlich der Beispielanwendung in der Befehlszeile sowie Skripts.

Beispiele für Bash xargs-Befehle

Hier behandeln wir Befehlszeilen-Beispielanwendungen des xargs-Befehls in bash, einschließlich der Beispielanwendung mit und ohne Pipe-Eingabe.

Beispiel) Machen Sie Ihren eigenen Input: Spaß mit xargs ohne Input

Was macht xargs allein zu Hause??

xargs
Hallo, ist jemand zu Hause?
…
(Strg-D)
Hallo, ist jemand zu Hause?…

Es scheint, als hätten wir unsere Frage als Antwort zurückbekommen, aber es scheint nur ein Echo zu sein.

Warum?

Wie Sie vielleicht in xargs gelesen haben, konvertiert es Standardeingaben in Befehlszeilenargumente. Wenn keine Optionen und Argumente angegeben werden, verhält es sich wie ein Pipe-Aware-Echo-Befehl. Das ist:

xargs
Hallo, ist jemand zu Hause?
…
(Steuerung-D) 2

Erzeugt implizit den entsprechenden echo-Befehlszeilenausdruck expression

hallo hallo, ist jemand zu hause?…
2 In einem Skript kann Heredoc wie folgt verwendet werden.
xargs << EOF
Hallo, ist jemand zu Hause?
…
EOF
hallo hallo, ist jemand zu hause?…

Beispiel) Verwenden Sie xargs als Platzhalter für interaktive Rohre

Die Verwendung von xargs auf der linken Seite einer Pfeife ist paradox⁴also lass uns bash im super eingeschränkten Modus laufen lassen⁵.

⁴ Pipe-fähige Befehle benötigen keine xargs. Pipe-unbewusste Befehle wissen nichts über xargs

⁵ Eingeschränkter Modus, der jede Zeile zurücksetzt. Andere Einschränkungen können später hinzugefügt werden.

xargs -I bash -cr ""
i=1
echo $i
hallo hallo!
Hallo!
!!
Schlag: !!: Befehl nicht gefunden
i=1; echo $i
1
CD…
bash: Zeile 0: cd: eingeschränkt

Beispiel) Verwenden Sie xargs als Platzhalter für interaktive Argumente

Laut dem HackerRank Developer Skills Report 2019³, „Rechner sind die neuen Spiele.„Immer mehr Entwickler unter 38 Jahren forcieren Taschenrechner als ihr erstes Codierungsprojekt. ³ Erkenntnisse basierend auf 71.281 Entwicklern

Also bauen wir einen Taschenrechner mit xargs!

_() echo $(( "$@" )) ; # Taschenrechner
während:
tun
_ $(xargs)
getan
1 + 2 + 3 + 4
(Strg-D)
10
1 - 2 + 3 - 4 + 5
(Strg-D)
3
1**2+2**2
(Strg-D)
3
1+
2+
3+
4+
5
(Strg-D)
fünfzehn

Beispiel) Statischer Site-Generator

Angenommen, Sie haben ein paar tausend Nur-Text-Dateien, die Sie verwenden möchten, um eine statische Site zu erstellen, und keine der Dateien heißt index. Dateinamen enthalten ASCII-Kleinbuchstaben und einen Bindestrich, falls vorhanden.

So würden ein oder zwei Zeilen im Terminal einer theoretischen Maschine aussehen, die Bash ausführt. Die Maschine verfügt über andere externe Befehle, einschließlich findutils und pandoc. Sie können jeden gleichwertigen Befehl Ihrer Wahl verwenden use.

# wir sind im Verzeichnis
# viele Dateien sehen

test -d "html" || mkdir -v $_
finden . -min.Tiefe 1 -max.Tiefe 1 -Typ f \
| xargs -P 6000 -i bash -c "echo ; cat | sed -e 's/$/ /' |
pandoc -thtml -o .html"

# sehen Sie jetzt doppelt so viele Dateien, einschließlich HTML-Dateien
# getan

Bash xargs-Skriptbeispiele

Beispiel) Verwenden Sie xargs, um quadratische Matrizen zu generieren

Hier ist ein Skript, das ich erstellt habe, um quadratische Matrizen mit xargs zu generieren. Insbesondere nutzt es das Verhalten mit der Option -n und verwendet den Befehl seq, um Zahlenfolgen in Matrizen zu verwenden.

#!/bin/bash
## quadratische Matrix
## - erzeugt quadratische Matrizen
##-Version 0.0.1 - Initiale
##################################################
quadratmatrix-hilfe()

Katze << EOF
quadratische Matrix
1 - bestellen
BEISPIELE
> Quadrat-Matrix 1
1
> Quadrat-Matrix 2
1 2
3 4
> Quadrat-Matrix 3
1 2 3
4 5 6
7 8 9
EOF

quadratmatrix () local -i order ; Bestellung=$1 ;
teste "$order" || $FUNCNAME-Hilfe ; Rückkehr ;
test $order -gt 0 || $FUNCNAME-Hilfe ; Rückkehr ;
_()
seq $(( $1 ** 2 )) | xargs -n $1

_ $Bestellung

##################################################
wenn [ ! ]
dann
wahr
sonst
Ausfahrt 1 # falsche Argumente
fi
##################################################
quadratische Matrix $@
##################################################
## generiert von create-stub2.sch v0.1.2
## am Mi, 29 Mai 2019 13:44:06 +0900
## sehen
##################################################

Quelle: Quadrat-Matrix.Sch

Ich habe auch ein Testprogramm hinzugefügt, um das Skript in Aktion zu zeigen und alle quadratischen Matrizen bis zu 10 x 10 . zu generieren.

#!/bin/bash
## Test-Quadrat-Matrix
## - erzeugt quadratische Matrizen bis zu 10 x 10
##-Version 0.0.1 - Initiale
##################################################
Test-Quadrat-Matrix ()
test -f "Quadrat-Matrix".Sch"
. $_ 1>/dev/null
lokal ich
für i in 1… 10
tun
echo "Quadrat-Matrix($i)"
quadratische Matrix $i
getan

##################################################
if [ $# -eq 0 ]
dann
wahr
sonst
Ausfahrt 1 # falsche Argumente
fi
##################################################
Test-Quadrat-Matrix
##################################################
## generiert von create-stub2.sch v0.1.2
## am Mi, 29 Mai 2019 13:40:08 +0900
## sehen
##################################################

Quelle: Testfeld-Matrix.Sch

Hier ist, was Sie erwartet:

Bash-Test-Quadrat-Matrix.sch | Kopf
Quadrat-Matrix(1)
1
Quadrat-Matrix(2)
1 2
3 4
Quadrat-Matrix(3)
1 2 3
4 5 6
7 8 9
…

Übung: Verbessern Sie die Anzeige im Terminal, indem Sie Zahlen auffüllen

Wenn wir versuchen, die quadratische Matrix der Ordnung 10 mal 10 zu erzeugen, erhalten wir die folgende Ausgabe:

bash quadratmatrix.sch 10
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70
71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 100

Als Übung erweitern Sie die Quadrat-Matrix.sh, um die Ausgabe wie folgt zu ermöglichen.

bash quadratmatrix.sch 10
001 002 003 004 005 006 007 008 009 010
011 012 013 014 015 016 017 018 019 020
021 022 023 024 025 026 027 028 029 030
031 032 033 034 035 036 037 038 039 040
041 042 043 044 045 046 047 048 049 050
051 052 053 054 055 056 057 058 059 060
061 062 063 064 065 066 067 068 069 070
071 072 073 074 075 076 077 078 079 080
081 082 083 084 085 086 087 088 089 090
091 092 093 094 095 096 097 098 099 100

Bash xargs praktische Anwendungsbeispiele

Beispiel) Durchsuchen von Dateien nach einem Muster mit xargs grep

Listen-Dateien¹ | xargs grep -e Muster

¹ list-files ist ein Befehl, der Kandidatenpfade zu einer Datei zurückgibt, die als Eingabe für grep über den xargs-Befehl verwendet werden soll

Als praktisches Anwendungsbeispiel für xargs in bash habe ich xargs aus einer geheimen Codebasis ausgegraben.

find -type f -name \*.sch | wc -l
994

Es gibt 994 Bash-Skripte. Mal sehen, wie viele der xargs-Befehl.

find -type f -name \*.sch | xargs grep -e xargs listet alle Vorkommen auf
von xargs in der Codebasis.
…
find -type f -name \*.sch | xargs grep -e xargs | wc -l
18

Es gibt 18 Übereinstimmungen für xargs in der Codebasis. Jetzt möchten wir vielleicht herausfinden, wie viele Skripte xargs verwenden.

Groß! Es gibt 10 Skripte mit xargs in der Codebasis. Mal sehen, was sie sind.

find -type f -name \*.sch | xargs grep -e xargs | Schnitt '-d:' '-f1' | sortieren | einzigartig
vim $( !! )

Zusammenfassung der Ergebnisse

- Suchen und zerstören Sie Dateien, die ein Muster im Dateinamen enthalten

find $path -type f -name \*$pattern\* | xargs rm -vf

- Listen Sie Informationen über Dateien auf der linken Seite der Pipe auf

find-Dateien | xargs ls -al

- Dateien ausführbar machen

find-Dateien | xargs chmod +x

- Dateiverzeichnisse auflisten

find-Dateien | xargs -I dirname ""

- Alles löschen

Pfade zur Säuberung | xargs rm -rvf

- Zip-Dateien

find-files-to-zip | xargs -I Archiv-$( Datum +%s )

- Dateibasisnamen auflisten

find-Dateien | xargs -I Basisname

Beispiel) Installieren Sie Software aus einer Liste mit apt-get in Ubuntu

Wenn Sie Ubuntu aktualisieren, müssen Sie nach der Sicherung Ihres Systems möglicherweise neue Software installieren install. Angenommen, Sie haben eine Liste von Software, die Sie mit apt-get in Ubuntu installieren möchten.

sudo dpkg --get-selections | grep '[[:space:]]install$' |
\awk 'print $1' > install_software
#…
cat install_software | xargs sudo apt-get install

Beispiel) Curl seige mit xargs in bash

Angenommen, Sie haben eine Reihe von URLs, die zu einem einzelnen Knoten irgendwo im Internet führen, und Sie möchten mit curl in bash besetzen. Vorzugsweise ist dies einer Ihrer Knoten und die Belagerung befindet sich nicht in Ihrer Produktionsumgebung. So legen wir mit xargs in bash die Belagerung an.

#declare -f Filter
filtern ()

grep -o -e 'loc[^<]*' | cut '-d>' '-f2'

get-arg-file()

curl https://linuxhint.com/sitemap.xml --silent \
| filtern \
| xargs -i curl --silent \
| filtern \
| xargs -i echo > arg-Datei

#declare -f curl
locken ()

echo (falsch) $FUNCNAME "$@"

deklariere -xf curl
Nutzlast()

test -f "arg-Datei" || Rückkehr
xargs -P 1000 -a arg-file -i echo curl | bash 1>/dev/null

seige ()

test -f "arg-Datei" || hol-$_
Nutzlast

belagern

Bash xargs debuggen

Wenn du vor dem Terminal sitzt, bist du der Boss. Wenn jedoch etwas schief geht, hilft es, wenn Sie wissen, wie man Bash-Skripte tatsächlich wie ein Boss debuggt.

Es wird dringend empfohlen, auf Nummer sicher zu gehen und eine Methode zur Validierung des Erfolgs bei der Verwendung von xargs in bash zu haben, anstatt blind zu erwarten, dass alles in Ordnung ist. Das heißt, Sie müssen sicherstellen, dass alle Befehle mit Erfolg und Misserfolg nicht deaktiviert sind.

Methoden

Größe der Standardfehlerausgabe
Wenn der Standardfehler 1 oder mehr Zeichen enthält, ist ein Fehler aufgetreten
Summe der Befehls-Exit-Codes
Wenn die Summe der Exit-Codes größer als 0 ist, ist etwas schief gelaufen
Nutzlastvalidierung
Wenn ein Stück der Nutzlast fehlt, ist etwas schief gelaufen
Ende der Skriptvalidierung
xargs-Befehle als Skript ausführen, wenn das Ende des Skripts nicht erreicht wird, ist ein Fehler aufgetreten. Beachten Sie, dass errexit gesetzt ist und Befehle innerhalb einer Funktion ausgeführt werden.
Andere Methode
Wenn das Ergebnis von den Erwartungen abweicht, ist möglicherweise etwas schief gelaufen

Beispiel) Debuggen von xargs mithilfe der Größe der Standardfehlerausgabe

Hier ist eine anonyme Funktion, die wir beim Debuggen von xargs mit stardart error testen.

# deklariere -f _, i.e. Ich habe den Code unten nicht geschrieben
# Wenn Sie feststellen, dass Sie ein wenig eingerostet sind, erklären Sie, dass ich ein weiteres Tutorial geschrieben habe
#
So funktioniert der Deklaration-Befehl in bash
_ ()

rm -vf-Fehler;
Berühren Sie $_;
Echo 1… 10 | xargs -x -P 10 '-d ' -i bash -c "test $(( $RANDOM % $1 )) -eq 0 ||
Echo 1>&2 ; Ausfahrt ; ; echo " 2> Fehler;
Prüfung ! $( WC < errout -c ) -gt 0 || echo something went wrong…

## Prüfung
_ 1 # Ausfallwahrscheinlichkeit (=1-1/1=0%)
_ 2 # Ausfallwahrscheinlichkeit (=1-1/2=1/2=50%)
_ 3 # Ausfallwahrscheinlichkeit (=1-1/3=2/3=60%)
…

Wenn Sie den Standardfehler für nichts anderes verwenden, ist die Verwendung der Größe des Standardfehlers zum Debuggen von xargs eine Methode, die für Sie funktionieren könnte.

Bash xargs-Funktionen

Manchmal möchten Sie Funktionen verwenden, die Sie in xargs definiert haben. Dazu müssen wir xargs die Funktion zur Verfügung stellen. Hier ist, wie.

#deklarieren -f _
_ ()

echo $@^^

echo a… z1… 9 | xargs '-d ' -i bash -c "_ "
bash: _: Befehl nicht gefunden
…
deklariere -xf_
echo a… z1… 9 | xargs '-d ' -i bash -c "_ "
A1
A2
A3
…
# oder
echo a… z1… 9 | xargs '-d ' -i echo "_ " | bash
…
Z7
Z8
Z9

Beachten Sie, dass das obige interaktive Sitzungsbeispiel mit bash xargs parallel beschleunigt werden kann.

Fazit

Xargs ist einer der vielen externen Befehle, die Sie in bash besser kennen sollten. Beim Schreiben dieser Anleitung zum Befehl xargs habe ich selbst einige zusätzliche Optionen gelernt. Es wird empfohlen, von Zeit zu Zeit zu überprüfen. Nur dann können Sie xargs zu seinem wahren Potenzial nutzen. Bis dahin Code an.