Bash Xargs kommanderer den hårde vej ved eksempel

Når du bare begynder at lære bash-programmering på den hårde måde, fortæller ingen dig om xargs-kommandoen. Siden da har du formået at hente nok xargs til at komme forbi uden at bryde for meget. Nu finder du dig selv spørger - Hvad med alle de andre muligheder? Kan jeg gøre dette? Hvad hvis jeg vil .. ?

Nu har du sandsynligvis en god nok forståelse for, hvordan du udfører kommando i bash. Men hvad nu hvis du vil udføre strømme af kommandoer i rækkefølge eller nogle gange parallelt? Det er her, vi finder os selv ved hjælp af xargs.

Her håber vi at besvare alle disse spørgsmål og mere om bash og xargs-kommandoen med et eksempel.

Hvad er xargs in bash?

xargs er en ekstern kommando, der bruges til konvertere standard input til kommandolinjeargumenter det siges at stå for ”udvidede argumenter.”Det blev hovedsageligt oprettet til brug med kommandoer, der ikke er bygget til at håndtere pipet input eller standard input såsom rm, cp, echo ¹ og andre eksterne kommandoer, der kun accepterer argumenter som parametre.

¹ Selvom de fleste systemer leveres med en ekkokommando, er ekko en indbygget bash; Det er medmindre det kaldes kommandoeko, det indbyggede ekko bruges. Tilsvarende er bash-buildins ikke opmærksom på piped-input.

Xargs-muligheder med bash-eksempler

Lad os løbe igennem xargs og dets muligheder med eksempler i bash. Sammen med den konventionelle behandling af kommandolinjemuligheder, der forventes med xargs, grupperes indstillingerne efter objekter som at få info eller ændre adfærd.

Xargs info

Her er muligheder, der giver information om xargs.

Xargs hjælp

xargs - hjælp
Anvendelse: xargs [OPTION]… COMMAND [INITIAL-ARGS]…
Kør COMMAND med argumenter INITIAL-ARGS og flere argumenter læst fra input.
Obligatoriske og valgfri argumenter for lange muligheder er også
obligatorisk eller valgfri for den tilsvarende korte mulighed.
-0, --null elementer er adskilt af et null, ikke hvidt mellemrum;
deaktiverer behandling af tilbuddene og tilbageslag og
logisk EOF-behandling
-a, --arg-file = FILE læste argumenter fra FILE, ikke standard input
-d, --delimiter = CHARACTER-elementer i inputstrøm adskilles af CHARACTER,
ikke ved mellemrum; deaktiverer tilbud og tilbageslag
behandling og logisk EOF-behandling
-E END sæt logisk EOF streng; hvis END forekommer som en linje
af input ignoreres resten af input
(ignoreret hvis -0 eller -d blev specificeret)
-e, --eof [= END] svarende til -E END hvis END er specificeret;
Ellers er der ingen streng til slutningen af filen
-I R samme som --replace = R
-i, --placere [= R] udskift R i INITIAL-ARGS med navne læst
fra standard input; hvis R ikke er specificeret,
antage
-L, --max-linjer = MAX-LINES bruger højst MAX-LINES ikke-tomme inputlinjer pr
kommandolinje
-l [MAX-LINES] svarer til -L, men er som standard højst en ikke-
tom inputlinje, hvis MAX-LINES ikke er specificeret
-n, --max-args = MAX-ARGS bruger højst MAX-ARGS argumenter pr. kommandolinje
-P, --max-procs = MAX-PROCS kører mest MAX-PROCS processer ad gangen
-p, --interaktiv prompt, før du kører kommandoer
--process-slot-var = VAR indstillet miljøvariabel VAR i underordnede processer
-r, --no-run-if-tom, hvis der ikke er argumenter, så kør ikke COMMAND;
hvis denne mulighed ikke er givet, vil COMMAND være
køre mindst en gang
-s, --max-chars = MAX-CHARS begrænser kommandolinjelængden til MAX-CHARS
--show-limits viser begrænsninger på kommandolinjelængden
-t, --verbose printkommandoer, før de udføres
-x, - afslut exit, hvis størrelsen (se -s) overskrides
--hjælp med at vise denne hjælp og afslut
--version output version information og exit

