Phenquestions
Nyní už pravděpodobně dostatečně dobře rozumíte tomu, jak vykonávat příkazy v bash. Ale co když chcete spouštět proudy příkazů postupně nebo někdy paralelně? To je místo, kde se nacházíme pomocí xargs.
Doufáme, že zde zodpovíme všechny tyto otázky a další informace o bash a příkazu xargs příkladem.
Co je xargs v bash?
xargs je externí příkaz zvyklý na převést standardní vstup na argumenty příkazového řádku to znamená „rozšířené argumenty.„Byl vytvořen hlavně pro použití s příkazy, které nejsou vytvořeny pro zpracování piped vstupu nebo standardního vstupu, jako je rm, cp, echo 1 a další externí příkazy přijímající argumenty pouze jako parametry.
1 Ačkoli většina systémů přichází s příkazem echo, echo je vestavěný bash; To znamená, že pokud nevoláte příkaz echo, použije se vestavěné echo. Podobně bash builtins neví o piped vstupu.
Možnosti Xargs s příklady bash
Pojďme si projít xargs a jeho možnosti s příklady v bash. Spolu s konvenčním zpracováním možností příkazového řádku očekávaného u xargs jsou možnosti seskupeny podle objektů, jako je získání informací nebo úprava chování.
Xargs informace
Zde jsou možnosti poskytující informace o xargs.
Nápověda Xargs
xargs - pomocPoužití: xargs [MOŽNOST]… PŘÍKAZ [VÝCHOZÍ ARGY]…
Spusťte příkaz COMMAND s argumenty INITIAL-ARGS a více argumentů přečtených ze vstupu.
Povinné a volitelné argumenty pro dlouhé volby jsou také
povinné nebo volitelné pro odpovídající krátkou možnost.
-0, --null položky jsou odděleny nulou, ne mezerami;
zakáže zpracování nabídek a zpětných lomítek a
logické zpracování EOF
-a, --arg-file = SOUBOR čte argumenty ze SOUBORU, ne standardní vstup
-d, --delimiter = CHARACTER položky ve vstupním proudu jsou odděleny CHARACTER,
ne mezerami; zakáže nabídku a zpětné lomítko
zpracování a logické zpracování EOF
-E END nastavit logický řetězec EOF; pokud se END objeví jako čára
vstupu, zbytek vstupu je ignorován
(ignorováno, pokud bylo zadáno -0 nebo -d)
-e, --eof [= END] ekvivalent k -E END, pokud je zadán END;
jinak neexistuje žádný řetězec konce souboru
-I R stejný jako --replace = R
-i, --replace [= R] nahraďte R v INITIAL-ARGS přečtenými jmény
ze standardního vstupu; pokud R není specifikováno,
předpokládat
-L, --max-lines = MAX-LINES používá maximálně MAX-LINES neprázdných vstupních řádků na
příkazový řádek
-l [MAX-LINES] podobné jako -L, ale výchozí hodnota je maximálně jedna non-
prázdný vstupní řádek, pokud není zadán MAX-LINES
-n, --max-args = MAX-ARGS používá maximálně MAX-ARGS argumentů na příkazový řádek
-P, --max-procs = MAX-PROCS běží na většině MAX-PROCS procesů najednou
-p, --interaktivní výzva před spuštěním příkazů
--process-slot-var = VAR nastavuje proměnnou prostředí VAR v podřízených procesech
-r, --no-run-if-empty, pokud neexistují žádné argumenty, pak nespouštějte COMMAND;
pokud tato možnost není zadána, bude PŘÍKAZ
spustit alespoň jednou
-s, --max-chars = MAX-CHARS omezuje délku příkazového řádku na MAX-CHARS
--show-limits zobrazit limity na délku příkazového řádku
-t, --verbose tiskové příkazy před jejich provedením
-x, --exit exit, pokud je překročena velikost (viz -s)
--help zobrazit tuto nápovědu a ukončit
--verze výstup informace o verzi a ukončení
Odkaz na nápovědu xargs jako rychlý odkaz na použití a možnosti xargs.
Verze Xargs
xargs --verzexargs (GNU findutils) 4.6.0
Limity Xargs
I xargs má své limity. Možnost -show-limits pro xargs zobrazuje limity používané xargs před spuštěním příkazů. Skutečné limity závisí na vašem prostředí. Pro většinu uživatelů to však stačí. Limity lze upravit na příkazovém řádku, viz příklady.
Příklad) Vaše prostředí xargs limity
xargs --show-limitsVaše proměnné prostředí zabírají 6234 bajtů
POSIX horní limit na délku argumentu (tento systém): 23718
Nejmenší povolený horní limit délky argumentu POSIX (všechny systémy): 4096
Maximální délka příkazu, kterou můžeme skutečně použít: 17484
Velikost vyrovnávací paměti příkazů, kterou ve skutečnosti používáme: 23718
Maximální paralelismus (--max-procs nesmí být větší): 2147483647
Provádění xargs bude nyní pokračovat a pokusí se přečíst jeho vstup a spustit příkazy; pokud to není to, co jste chtěli, zadejte klávesovou zkratku na konci souboru.
Varování: echo bude spuštěno alespoň jednou. Pokud si nepřejete, aby se to stalo, stiskněte klávesu pro přerušení.
Všimněte si, že příkaz, který by běžel jako důsledek xargs, je echo, výchozí příkaz xargs.
Příklad) Limity Xargs s upraveným limitem vyrovnávací paměti příkazů
xargs --show-limits -s 1Vaše proměnné prostředí zabírají 9479 bajtů
POSIX horní limit na délku argumentu (tento systém): 20473
Nejmenší povolený horní limit délky argumentu POSIX (všechny systémy): 4096
Maximální délka příkazu, kterou můžeme skutečně použít: 10994
Velikost vyrovnávací paměti příkazů, kterou ve skutečnosti používáme: 1
Maximální paralelismus (--max-procs nesmí být větší): 2147483647
…
Varování: echo bude spuštěno alespoň jednou. Pokud si nepřejete, aby se to stalo,
poté stiskněte klávesu pro přerušení.
xargs: do limitu velikosti seznamu argumentů se nevejde jediný argument
Všimněte si, že v dolní části se po případných Varováních objeví chyby. Máme chybu „xargs: cannot fit single argument within argument list size limit“, což znamená, že se pokoušíme pracovat mimo povolenou velikost vyrovnávací paměti příkazů, která je nastavena na znak.
Vyrovnávací paměť příkazů obsahuje příkaz následovaný všemi argumenty včetně mezer.
V případě příkazu v tomto příkladu možnosti xargs je vyrovnávací paměť příkazů
který obsahuje 4 znaky.
Musíme tedy nastavit velikost vyrovnávací paměti příkazů na hodnotu větší nebo rovnou 5 následujícím způsobem. Všimněte si, že spotřeba vyrovnávací paměti příkazů se bude rovnat length_of_command + length_args_including_spaces_plus_one + 1.
# Už ne "xargs: do limitu velikosti seznamu argumentů se nevejde jediný argument" chyba
Ale co když má náš příkaz args?
ano | xargs -t --show-limits -t -s 6 # poběží s následujícím výstupemozvěna y
…
Xargs podrobně
lhs | xargs -t other_xargs_options_if_any | rhsVolbu -t lze použít k zobrazení příkazů spuštěných xargs jako výstup do fd2, standardní chyba. To je xargs -t lze zrušit přesměrováním standardní chyby na / dev / null následujícím způsobem.
xargs -t 2> / dev / nullPříklad) Ano jednou
ano | hlava -n 5 | xargs -t pravdapravda y y y y y
Příklad) Ano 5krát
ano | hlava -n 5 | xargs -t -I pravdapravda y
pravda y
pravda y
pravda y
pravda y
Chování Xargs
Žádný příkaz není kompletní bez možností úpravy chování za běhu. Xargs se nijak neliší. Zde jsou možnosti, které vám umožňují změnit jeho chování.
Xargs null
lhs | xargs -0 other_xargs_options_if_any | rhsMožnost -0 lze použít k tomu, aby xargs řekl, aby místo mezer použil null. Zakáže také uvozovky a únikové sekvence.
ano | hlava -n 5 | sed.* / cul- "de" - 'sac' / "| xargs -I echo -en" \ n \ x00 "slepá ulička
slepá ulička
slepá ulička
slepá ulička
slepá ulička
ano | hlava -n 5 | sed.* / cul- "de" - 'sac' / "| xargs -0 -I echo -en" \ n \ x00 "
cul- "de" - 'vak'
cul- "de" - 'vak'
cul- "de" - 'vak'
cul- "de" - 'vak'
cul- "de" - 'vak'
Xargs nulový případ použití
Určené použití pro xargs null je pro zpracování případů, jako když položky obsahují mezery, například soubory obsahující mezery nebo znaky nového řádku.
Předpokládejme, že máte adresář „a b c“ včetně mezer v názvu adresáře.
je „a b c“de / fg / h / 'i j k l' /
Chcete spustit příkaz pro každý adresář v „a b c“ pomocí příkazu find.
Můžete zkusit následující:
najít typ „a b c“ d | xargs du -d 0 -hdu: nemá přístup k 'a': Žádný takový soubor nebo adresář
du: nelze získat přístup k „b“: Žádný takový soubor nebo adresář
du: nelze získat přístup k „c“: Žádný takový soubor nebo adresář
du: nemá přístup k 'a': Žádný takový soubor nebo adresář
du: nelze získat přístup k „b“: Žádný takový soubor nebo adresář
du: nelze získat přístup k „c / de“: Žádný takový soubor nebo adresář
du: nemá přístup k 'a': Žádný takový soubor nebo adresář
du: nelze získat přístup k „b“: Žádný takový soubor nebo adresář
du: nelze získat přístup k souboru „c / fg“: Žádný takový soubor nebo adresář neexistuje
du: nemá přístup k 'a': Žádný takový soubor nebo adresář
du: nelze získat přístup k „b“: Žádný takový soubor nebo adresář
du: nelze získat přístup k souboru „c / h“: Žádný takový soubor nebo adresář neexistuje
du: nemá přístup k 'a': Žádný takový soubor nebo adresář
du: nelze získat přístup k „b“: Žádný takový soubor nebo adresář
du: nelze získat přístup k „c / i“: Žádný takový soubor nebo adresář
du: nelze získat přístup k souboru „j“: Žádný takový soubor nebo adresář neexistuje
du: nelze získat přístup k „k“: Žádný takový soubor nebo adresář
du: Nelze získat přístup k l: Žádný takový soubor nebo adresář
Funguje to nesprávně, protože názvy adresářů jsou plné mezer. To nebyl váš záměr.
Můžete to opravit přidáním xargs replacement, tj.e -I následovně.
najít typ „a b c“ d | xargs -i du -d 0 -h0 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
Funguje správně, když používáte náhradu xargs. Všimněte si, že jsme použili -i, což je zkratka pro -I .
Dalším způsobem, jak můžeme dosáhnout stejného výsledku, je použití xargs null, -null, v kombinaci s volbou find -print0 následujícím způsobem.
najít typ „a b c“ d -print0 | xargs --null -i du -d 0 -h0 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
Skvělý! Nyní máme více než jeden způsob, jak se dostat do hloubky vesmíru souborového systému, aniž bychom se museli starat o kolizi s vesmírnou nevyžádanou cestou. Hned.
Xargs interaktivní
Možná nedůvěřujete, že xargs spouští všechny příkazy bez potvrzení. V takovém případě je xargs interactive nebo -p možnost, kterou potřebujete k řízení, které příkazy jsou spouštěny xargsem, jak je uvedeno níže.
najít typ „a b c“ d -print0 | xargs --null -i -p du -d 0 -hdu -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 ?… Ano
0 a b c / h
du -d 0 -h a b c / i j k l ?… Ne
Zde je spuštěn jakýkoli příkaz začínající na „y“ nebo „Y“. Jinak jsou příkazy ignorovány.
Soubor Xargs
Již máte soubor, soubor arg, připravený ke čtení do xargs. Váš program může někde čekat v adresáři, kde někdo jiný nebo jiná vaše instance vloží soubor arg. V tomto případě můžete zadat soubor jako možnost xargs pomocí -a arg-file namísto použití cat souboru | xargs… Následuje příklad souboru Xargs.
Pro zábavu si udělejme z vašich rutin čištění plochy arg-soubor, který můžeme použít.
Vyčištění pracovní plochy | tee arg-soubor190605_cleanup_desktop_files_sh.txt
190605_cleanup_desktop_lnk_files_sh.txt
190605_cleanup_desktop_un_files_sh.txt
Každý soubor obsahuje rutinu, kterou lze spustit pomocí bash. To znamená, že příkaz, který použijeme, je bash.
Pojďme spustit čisticí rutiny pomocí xargs.
xargs -a arg-soubor -i -P 99 bash -c 'echo ; . cleanup-desktop / ; '190605_cleanup_desktop_files_sh.txt
190605_cleanup_desktop_lnk_files_sh.txt
190605_cleanup_desktop_un_files_sh.txt
A funguje to!
Jen v případě, že potřebujeme specifikovat soubor arg namísto použití piped vstupu, přijde vhod volba xargs file.
Xargs nahradit
lhs_if_any | xargs -i other_args_etc | rhs_if_anyV neposlední řadě vám xargs replace -i umožňuje převzít plnou kontrolu nad formátem příkazu před jeho spuštěním. Lze použít libovolný znak. Podle konvence však většina programátorů bash používá toto nebo toto%. Výchozí hodnota je . -Řeknu xargs, že se použije výchozí. A je to považováno za zkratku. -Za mnou následoval náhradní znak podle vašeho výběru, který xargsovi řekne, jaký znak budete používat. Nepoužívejte běžné znaky, jako je písmeno a. To rozbije váš kód více než jakýkoli prostor nebo nový řádek, jaký kdy udělal.
Xargs paralelní
lhs_if_any | xargs -P n_ge_1 other_args_etc | rhs_if_anyXargs parallel -P umožňuje spouštět příkazy současně namísto v pořadí. Platné argumenty pro n_ge_1 nebo souběžnost najdete v xargs limits -show-limits. Například pokud
Maximální paralelismus (--max-procs nesmí být větší): 2147483647Můžete nastavit -P 2147483647 bez jakýchkoli chyb. V praxi můžete najít hezčí nastavení jako -P 99, které zlepšuje celkový výkon bez zvýšení režie pro správu souběžných procesů.
Následují příklady ukazující, jak může paralelní použití xargs zlepšit výkon.
Příklad) Počítání v pořadí versus paralelní pomocí xargs
Podívejme se, co se stane, když čas počítáme postupně pomocí xargs.
časová ozvěna 1… 1000 | xargs '-d' -i bash -c 'echo '…
998
999
1000
skutečný 1m13.927s
uživatel 0m6.994s
sys 0m15.184s
Nyní se podívejte, co se stane, pokud budeme počítat čas paralelně pomocí xargs.
časová ozvěna 1… 1000 | xargs -P 200 '-d' -i bash -c 'echo '…
998
999
1000
skutečný 0m13.554s
uživatel 0m6.446s
sys 0m14.293s
Významné zlepšení výkonu je pozorováno při použití xargs paralelně ke spouštění jednoduchých příkazů bez sdílených prostředků.
Příklad) Porovnání pořadí a načasování xargs paralelně
Podívejme se, co se stane, když příkaz spotřebuje čas CPU.
časová ozvěna 1… 10 | xargs '-d' -i bash -c 'sleep $ (($ RANDOM% 2)); ozvěna '1
2
3
4
5
6
7
8
9
10
skutečný 0m5.601s
uživatel 0m0.180s
sys 0m0.334s
Všimněte si, že všechny příkazy jsou dokončeny v pořadí.
Nyní se podívejte, co se stane, když je stejný příkaz spuštěn paralelně.
časová ozvěna 1… 10 | xargs -P 10 '-d' -i bash -c 'sleep $ (($ RANDOM% 2)); ozvěna '3
4
6
7
8
1
2
5
9
10
skutečný 0m1.257s
uživatel 0m0.60. léta
sys 0m0.225s
Příkazy 1, 2, 5 a 9 šly spát. Byli jsme však schopni snížit
čas na dokončení až o 78 procent.
Xargsův paralelní závěr
Jednoduché přidání xargs paralelně jako možnosti příkazového řádku může zlepšit výkon desetkrát. Měli byste však postupovat opatrně, když používáte procedury závislé na objednávce nebo když příkazy sdílejí prostředky.
Xargsův oddělovač
lhs_if_any | xargs '-dc' other_args_etc | rhs_if_anyXargs delimiter -d umožňuje nastavit oddělovač položek na libovolný znak c stejným způsobem, jako jsou oddělovače znaků nastaveny v příkazu cut.
Ve výchozím nastavení je -dc nastaveno na mezery vytvořené znakem nového řádku -d \ x0a.Při použití xargs null -0 je -dc nastaven na nulový znak -d \ x00.
Například můžete nastavit oddělovač na znak mezery, tj.E. -dc je '-d' v příkazovém řádku nebo ve vašem bash skriptu.
Oddělovač můžete nastavit na znak čárky, tj.E. -dc je '-d'.
Možnost oddělovače v xargs -d umožňuje nastavit oddělovač položek na libovolný znak, který si přejete.
Bash xargs příklady
Zde uvádíme příklady použití příkazu xargs v bash, včetně příkladu použití v příkazovém řádku a skriptů.
Příklady příkazů Bash xargs
Zde uvádíme příklady použití příkazu xargs v bash včetně příkladu použití sa bez vstupního potrubí.
Příklad) Vytvořte si vlastní vstup: zábava s xargs bez vstupu
Co dělá xargs sám doma?
xargsAhoj, je někdo doma??
…
(Ctrl-D)
Ahoj, je někdo doma??…
Zdá se, že jsme dostali naši otázku zpět jako odpověď, ale zdá se, že je to jen ozvěna.
Proč?
Jak jste si možná přečetli, o čem je xargs, převádí standardní vstup na argumenty příkazového řádku. Pokud nejsou k dispozici žádné možnosti a argumenty, chová se jako příkaz echo s vědomím kanálu. To je:
xargsAhoj, je někdo doma??
…
(Control-D) 2
Produkuje ekvivalentní výraz příkazového řádku echo implicitně
echo Dobrý den, je někdo doma?…2 Ve scénáři lze heredoc použít následovně.
xargs << EOF
Ahoj, je někdo doma??
…
EOF
echo Dobrý den, je někdo doma?…
Příklad) Použijte xargs jako zástupný symbol pro interaktivní kanály
Použití xargs na levé straně potrubí je paradoxní4 tak pojďme spustit bash v super omezeném režimu5.
4 Pipe vědomé příkazy nepotřebují xargs. Pipe nevědomé příkazy neví o xargs
5 Omezený režim, který resetuje každý řádek. Další omezení mohou být přidána později.
xargs -I bash -cr ""i = 1
ozvěna $ i
echo Ahoj!
Ahoj!
!!
bash: !!: příkaz nenalezen
i = 1; ozvěna $ i
1
CD…
bash: řádek 0: cd: omezeno
Příklad) Použijte xargs jako zástupný symbol pro interaktivní argumenty
Podle zprávy vývojových dovedností HackerRank z roku 20193, "Kalkulačky jsou nové hry.".„Více vývojářů do 38 let prosazuje kalkulačky jako svůj první kódovací projekt. 3 Statistiky založené na 71 281 vývojářích
Pojďme tedy sestavit kalkulačku pomocí xargs!
_ () echo $ (("$ @")); # kalkulačkazatímco :
dělat
_ $ (xargs)
Hotovo
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
Příklad) Statický generátor stránek
Předpokládejme, že máte několik tisíc souborů prostého textu, které chcete použít ke generování statického webu, a žádný ze souborů nemá název index. Názvy souborů zahrnují malá písmena ascii a pomlčku, pokud existuje.
Zde by vypadal řádek nebo dva v terminálu teoretického stroje běžícího bash. Zařízení bude mít další externí příkazy, včetně findutils a pandoc. Můžete použít jakýkoli ekvivalentní příkaz podle vašeho výběru.
# jsme v adresáři# zobrazit spoustu souborů
test -d "html" || mkdir -v $ _
nalézt . -hloubka 1 - maximální hloubka 1 - typ f \
| xargs -P 6000 -i bash -c "echo ; kočka | sed -e 's / $ / /' |
pandoc -thtml -o .html "
# zobrazit dvakrát tolik souborů, včetně souborů html
# Hotovo
Příklady skriptu Bash xargs
Příklad) Použijte xargs ke generování čtvercových matic
Tady je skript, který jsem připravil pro generování čtvercových matic pomocí xargs. Konkrétně využívá výhod chování pomocí volby -n a používá příkaz seq k posloupnostem čísel, které mají být použity v maticích.
#!/ bin / bash## čtvercová matice
## - generuje čtvercové matice
## verze 0.0.1 - počáteční
#######################################################
square-matrix-help ()
kočka << EOF
čtvercová matice
1 - objednávka
PŘÍKLADY
> čtvercová matice 1
1
> čtvercová matice 2
1 2
3 4
> čtvercová matice 3
1 2 3
4 5 6
7 8 9
EOF
square-matrix () local -i order; objednávka = $ 1;
test „$ order“ || $ FUNCNAME - pomoc; vrátit se ;
test $ order -gt 0 || $ FUNCNAME - pomoc; vrátit se ;
_ ()
seq $ (($ 1 ** 2)) | xargs -n $ 1
_ $ objednávka
#######################################################
pokud [ ! ]
pak
skutečný
jiný
exit 1 # špatné args
fi
#######################################################
čtvercová matice $ @
#######################################################
## generováno create-stub2.sh v0.1.2
## ve středu 29. května 2019 13:44:06 +0900
## viz
#######################################################
Zdroj: čtvercová matice.sh
Také jsem zahrnoval testovací program pro zobrazení skriptu v akci, generování všech čtvercových matic až 10 x 10.
#!/ bin / bash## test-square-matrix
## - generuje čtvercové matice až 10 x 10
## verze 0.0.1 - počáteční
#######################################################
test-square-matrix ()
test -f "čtvercová matice.sh "
. $ _ 1> / dev / null
místní i
pro i v 1… 10
dělat
echo "square-matrix ($ i)"
čtvercová matice $ i
Hotovo
#######################################################
pokud [$ # -eq 0]
pak
skutečný
jiný
exit 1 # špatné args
fi
#######################################################
test-square-matrix
#######################################################
## generováno create-stub2.sh v0.1.2
## ve středu 29. května 2019 13:40:08 +0900
## viz
#######################################################
Zdroj: test-square-matrix.sh
Zde můžete očekávat:
bash test-čtvercová matice.sh | hlavačtvercová matice (1)
1
čtvercová matice (2)
1 2
3 4
čtvercová matice (3)
1 2 3
4 5 6
7 8 9
…
Cvičení: Vylepšete zobrazení v terminálu použitím polstrování čísel
Když se pokusíme vygenerovat čtvercovou matici řádu 10 na 10, dostaneme následující výstup:
bash čtvercová matice.sh 101 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
Jako cvičení rozšiřte čtvercovou matici.sh umožňující výstup následujícím způsobem.
bash čtvercová matice.sh 10001 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
031033033344035366377038399040
041 042 043 044 045 046 047 048 049 050
051 052 053 054 055 056057 058 059 060
061 062 063 064 065 066 067 068 069 070
071 072 073 074 075 076 077 078 07 9080
081 082 083 084 085 086 087 088 089 090
091 092 093 094 095 096 097 098 099 100
Příklady praktického použití Bash xargs
Příklad) Vyhledejte soubory vzoru pomocí xargs grep
seznam souborů1 | xargs grep -e vzor1 list-files je příkaz, který vrací kandidátské cesty do souboru, který má být použit jako vstup pro grep pomocí příkazu xargs
Jako praktický příklad použití xargs v bash jsem vykopal xargs ze základny tajných kódů.
najít -typ f -název \ *.sh | wc -l994
Existuje 994 bash skriptů. Podívejme se, kolik příkazů xargs.
najít -typ f -název \ *.sh | xargs grep -e xargs vypíše všechny výskytyxargs v codebase.
…
najít -typ f -název \ *.sh | xargs grep -e xargs | wc -l
18
V základně kódů je 18 shod pro xargs. Nyní možná budeme chtít zjistit, kolik skriptů používá xargs.
najít -typ f -název \ *.sh | xargs grep | cut '-d:' '-f1' | třídit |uniq vypíše skripty pomocí xargs.
…
najít -typ f -název \ *.sh | xargs grep -e xargs | cut '-d:' '-f1' |
třídit | uniq | wc -l
10
Skvělý! V základně kódů je 10 skriptů s xargs. Uvidíme, co jsou zač.
najít -typ f -název \ *.sh | xargs grep -e xargs | cut '-d:' '-f1' | třídit | uniqvim $ ( !! )
Shrnutí zjištění
-
- Vyhledejte a zničte soubory obsahující vzor v názvu souboru
-
- Seznam informací o souborech na lhs potrubí
-
- Udělejte soubory spustitelnými
-
- Seznam dirnam souborů
-
- Vyčistit vše
-
- Soubory ZIP
-
- Seznam základních jmen souborů
Příklad) Nainstalujte software ze seznamu pomocí apt-get v Ubuntu
Při upgradu Ubuntu možná budete muset po zálohování systému nainstalovat nový software. Předpokládejme, že máte seznam softwaru pro instalaci pomocí apt-get v Ubuntu.
sudo dpkg --get-výběry | grep '[[: space:]] install $' |\ awk 'print $ 1'> instalační_software
#…
cat install_software | xargs sudo apt-get install
Příklad) Curl seige pomocí xargs v bash
Předpokládejme, že máte spoustu adres URL vedoucích k jedinému uzlu někde na internetu a chtěli byste se pokládat seige pomocí curl v bash. Výhodně je to jeden z vašich uzlů a seige není ve vašem produkčním prostředí. Zde je způsob, jakým jsme položili seige pomocí xargs v bash.
#declare -f filtrfiltr ()
grep -o -e 'loc [^<]*' | cut '-d>'-f2'
get-arg-file ()
curl https: // linuxhint.com / sitemap.xml - tichý \
| filtr \
| xargs -i curl --silent \
| filtr \
| xargs -i echo > soubor arg
#declare -f curl
zvlnění ()
echo (falešný) $ FUNCNAME "$ @"
deklarovat -xf curl
užitečné zatížení ()
test -f "soubor arg" || vrátit se
xargs -P 1000 -a arg-file -i echo curl | bash 1> / dev / null
seige ()
test -f "soubor arg" || získat - $ _
užitečné zatížení
seige
Bash xargs debug
Když sedíte před terminálem, jste šéf. Když se však něco pokazí, pomůže to, pokud víte, jak ve skutečnosti ladit bash skripty jako šéf.
Hrát na jistotu, mít metodu k ověření úspěchu při použití xargs v bash namísto slepého očekávání, že vše bude v pořádku, je vysoce doporučeno. To znamená, že musíte zajistit, aby všechny příkazy s úspěchem a neúspěchem nebyly ponechány nezaškrtnuté.
Metody
- Velikost standardního chybového výstupu
Pokud standardní chyba obsahuje 1 nebo více znaků, něco se pokazilo - Součet kódů ukončení příkazu
Pokud je součet výstupních kódů větší než 0, něco se pokazilo - Ověření užitečného zatížení
Pokud chybí část užitečného zatížení, něco se pokazilo - Konec ověření skriptu
- Spouštění příkazů xargs jako skriptu, pokud není dosaženo konce skriptu, došlo k chybě. Pamatujte, že je nastaven errexit a příkazy jsou spouštěny zevnitř funkce.
- Jiná metoda
Pokud se výsledek liší od toho, co se očekává, pak se mohlo něco pokazit
Příklad) Ladění xargs pomocí velikosti standardního chybového výstupu
Zde je anonymní funkce, kterou testujeme ladění xargs pomocí chyby stardart.
# prohlásit -f _, i.E. Níže uvedený kód jsem nenapsal# pokud zjistíte, že jste trochu rezaví, prohlásit jsem napsal další výukový program
#
jak příkaz declare funguje v bash
_ ()
rm -vf errout;
klepněte na $ _;
ozvěna 1… 10 | xargs -x -P 10 '-d' -i bash -c "test $ (($ RANDOM% $ 1)) -eq 0 ||
echo 1> & 2; výstup; ; echo "2> errout;
test ! $ (wc < errout -c ) -gt 0 || echo something went wrong…
## test
_ 1 # pravděpodobnost selhání (= 1-1 / 1 = 0%)
_ 2 # pravděpodobnost poruchy (= 1-1 / 2 = 1/2 = 50%)
_ 3 # pravděpodobnost selhání (= 1-1 / 3 = 2/3 = 60%)
…
Pokud nepoužíváte standardní chybu pro nic jiného, použití velikosti standardní chyby k ladění xargs je jednou z metod, která pro vás může fungovat.
Bash xargs funkce
Někdy chcete použít funkce, které jste definovali v xargs. Abychom to mohli udělat, musíme funkci zpřístupnit pro xargs. Zde je návod.
#declare -f __ ()
ozvěna $ @ ^^
echo a… z 1… 9 | xargs '-d' -i bash -c "_ "
bash: _: příkaz nebyl nalezen
…
deklarovat -xf _
echo a… z 1… 9 | xargs '-d' -i bash -c "_ "
A1
A2
A3
…
# nebo
echo a… z 1… 9 | xargs '-d' -i echo "_ " | bash
…
Z7
Z8
Z9
Všimněte si, že výše uvedený příklad interaktivní relace lze zrychlit pomocí paralelního bash xargs.
Závěr
Xargs je jedním z mnoha externích příkazů, které byste měli znát v bash. Při psaní této příručky k příkazu xargs jsem se sám naučil několik dalších možností. Doporučuje se kontrolovat každou tak často. Teprve potom budete moci využít xargs k jeho skutečnému potenciálu. Do té doby kódujte dál.