Henvis til xargs-hjælp som en hurtig reference til brug og muligheder for xargs.

Xargs version

xargs --version
xargs (GNU findutils) 4.6.0

Xargs grænser

Selv xargs har sine grænser. Indstillingen -show-limits for xargs viser grænser, der bruges af xargs, før kommandoer køres. De faktiske grænser afhænger af dit miljø. For de fleste brugere er det dog nok. Grænserne kan justeres på kommandolinjen, se eksempler.

Eksempel) Dit miljø xargs grænser

xargs - showgrænser
Dine miljøvariabler optager 6234 bytes
POSIX øvre grænse for argumentlængde (dette system): 23718
POSIX mindste tilladte øvre grænse for argumentlængde (alle systemer): 4096
Maksimal kommandolængde, vi faktisk kunne bruge: 17484
Størrelse på kommandobuffer, vi faktisk bruger: 23718
Maksimal parallelisme (--max-procs må ikke være større): 2147483647

Udførelsen af xargs fortsætter nu, og den vil forsøge at læse dens input og køre kommandoer; hvis dette ikke er, hvad du ønskede at ske, skal du indtaste slutningen af fil-tastetryk.

Advarsel: ekko køres mindst én gang. Hvis du ikke ønsker, at det skal ske, skal du trykke på afbryd tastetryk.

Bemærk, at den kommando, der kører som en konsekvens af xargs, er ekko, standardkommandoen for xargs.

Eksempel) Xargs-grænser med en justeret kommandobuffergrænse

xargs --show-limits -s 1
Dine miljøvariabler optager 9479 bytes
POSIX øvre grænse for argumentlængde (dette system): 20473
POSIX mindste tilladte øvre grænse for argumentlængde (alle systemer): 4096
Maksimal kommandolængde, vi faktisk kunne bruge: 10994
Størrelse på kommandobuffer, vi faktisk bruger: 1
Maksimal parallelisme (--max-procs må ikke være større): 2147483647
..
Advarsel: ekko køres mindst én gang. Hvis du ikke ønsker, at det skal ske,
tryk derefter på afbryd tastetryk.
xargs: kan ikke passe til et enkelt argument inden for grænsen for argumentlistestørrelse

Bemærk, at der vises fejl i bunden efter advarsler, hvis-nogen. Vi har en ”xargs: kan ikke passe et enkelt argument inden for grænsen for argumentlistestørrelse”, hvilket bare betyder, at vi forsøger at arbejde uden for den tilladte kommandobufferstørrelse, der er indstillet til et tegn.

Kommandobufferen indeholder kommandoen efterfulgt af alle argumenter inklusive mellemrum.
I tilfælde af kommandoen i dette eksempel på xargs-indstilling er kommandobufferen

"ekko"

som indeholder 4 tegn.
Så vi er nødt til at indstille kommandobufferstørrelsen til en værdi større end eller lig med 5 som følger. Bemærk, at kommandobufferforbrug svarer til længde_af_kommando + længde_args_indbefattet_rum_plus_one + 1.

xargs --show-limits -s 5

# Ikke mere "xargs: kan ikke passe til et enkelt argument inden for grænsen for argumentlistestørrelse" fejl

Men hvad nu hvis vores kommando har argumenter?

ja | xargs -t --show-limits -t -s 6 # kører med følgende output
ekko y
..

Xargs detaljerede

lhs | xargs -t other_xargs_options_if_any | rhs

Indstillingen -t kan bruges til at vise kommandoer, der køres af xargs som output til fd2, standardfejl. Det vil sige xargs -t kan annulleres ved at omdirigere standardfejl til / dev / null som følger.

xargs -t 2> / dev / null

Eksempel) Ja en gang

ja | hoved -n 5 | xargs -t sandt
sandt y y y y y

Eksempel) Ja 5 gange

ja | hoved -n 5 | xargs -t -I sandt
sandt y
sandt y
sandt y
sandt y
sandt y

Xargs opførsel

Ingen kommando er komplet uden muligheder for at ændre runtime-opførsel. Xargs er ikke anderledes. Her er de muligheder, der giver dig mulighed for at ændre dens adfærd.

Xargs null

lhs | xargs -0 other_xargs_options_if_any | rhs

Indstillingen -0 kan bruges til at fortælle xargs at bruge null i stedet for mellemrum. Det deaktiverer også tilbud og flugtsekvenser.

Xargs null brugssag

Det anvendte til xargs null er til håndtering af sager, som f.eks. Når emner indeholder mellemrum såsom filer, der indeholder mellemrum eller nye linjetegn.

Antag at du har et bibliotek “a b c” inklusive mellemrum i et katalognavn.

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

Du vil køre en kommando på hver mappe i “a b c” ved hjælp af find-kommandoen.

Du kan prøve følgende:

find "a b c" -type d | xargs du -d 0 -h
du: kan ikke få adgang til 'a': Ingen sådan fil eller katalog
du: kan ikke få adgang til 'b': Ingen sådan fil eller katalog
du: kan ikke få adgang til 'c': Ingen sådan fil eller mappe
du: kan ikke få adgang til 'a': Ingen sådan fil eller katalog
du: kan ikke få adgang til 'b': Ingen sådan fil eller katalog
du: kan ikke få adgang til 'c / de': Ingen sådan fil eller mappe
du: kan ikke få adgang til 'a': Ingen sådan fil eller katalog
du: kan ikke få adgang til 'b': Ingen sådan fil eller katalog
du: kan ikke få adgang til 'c / fg': Ingen sådan fil eller mappe
du: kan ikke få adgang til 'a': Ingen sådan fil eller katalog
du: kan ikke få adgang til 'b': Ingen sådan fil eller katalog
du: kan ikke få adgang til 'c / h': Ingen sådan fil eller mappe
du: kan ikke få adgang til 'a': Ingen sådan fil eller katalog
du: kan ikke få adgang til 'b': Ingen sådan fil eller katalog
du: kan ikke få adgang til 'c / i': Ingen sådan fil eller mappe
du: kan ikke få adgang til 'j': Ingen sådan fil eller katalog
du: kan ikke få adgang til 'k': Ingen sådan fil eller mappe
du: kan ikke få adgang til 'l': Ingen sådan fil eller katalog

Det fungerer forkert, fordi vores katalognavne er fyldt med mellemrum. Dette var ikke din hensigt.

Du kan løse dette ved at tilføje udskiftning af xargs, dvs.e-jeg som følger.

find "a b c" -type 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

Det fungerer korrekt, når du bruger udskiftning af xargs. Bemærk, at vi brugte -i, som er stenografi for -I .

En anden måde, hvorpå vi kan opnå det samme resultat, er at bruge xargs null, -null, i kombination med find -print0-indstillingen som følger.

find "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

Store! Nu har vi mere end en måde at sprænge os dybt ind i filsystemets univers uden at skulle bekymre os om at kollidere med rumskrot vores rejse. Lige på.

Xargs interaktiv

Måske stoler du ikke på xargs til at køre alle kommandoer uden bekræftelse. I så fald er xargs interaktiv eller -p den mulighed, du har brug for til at kontrollere, hvilke kommandoer der køres af xargs som følger.

find "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 ?... y
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 ?... nej

Her køres enhver kommando, der starter med 'y' eller 'Y'. Ellers ignoreres kommandoer.

Xargs-fil

Du har allerede en fil, arg-fil, klar til at blive læst i xargs. Dit program venter muligvis rundt i et bibliotek et eller andet sted for en anden eller en anden forekomst af dig selv at droppe en arg-fil. I dette tilfælde kan du angive filen som en mulighed for at xargs ved hjælp af -a arg-fil i stedet for at skulle bruge cat-fil | xargs ... Xargs fileksempler følger.

Bare for sjov, lad os omdanne dine desktop-oprydningsrutiner til en arg-fil, som vi kan bruge.

ls oprydnings-desktop | tee arg-fil
190605_cleanup_desktop_files_sh.txt
190605_cleanup_desktop_lnk_files_sh.txt
190605_cleanup_desktop_un_files_sh.txt

Hver fil indeholder en rutine, der kan køres ved hjælp af bash. Det betyder, at kommandoen, vi vil bruge, er bash.

Lad os køre oprydningsrutiner ved hjælp af xargs.

xargs -a arg-fil -i -P 99 bash -c 'echo ; . oprydnings-desktop / ; '
190605_cleanup_desktop_files_sh.txt
190605_cleanup_desktop_lnk_files_sh.txt
190605_cleanup_desktop_un_files_sh.txt

Og det fungerer!
Bare hvis vi har brug for at angive en arg-fil i stedet for at bruge piped-input, er xargs-filindstillingen praktisk.

Xargs erstatter

lhs_if_any | xargs -i andet_args_etc | rhs_if_any

Sidst men ikke mindst giver xargs erstatning -i dig mulighed for at tage fuld kontrol over kommandoformatet, før det køres. Ethvert tegn kan bruges. Efter konvention bruger de fleste bash-programmører dog denne eller denne%. Bemærk, at standardværdien er . -jeg fortæller xargs at du vil blive brugt som standard. Og det betragtes som stenografi. -Jeg fulgte af en erstatningskarakter efter eget valg fortæller xargs, hvilket tegn du vil bruge. Undgå at bruge almindelige tegn som bogstavet a. Det vil bryde din kode mere end noget mellemrum eller ny linje nogensinde har gjort.

Xargs parallel

lhs_if_any | xargs -P n_ge_1 anden_args_etc | rhs_if_any

Xargs parallel -P gør det muligt at køre kommandoer samtidigt i stedet for i rækkefølge. Se xargs-grænser -show-grænser for gyldige argumenter for n_ge_1 eller samtidighed. For eksempel hvis

Maksimal parallelisme (--max-procs må ikke være større): 2147483647

Du kan indstille -P 2147483647 uden fejl. I praksis kan du muligvis finde en pænere indstilling som -P 99, der forbedrer den samlede ydeevne uden at øge overhead for at styre samtidige processer.

Eksempler, der viser, hvordan brugen af xargs parallel kan forbedre ydeevnen, følger.

Eksempel) Tæller i rækkefølge versus parallel ved hjælp af xargs

Lad os se, hvad der sker, når vi tidstæller i rækkefølge ved hjælp af xargs.

tidsekko 1… 1000 | xargs '-d' -i bash -c 'ekko '
..
998
999
1000
rigtig 1m13.927s
bruger 0m6.994s
sys 0m15.184s

Se nu, hvad der sker, hvis vi tidstæller parallelt ved hjælp af xargs.

tidsekko 1… 1000 | xargs -P 200 '-d' -i bash -c 'ekko '
..
998
999
1000
rigtig 0m13.554s
bruger 0m6.446s
sys 0m14.293s

Betydelig forbedring i ydeevne observeres ved hjælp af xargs parallelt til at køre enkle kommandoer uden delte ressourcer.

Eksempel) Sammenligning af rækkefølge og timing af xargs parallel

Lad os se, hvad der sker, når en kommando bruger CPU-tid.

tidsekko 1… 10 | xargs '-d' -i bash -c 'sove $ (($ RANDOM% 2)); ekko '
1
2
3
4
5
6
7
8
9
10
rigtig 0m5.601s
bruger 0m0.180'erne
sys 0m0.334s

Bemærk, at alle kommandoer er komplette i rækkefølge.

Se nu, hvad der sker, når den samme kommando køres parallelt.

tidsekko 1… 10 | xargs -P 10 '-d' -i bash -c 'sove $ (($ RANDOM% 2)); ekko '
3
4
6
7
8
1
2
5
9
10
rigtig 0m1.257s
bruger 0m0.060'erne
sys 0m0.225s
Kommando 1, 2, 5 og 9 gik i dvale. Vi var dog i stand til at reducere
tid til at fuldføre med så meget som 78 procent.

Xargs Parallel Konklusion

Enkel tilføjelse af xargs parallel som en kommandolinjemulighed kan forbedre ydelsen ti gange. Du skal dog fortsætte med forsigtighed, når du bruger ordreafhængige procedurer, eller når kommandoer deler ressourcer.

Xargs-afgrænser

lhs_if_any | xargs '-dc' andet_args_etc | rhs_if_any

Xargs-afgrænser -d giver dig mulighed for at indstille emneseparatoren til ethvert tegn c på samme måde som afgrænsningstegn er indstillet i kommandoen klippe.

Som standard er -dc indstillet til hvidt mellemrum oprettet af newline-tegnet -d \ x0a.
Når du bruger xargs null -0, er -dc indstillet til null-tegnet -d \ x00.

For eksempel kan du indstille afgrænseren til mellemrumstegnet, i.e. -dc er '-d' i en kommandolinje eller dit bash-script.

Du kan indstille skillelinjen til kommategnet, dvs.e. -dc er '-d'.

Afgrænsningsindstillingen i xargs -d giver dig mulighed for at indstille artikelseparatoren til ethvert tegn, du ønsker.

Eksempler på Bash xargs

Her dækker vi eksempler på anvendelser af xargs-kommandoen i bash inklusive eksempelbrug i kommandolinjen såvel som scripts.

Eksempler på Bash xargs-kommandoer

Her dækker vi eksempler på kommandolinjebrug af xargs-kommandoen i bash inklusive eksempelbrug med og uden pipet input.

Eksempel) Lav dit eget input: sjovt med xargs uden input

Hvad gør xargs alene hjemme?

xargs
Hej, er der nogen hjemme?
..
(Ctrl-D)
Hej, er der nogen hjemme?..

Det ser ud til, at vi fik vores spørgsmål tilbage som et svar, men det ser ud til at være et ekko.

Hvorfor?

Som du måske har læst i, hvad xargs handler om, konverterer det standardinput til kommandolinjeargumenter. Hvis der ikke gives nogen indstillinger og argumenter, opfører den sig som en rørbevidst ekkokommando. Det er:

xargs
Hej, er der nogen hjemme?
..
(Kontrol-D) 2

Producerer det tilsvarende ekko kommandolinieudtryk implicit

ekko Hej, er der nogen hjemme?..
2 I et script kan heredoc bruges som følger.
xargs << EOF
Hej, er der nogen hjemme?
..
EOF
ekko Hej, er der nogen hjemme?..

Eksempel) Brug xargs som pladsholder til interaktive rør

At bruge xargs på venstre side af et rør er paradoksalt⁴så lad os køre bash i superbegrænset tilstand⁵.

⁴ Rørbevidste kommandoer behøver ikke xargs. Rør uvidende kommandoer ved ikke om xargs

⁵ Begrænset tilstand, der nulstiller hver linje. Andre begrænsninger kan tilføjes senere.

xargs -I bash -cr ""
i = 1
ekko $ i
ekko Hej!
Hej!
!!
bash: !!: Kommando ikke fundet
i = 1; ekko $ i
1
cd ..
bash: linje 0: cd: begrænset

Eksempel) Brug xargs som pladsholder til interaktive argumenter

I henhold til HackerRank-udviklingsrapporten fra 2019³, ”Regnemaskiner er de nye spil.”Flere udviklere under 38 år skubber regnemaskiner som deres første kodningsprojekt. ³ Indsigt baseret på 71.281 udviklere

Så lad os bygge en lommeregner ved hjælp af xargs!

_ () echo $ (("$ @")); # lommeregner
mens :
gør
_ $ (xargs)
Færdig
1 + 2 + 3 + 4
(Ctrl-D)
10
1 - 2 + 3 - 4 + 5
(Ctrl-D)
3
1 ** 2 + 2 ** 2
(Ctrl-D)
3
1+
2+
3+
4+
5
(Ctrl-D)
15

Eksempel) Statisk stedgenerator

Antag at du har et par tusinde almindelige tekstfiler, som du vil bruge til at generere et statisk sted til, og ingen af filerne hedder indeks. Filnavne inkluderer små bogstaver ascii og eventuelt en bindestreg.

Her er hvad en linje eller to i terminalen på en teoretisk maskine, der kører bash, vil se ud. Maskinen har andre eksterne kommandoer, herunder findutils og pandoc. Du kan bruge en hvilken som helst tilsvarende kommando efter eget valg.

# vi er i biblioteket
# se mange filer

test -d "html" || mkdir -v $ _
finde . -mindepth 1 -maxdepth 1 -type f \
| xargs -P 6000 -i bash -c "ekko ; kat | sed -e 's / $ / /' |
pandoc -thtml -o .html "

# se dobbelt så mange filer nu inklusive html-filer
# Færdig

Eksempler på Bash xargs-script

Eksempel) Brug xargs til at generere firkantede matricer

Her er et script, jeg tilberedte for at generere firkantede matricer ved hjælp af xargs. Specifikt drager den fordel af opførslen ved hjælp af indstillingen -n og bruger kommandoen seq til sekvenser af tal, der skal bruges i matricer.

#!/ bin / bash
## kvadratmatrix
## - genererer firkantede matricer
## version 0.0.1 - indledende
##################################### ############################
kvadrat-matrix-hjælp ()

kat << EOF
kvadratmatrix
1 - ordre
EKSEMPLER
> kvadratmatrix 1
1
> kvadratmatrix 2
1 2
3 4
> kvadratmatrix 3
1 2 3
4 5 6
7 8 9
EOF

firkant-matrix () lokal -i rækkefølge; ordre = $ 1;
test "$ order" || $ FUNCNAME -hjælp; Vend tilbage ;
test $ order -gt 0 || $ FUNCNAME -hjælp; Vend tilbage ;
_ ()
seq $ (($ 1 ** 2)) | xargs -n $ 1

_ $ ordre

##################################### ############################
hvis [ ! ]
derefter
rigtigt
andet
exit 1 # forkert args
fi
##################################### ############################
kvadratmatrix $ @
##################################### ############################
## genereret af create-stub2.sh v0.1.2
## ons, 29. maj 2019 13:44:06 +0900
## se
##################################### ############################

Kilde: kvadratmatrix.sh

Jeg har også inkluderet et testprogram til at vise scriptet i aktion, generere alle firkantede matricer op til 10 x 10.

#!/ bin / bash
## test-kvadrat-matrix
## - genererer firkantede matricer op til 10 x 10
## version 0.0.1 - indledende
##################################### ############################
test-kvadrat-matrix ()
test -f "firkant-matrix.sh "
. $ _ 1> / dev / null
lokal i
for jeg i 1… 10
gør
ekko "firkantmatrix ($ i)"
kvadratmatrix $ i
Færdig

##################################### ############################
hvis [$ # -eq 0]
derefter
rigtigt
andet
exit 1 # forkert args
fi
##################################### ############################
test-kvadrat-matrix
##################################### ############################
## genereret af create-stub2.sh v0.1.2
## ons, 29. maj 2019 13:40:08 +0900
## se
##################################### ############################

Kilde: test-kvadrat-matrix.sh

Her er hvad man kan forvente:

bash test-kvadrat-matrix.sh | hoved
firkant-matrix (1)
1
kvadratmatrix (2)
1 2
3 4
kvadratmatrix (3)
1 2 3
4 5 6
7 8 9
..

Øvelse: Forbedre displayet i terminalen ved at anvende polstring på tal

Når vi forsøger at generere den firkantede matrix i rækkefølge 10 ved 10, får vi følgende output:

bash firkant-matrix.sh 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 99100

Udvid kvadratmatrix som en øvelse.sh for at muliggøre output som følger.

bash firkant-matrix.sh 10
001002 003 004 005 006 007 008 00 9010
011 012 013 014 015 016 017 018 019 020
021 022 023 024 025 026 027 028 029030
031 032 033 034 035 036 037 038 0390 040
0410420430440454604804849050
051052053055055055055055059060
06106620304040656606768069070
071077203030507070707080909080
08108208330408508808808909090
09109220303040096097099099100

Eksempler på praktiske brug af Bash xargs

Eksempel) Søg efter filer efter et mønster ved hjælp af xargs grep

liste-filer¹ | xargs grep -e mønster

¹ liste-filer er en kommando, der returnerer kandidatstier til fil, der skal tages som input til grep gennem kommandoen xargs

Som et praktisk anvendelseseksempel på xargs i bash gravede jeg op xargs fra en hemmelig kodebase.

find -type f -navn \ *.sh | wc -l
994

Der er 994 bash-scripts. Lad os se, hvor mange kommandoen xargs.

find -type f -navn \ *.sh | xargs grep -e xargs viser alle forekomster
af xargs i kodebasen.
..
find -type f -navn \ *.sh | xargs grep -e xargs | wc -l
18

Der er 18 matches for xargs i kodebasen. Nu vil vi måske finde ud af, hvor mange scripts der bruger xargs.

Store! Der er 10 scripts med xargs i kodebasen. Lad os se, hvad de er.

find -type f -navn \ *.sh | xargs grep -e xargs | klippe '-d:' '-f1' | sorter | uniq
vim $ ( !! )

Resumé af resultaterne

- Søg og ødelæg filer, der indeholder et mønster i filnavnet

find $ sti -type f -navn \ * $ mønster \ * | xargs rm -vf

- Listeoplysninger om filer på rørets rør

find-filer | xargs ls -al

- Gør filer eksekverbare

find-filer | xargs chmod + x

- Liste over filnavne

find-filer | xargs -I dirname ""

- Rens alle

stier til rensning | xargs rm -rvf

- Zip filer

find-filer-til-zip | xargs -I arkiv - $ (dato +% s)

- Liste over filnavne

find-filer | xargs -I basenavn

Eksempel) Installer software fra en liste ved hjælp af apt-get i Ubuntu

Når du opgraderer Ubuntu, skal du muligvis installere ny software efter sikkerhedskopiering af dit system. Antag at du har en liste over software, der skal installeres ved hjælp af apt-get i Ubuntu.

sudo dpkg - get-selections | grep '[[: space:]] installer $' |
\ awk 'print $ 1'> install_software
# ..
kat install_software | xargs sudo apt-get installation

Eksempel) Curl seige ved hjælp af xargs i bash

Antag at du har en masse webadresser, der fører til en enkelt node et eller andet sted på internettet, og at du gerne vil lægge seige ved hjælp af curl in bash. Fortrinsvis er dette en af dine noder, og seigen er ikke i dit produktionsmiljø. Her er hvordan vi lægger seige ved hjælp af xargs i bash.

#declare -f filter
filter ()

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

get-arg-fil ()

krølle https: // linuxhint.com / sitemap.xml - stille \
| filter \
| xargs -i krølle - stille \
| filter \
| xargs -i echo > arg-fil

#declare -f krølle
krølle ()

ekko (falsk) $ FUNCNAME "$ @"

erklære -xf krølle
nyttelast ()

test -f "arg-fil" || Vend tilbage
xargs -P 1000 -a arg-file -i echo curl | bash 1> / dev / null

seige ()

test -f "arg-fil" || få - $ _
nyttelast

seige

Bash xargs debug

Når du sidder foran terminalen, er du chefen. Men når noget går galt, hjælper det, hvis du ved, hvordan du rent faktisk debugger bash-scripts som en chef.

At spille det sikkert, have en metode til at validere succes, når du bruger xargs i bash i stedet for blindt at forvente, at alt vil være okay, anbefales stærkt. Det vil sige, du skal sørge for, at alle kommandoer komplet med succes og fiasko ikke er markeret.

Metoder

Størrelse på standardfejloutput
Hvis standardfejl indeholder 1 eller flere tegn, gik der noget galt
Summen af kommandoudgangskoder
Hvis summen af udgangskoder er større end 0, gik der noget galt
Validering af nyttelast
Hvis et stykke af nyttelasten mangler, gik der noget galt
Slutningen af scriptvalidering
Kørsel af xargs-kommandoer som et script, hvis slutningen af scriptet ikke er nået, gik der noget galt. Bemærk, at errexit er indstillet, og kommandoer køres inde fra en funktion.
Anden metode
Hvis resultatet afviger fra det, der forventes, kan der gå noget galt

Eksempel) Fejlfinding af xargs ved hjælp af størrelsen på standardfejloutput

Her er en anonym funktion, som vi tester debugging af xargs ved hjælp af stardart-fejl.

# erklær -f _, jeg.e. Jeg skrev ikke koden nedenfor
# hvis du finder ud af, at du er lidt rusten på at erklære, at jeg skrev en anden tutorial om
#
hvordan erklær kommandoen fungerer i bash
_ ()

rm -vf errout;
tryk på $ _;
ekko 1… 10 | xargs -x -P 10 '-d' -i bash -c "test $ (($ RANDOM% $ 1)) -eq 0 ||
ekko 1> & 2; Afslut ; ; ekko "2> errout;
prøve ! $ (wc < errout -c ) -gt 0 || echo something went wrong…

## test
_ 1 # sandsynlighed for fiasko (= 1-1 / 1 = 0%)
_ 2 # sandsynlighed for fiasko (= 1-1 / 2 = 1/2 = 50%)
_ 3 # sandsynligvis fejl (= 1-1 / 3 = 2/3 = 60%)
..

Hvis du ikke bruger standardfejl til noget andet ved hjælp af størrelsen på standardfejl til fejlretning af xargs er en metode, der kan fungere for dig.

Bash xargs-funktioner

Nogle gange er det, du vil gøre, at bruge funktioner, som du har defineret i xargs. For at gøre det skal vi gøre funktionen tilgængelig for xargs. Sådan gør du.

#declare -f _
_ ()

ekko $ @ ^^

ekko a… z 1… 9 | xargs '-d' -i bash -c "_ "
bash: _: kommandoen blev ikke fundet
..
erklære -xf _
ekko a… z 1… 9 | xargs '-d' -i bash -c "_ "
A1
A2
A3
..
# eller
ekko a… z 1… 9 | xargs '-d' -i ekko "_ " | bash
..
Z7
Z8
Z9

Bemærk, at ovenstående interaktive sessionseksempel kan fremskyndes ved hjælp af bash xargs parallel.

Konklusion

Xargs er en af de mange eksterne kommandoer, som du bedre har at vide i bash. Ved at skrive denne vejledning om xargs-kommandoen lærte jeg selv et par ekstra muligheder. Gennemgang anbefales så ofte. Først da kan du være i stand til at bruge xargs til sit virkelige potentiale. Indtil da skal du kode.