Bash Xargs comanda nel modo più duro con l'esempio

Quando inizi a imparare a programmare bash nel modo più duro, nessuno ti parla del comando xargs. Da allora, sei riuscito a raccogliere abbastanza xarg per tirare avanti senza rompere troppo. Ora ti ritrovi a chiederti ― E tutte quelle altre opzioni?? Posso farlo? E se volessi.. ?

Ormai probabilmente hai una comprensione abbastanza buona di come eseguire il comando in bash. Ma cosa succede se si desidera eseguire flussi di comandi in sequenza o talvolta in parallelo?? È qui che ci troviamo ad usare xargs.

Qui speriamo di rispondere a tutte queste domande e altro su bash e il comando xargs con l'esempio.

Che cos'è xargs in bash??

xargs è un comando esterno usato per convertire l'input standard in argomenti della riga di comando che si dice stia per "argomentazioni estese".” È stato creato principalmente per essere utilizzato con comandi non creati per gestire input con pipe o input standard come rm, cp, echo ¹ e altri comandi esterni che accettano solo argomenti come parametri.

¹ Sebbene la maggior parte dei sistemi sia dotata di un comando echo, echo è integrato in bash; A meno che non si chiami il comando echo, viene utilizzato l'eco integrato. Allo stesso modo, i builtin di bash non sono a conoscenza dell'input con pipe.

Opzioni Xargs con esempi bash

Esaminiamo xargs e le sue opzioni con esempi in bash. Insieme al trattamento convenzionale per le opzioni della riga di comando previsto con xargs, le opzioni sono raggruppate per oggetti come ottenere informazioni o modificare il comportamento.

Informazioni su Xargs

Ecco le opzioni che forniscono informazioni su xargs.

Xargs aiuto

xargs --help
Utilizzo: xargs [OPTION]... COMANDO [INITIAL-ARGS]..
Esegui COMANDO con argomenti INITIAL-ARGS e più argomenti letti dall'input.
Anche gli argomenti obbligatori e facoltativi per le opzioni lunghe sono
obbligatorio o facoltativo per l'opzione breve corrispondente.
-0, --null                  gli elementi sono separati da un null, non da uno spazio bianco;
disabilita l'elaborazione di citazioni e barre rovesciate e
elaborazione logica EOF
-a, --arg-file=FILE          legge gli argomenti da FILE, non l'input standard
-d, --delimiter=CARATTERE    gli elementi nel flusso di input sono separati da CARATTERE,
non da spazi bianchi; disabilita citazione e barra rovesciata
elaborazione e elaborazione logica EOF
-E END                      imposta la stringa EOF logica; se END si presenta come una linea
di input, il resto dell'input viene ignorato
(ignorato se è stato specificato -0 o -d)
-e, --eof[=END]              equivalente a -E END se viene specificato END;
altrimenti, non c'è una stringa di fine file
-I R                        come --replace=R
-i, --replace[=R]            sostituisci R in INITIAL-ARGS con i nomi letti
dall'input standard; se R non è specificato,
presumi
-L, --max-lines=MAX-LINES    utilizza al massimo MAX-LINES linee di input non vuote per
riga di comando
-l[MAX-LINES]                simile a -L ma il valore predefinito è al massimo un non-
riga di input vuota se MAX-LINES non è specificato
-n, --max-args=MAX-ARGS      utilizza al massimo MAX-ARGS argomenti per riga di comando
-P, --max-procs=MAX-PROCS    esegue al massimo i processi MAX-PROCS alla volta
-p, --interactive            prompt prima di eseguire i comandi
--process-slot-var=VAR   imposta la variabile di ambiente VAR nei processi figlio child
-r, --no-run-if-empty        se non ci sono argomenti, non eseguire COMMAND;
se questa opzione non viene data, COMANDO sarà
corri almeno una volta
-s, --max-chars=MAX-CHARS    limita la lunghezza della riga di comando a MAX-CHARS
--show-limits            mostra limiti sulla lunghezza della riga di comando
-t, --verbose                stampa i comandi prima di eseguirli
-x, --exit                  esci se la dimensione (vedi -s) viene superata
--help                  visualizza questo aiuto ed esci
--version                visualizza le informazioni sulla versione ed esci

Fare riferimento a xargs help come riferimento rapido all'utilizzo e alle opzioni di xargs.

Versione Xargs

xargs --version
xargs (GNU findutils) 4.6.0

Limiti di Xargs

Anche xargs ha i suoi limiti. L'opzione -show-limits per xargs mostra i limiti usati da xargs prima di eseguire i comandi. I limiti effettivi dipendono dal tuo ambiente. Tuttavia, per la maggior parte degli utenti, questo è sufficiente. I limiti possono essere modificati dalla riga di comando, vedere esempi.

Esempio) Il tuo ambiente xargs limiti

xargs --show-limits
Le tue variabili d'ambiente occupano 6234 byte
Limite superiore POSIX sulla lunghezza dell'argomento (questo sistema): 23718
POSIX più piccolo limite massimo consentito sulla lunghezza dell'argomento (tutti i sistemi): 4096
Lunghezza massima del comando che potremmo effettivamente usare: 17484
Dimensione del buffer dei comandi che stiamo effettivamente utilizzando: 23718
Parallelismo massimo (--max-procs non deve essere maggiore): 2147483647

L'esecuzione di xargs continuerà ora e proverà a leggere il suo input ed eseguire i comandi; se questo non è ciò che volevi che accadesse, digita la sequenza di tasti di fine file.

Attenzione: echo verrà eseguito almeno una volta.  Se non vuoi che ciò accada, premi il tasto di interruzione.

Nota che il comando che verrebbe eseguito come conseguenza di xargs è echo, il comando predefinito di xargs.

Esempio) Limiti Xargs con un limite del buffer dei comandi modificato adjusted

xargs --show-limits -s 1
Le tue variabili d'ambiente occupano 9479 byte
Limite superiore POSIX sulla lunghezza dell'argomento (questo sistema): 20473
POSIX più piccolo limite massimo consentito sulla lunghezza dell'argomento (tutti i sistemi): 4096
Lunghezza massima del comando che potremmo effettivamente usare: 10994
Dimensione del buffer dei comandi che stiamo effettivamente utilizzando: 1
Parallelismo massimo (--max-procs non deve essere maggiore): 2147483647
…
Attenzione: echo verrà eseguito almeno una volta.  Se non vuoi che ciò accada,
quindi premere il tasto di interruzione.
xargs: impossibile inserire un singolo argomento all'interno del limite di dimensione dell'elenco di argomenti

Nota che gli errori verranno visualizzati in basso dopo Avvisi se presenti-. Abbiamo un errore "xargs: impossibile inserire un singolo argomento all'interno del limite di dimensione dell'elenco di argomenti", il che significa solo che stiamo tentando di lavorare al di fuori della dimensione consentita del buffer di comando che è impostata su un carattere.

Il buffer dei comandi contiene il comando seguito da tutti gli argomenti inclusi gli spazi.
Nel caso del comando in questo esempio di opzione xargs, il buffer dei comandi è

"eco"

che contiene 4 caratteri.
Quindi, dobbiamo impostare la dimensione del buffer dei comandi su un valore maggiore o uguale a 5 come segue. Tieni presente che il consumo del buffer dei comandi sarà uguale a length_of_command + length_args_include_spaces_plus_one  + 1.

xargs --show-limits -s 5

# Non piu "xargs:impossibile inserire un singolo argomento entro il limite di dimensione dell'elenco di argomenti" errore

Ma cosa succede se il nostro comando ha argomenti??

si | xargs -t --show-limits -t -s 6 # verrà eseguito con il seguente output
eco sì
…

Xargs verbose

lhs | xargs -t other_xargs_options_if_any | rhs

L'opzione -t può essere utilizzata per mostrare i comandi eseguiti da xargs come output su fd2, errore standard. Questo è xargs -t può essere annullato reindirizzando l'errore standard a /dev/null come segue.

xargs -t 2>/dev/null

Esempio) Sì una volta

si | testa -n 5 | xargs -t vero
vero sì sì sì sì

Esempio) Sì 5 volte

si | testa -n 5 | xargs -t -I vero
vero sì
vero sì
vero sì
vero sì
vero sì

Comportamento di Xargs

Nessun comando è completo senza opzioni per modificare il comportamento di runtime. Xargs non è diverso. Ecco le opzioni che ti permettono di cambiarne il comportamento.

Xargs nullo

lhs | xargs -0 other_xargs_options_if_any | rhs

L'opzione -0 può essere usata per dire a xargs di usare null invece di spazi bianchi. Disabilita anche le virgolette e le sequenze di escape.

si | testa -n 5 | sed "s/.*/cul-"de"-'sac'/" | xargs -I echo -en "\n\x00"
vicolo cieco
vicolo cieco
vicolo cieco
vicolo cieco
vicolo cieco
si | testa -n 5 | sed "s/.*/cul-"de"-'sac'/" | xargs -0 -I echo -en "\n\x00"
cul-"de"-'sac'
cul-"de"-'sac'
cul-"de"-'sac'
cul-"de"-'sac'
cul-"de"-'sac'

Caso d'uso Xargs nullo

L'uso inteso per xargs null è per la gestione di casi come quando gli elementi contengono spazi come file contenenti spazi o caratteri di nuova riga.

Supponiamo di avere una directory "a b c" che include spazi nel nome di una directory.

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

Vuoi eseguire un comando su ogni directory in "a b c" usando il comando trova.

Puoi provare quanto segue:

trova "a b c" -tipo d | xargs du -d 0 -h
du: impossibile accedere a 'a': nessun file o directory di questo tipo
du: impossibile accedere a 'b': nessun file o directory di questo tipo
du: impossibile accedere a 'c': nessun file o directory di questo tipo
du: impossibile accedere a 'a': nessun file o directory di questo tipo
du: impossibile accedere a 'b': nessun file o directory di questo tipo
du: impossibile accedere a 'c/de': nessun file o directory di questo tipo
du: impossibile accedere a 'a': nessun file o directory di questo tipo
du: impossibile accedere a 'b': nessun file o directory di questo tipo
du: impossibile accedere a 'c/fg': nessun file o directory di questo tipo
du: impossibile accedere a 'a': nessun file o directory di questo tipo
du: impossibile accedere a 'b': nessun file o directory di questo tipo
du: impossibile accedere a 'c/h': nessun file o directory di questo tipo
du: impossibile accedere a 'a': nessun file o directory di questo tipo
du: impossibile accedere a 'b': nessun file o directory di questo tipo
du: impossibile accedere a 'c/i': nessun file o directory di questo tipo
du: impossibile accedere a 'j': nessun file o directory di questo tipo
du: impossibile accedere a 'k': nessun file o directory di questo tipo
du: impossibile accedere a 'l': nessun file o directory di questo tipo

Funziona in modo errato perché i nomi delle nostre directory sono pieni di spazi. Questa non era la tua intenzione.

Puoi risolvere questo problema aggiungendo la sostituzione di xargs, i.e -I come segue.

trova "a b c" -tipo 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

Funziona correttamente quando si utilizza la sostituzione di xargs. Nota che abbiamo usato -i, che è l'abbreviazione di -I .

Un altro modo per ottenere lo stesso risultato è usare xargs null, -null, in combinazione con l'opzione find -print0 come segue.

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

grande! Ora abbiamo più di un modo per farci strada a pugni nell'universo del filesystem senza doverci preoccupare di scontrarci con la spazzatura spaziale il nostro viaggio. Proprio su.

Xargs interattivo

Forse non ti fidi di xargs per eseguire tutti i comandi senza conferma. In tal caso, xargs interactive o -p è l'opzione di cui hai bisogno per controllare quali comandi vengono eseguiti da xargs come segue.

trova "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 ?… sì
0       a b c/fg
du -d 0 -h a b c/h ?… Sì
0       a b c/h
du -d 0 -h a b c/i j k l ?… no

Qui viene eseguito qualsiasi comando che inizia con 'y' o 'Y'. In caso contrario, i comandi vengono ignorati.

File Xargs

Hai già un file, arg-file, pronto per essere letto in xargs. Il tuo programma potrebbe essere in attesa in una directory da qualche parte che qualcun altro o un'altra istanza di te stesso inserisca un file arg. In questo caso, puoi specificare il file come opzione per xargs usando -a arg-file invece di dover usare cat file | xargs… Seguono esempi di file Xargs.

Solo per divertimento, trasformiamo le tue routine di pulizia del desktop in un file arg che possiamo usare.

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

Ogni file contiene una routine che può essere eseguita usando bash. Ciò significa che il comando che useremo è bash.

Eseguiamo le routine di pulizia usando xargs.

xargs -a arg-file -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

E funziona!
Nel caso in cui abbiamo bisogno di specificare un arg-file invece di usare l'input con pipe, l'opzione xargs file è utile.

Xargs sostituisce

lhs_if_any | xargs -i other_args_etc | rhs_if_any

Ultimo ma non meno importante, xargs replace -i ti consente di avere il pieno controllo sul formato del comando prima che venga eseguito. Può essere usato qualsiasi carattere. Tuttavia, seguendo la convenzione la maggior parte dei programmatori bash usa questo o questo %. Tieni presente che il valore predefinito è . -dico a xargs che verrai usato come predefinito. Ed è considerato stenografia. -Ho seguito da un carattere sostitutivo a tua scelta che dice a xargs quale carattere utilizzerai. Evita di usare caratteri comuni come la lettera a. Ciò romperà il tuo codice più di qualsiasi spazio o nuova riga mai fatto.

Xargs parallelo

lhs_if_any | xargs -P n_ge_1 other_args_etc | rhs_if_any

Xargs parallel -P consente di eseguire i comandi contemporaneamente anziché in sequenza. Fare riferimento a xargs limits -show-limits per argomenti validi per n_ge_1 o concorrenza. Ad esempio, se

Parallelismo massimo (--max-procs non deve essere maggiore): 2147483647

È possibile impostare -P 2147483647 senza errori. In pratica, potresti trovare un'impostazione migliore come -P 99 che migliora le prestazioni complessive senza aumentare il sovraccarico per gestire i processi simultanei.

Seguono esempi che mostrano come l'utilizzo di xargs parallel può migliorare le prestazioni.

Esempio) Conteggio in sequenza rispetto a quello parallelo utilizzando xargs

Vediamo cosa succede quando contiamo il tempo in sequenza usando xargs.

tempo eco 1… 1000 | xargs '-d ' -i bash -c 'echo '
…
998
999
1000
reale    1m13.927 secondi
utente    0m6.994 secondi
sis     0m15.184s

Ora guarda cosa succede se contiamo il tempo in parallelo usando xargs.

tempo eco 1… 1000 | xargs -P 200 '-d ' -i bash -c 'echo '
…
998
999
1000
reale    0m13.554s
utente    0m6.446s
sis     0m14.293s

Si osserva un significativo miglioramento delle prestazioni utilizzando xargs parallel per eseguire semplici comandi senza risorse condivise.

Esempio) Confronto dell'ordine e dei tempi di xargs parallel

Vediamo cosa succede quando un comando consuma tempo CPU.

tempo eco 1… 10 | xargs '-d ' -i bash -c 'sleep $(( $RANDOM % 2 )) ; eco '
1
2
3
4
5
6
7
8
9
10
reale    0m5.601s
utente    0m0.180s
sis     0m0.334s

Nota che tutti i comandi sono completi in ordine.

Ora guarda cosa succede quando lo stesso comando viene eseguito in parallelo.

tempo eco 1… 10 | xargs -P 10 '-d ' -i bash -c 'sleep $(( $RANDOM % 2 )) ; eco '
3
4
6
7
8
1
2
5
9
10
reale    0m1.257s
utente    0m0.060s
sis     0m0.225s
I comandi 1, 2, 5 e 9 si sono addormentati. Tuttavia, siamo stati in grado di ridurre il
tempo per completare fino al 78 percento.

Conclusione parallela di Xargs

La semplice aggiunta di xargs parallel come opzione della riga di comando può migliorare le prestazioni di dieci volte. Tuttavia, è necessario procedere con cautela quando si utilizzano procedure dipendenti dall'ordine o quando i comandi condividono risorse.

Delimitatore Xargs

lhs_if_any | xargs '-dc' other_args_etc | rhs_if_any

Delimitatore Xargs -d consente di impostare il separatore di elementi su qualsiasi carattere c allo stesso modo in cui i caratteri delimitatori sono impostati nel comando taglia.

Per impostazione predefinita -dc è impostato su uno spazio vuoto creato dal carattere di nuova riga -d\x0a.
Quando si utilizza xargs null -0, -dc è impostato sul carattere null -d\x00.

Ad esempio, puoi impostare il delimitatore sul carattere spazio, i.e. -dc è '-d ' in una riga di comando o nel tuo script bash.

Puoi impostare il delimitatore sul carattere virgola, i.e. -dc è '-d,'.

L'opzione delimitatore in xargs -d ti consente di impostare il separatore di elementi su qualsiasi carattere desideri.

Esempi di Bash xargs

Qui copriamo gli usi di esempio del comando xargs in bash incluso l'uso di esempio nella riga di comando e negli script.

Esempi di comandi Bash xargs

Qui trattiamo l'uso di esempio della riga di comando del comando xargs in bash incluso l'uso di esempio con e senza input con pipe.

Esempio) Dai il tuo contributo: divertiti con xargs senza input

Cosa fa xargs a casa da solo?

xargs
Ciao, c'è qualcuno in casa??
…
(Ctrl-D)
Ciao, c'è qualcuno in casa??…

Sembra che abbiamo ricevuto la nostra domanda come risposta, ma sembra essere solo un'eco.

Perché?

Come potresti aver letto in cosa tratta xargs, converte l'input standard in argomenti della riga di comando. Se non vengono fornite opzioni e argomenti, si comporta come un comando echo pipe consapevole pipe. Questo è:

xargs
Ciao, c'è qualcuno in casa??
…
(Control-D) 2

Produce implicitamente l'espressione della riga di comando echo equivalente

echo Ciao, c'è qualcuno in casa??…
2 In uno script, heredoc può essere usato come segue.
xargs << EOF
Ciao, c'è qualcuno in casa??
…
EOF
echo Ciao, c'è qualcuno in casa??…

Esempio) Usa xargs come segnaposto per pipe interattive

L'uso di xargs sul lato sinistro di una pipe è paradossale⁴ quindi eseguiamo bash in modalità super limitata⁵.

⁴ I comandi che riconoscono le pipe non hanno bisogno di xargs. I comandi ignari della pipe non conoscono xargs

⁵ Modalità ristretta che ripristina ogni riga. Altre restrizioni possono essere aggiunte in seguito.

xargs -I bash -cr ""
i=1
eco $i
eco Ciao!
Ciao!
!!
bash: !!: comando non trovato
io=1; eco $i
1
CD…
bash: riga 0: cd: limitato

Esempio) Usa xargs come segnaposto per argomenti interattivi

Secondo l'HackerRank Developer Skills Report 2019³,  "Le calcolatrici sono i nuovi giochi."Più sviluppatori sotto i 38 anni stanno spingendo i calcolatori come loro primo progetto di codificacoding. ³ Approfondimenti basati su 71.281 sviluppatori

Quindi, costruiamo una calcolatrice usando xargs!

_() echo $(( "$@" )) ; # calcolatrice
mentre :
fare
_ $( xargs )
fatto
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

Esempio) Generatore di siti statici

Supponiamo di avere qualche migliaio di file di testo normale che desideri utilizzare per generare un sito statico e nessuno dei file si chiama index. I nomi dei file includono caratteri ascii minuscoli e un trattino se presente.

Ecco come sarebbero una o due righe nel terminale di una macchina teorica che esegue bash. La macchina avrà altri comandi esterni inclusi findutils e pandoc. Puoi usare qualsiasi comando equivalente a tua scelta.

# siamo nella directory
# vedi molti file

test -d "html" || mkdir -v $_
trova . -profondità minima 1 -profondità massima 1 -tipo f \
| xargs -P 6000 -i bash -c "echo ; cat | sed -e 's/$/  /' |
pandoc -thtml -o .html"

# vedi il doppio dei file ora inclusi i file html
# fatto

Esempi di script Bash xargs

Esempio) Usa xargs per generare matrici quadrate

Ecco uno script che ho preparato per generare matrici quadrate usando xargs. Nello specifico, sfrutta il comportamento utilizzando l'opzione -n ​​e utilizza il comando seq per sequenze di numeri da utilizzare nelle matrici.

#!/bin/bash
## matrice-quadrata
## - genera matrici quadrate
## versione 0.0.1 - iniziale
#################################################
matrice-quadrata-aiuto()

gatto << EOF
matrice quadrata square
1 - ordine
ESEMPI
> matrice quadrata 1
1
> matrice quadrata 2
1 2
3 4
> matrice quadrata 3
1 2 3
4 5 6
7 8 9
EOF


matrice-quadrata() local -i order ; ordine=$1 ;
prova "$ordine" || $FUNCNAME-help ; ritorno ;
prova $ordine -gt 0 || $FUNCNAME-help ; ritorno ;
_()
seq $(( $1 ** 2 )) | xargs -n $1

_ $ordine

#################################################
Se [ ! ]
poi
vero
altro
exit 1 # argomenti errati
fi
#################################################
matrice quadrata $@
#################################################
## generato da create-stub2.sh v0.1.2
## il mer, 29 maggio 2019 13:44:06 +0900
## vedi
#################################################

Fonte: matrice quadrata.sh

Ho anche incluso un programma di test per mostrare lo script in azione, generando tutte le matrici quadrate fino a 10 x 10.

#!/bin/bash
## test-matrice-quadrata
## - genera matrici quadrate fino a 10 x 10
## versione 0.0.1 - iniziale
#################################################
test-matrice-quadrata()
test -f "matrice quadrata.sh"
. $_ 1>/dev/null
locale io
per io in 1… 10
fare
echo "matrice quadrata($i)"
matrice quadrata $i
fatto

#################################################
if [ $# -eq 0 ]
poi
vero
altro
exit 1 # argomenti errati
fi
#################################################
test-matrice-quadrata
#################################################
## generato da create-stub2.sh v0.1.2
## il mer, 29 maggio 2019 13:40:08 +0900
## vedi
#################################################

Fonte: test-square-matrix.sh

Ecco cosa aspettarsi:

bash test-matrice-quadrata.sh | testa
matrice quadrata(1)
1
matrice quadrata(2)
1 2
3 4
matrice quadrata(3)
1 2 3
4 5 6
7 8 9
…

Esercizio: Migliora la visualizzazione nel terminale applicando la spaziatura interna ai numeri

Quando proviamo a generare la matrice quadrata di ordine 10 per 10, otteniamo il seguente output:

bash matrice quadrata.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 99 100

Come esercizio estendi la matrice quadrata.sh per consentire l'output come segue.

bash matrice quadrata.sh 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 esempi di uso pratico

Esempio) Cerca file per un pattern usando xargs grep

file-elenco¹ | xargs grep -e modello

¹ list-files è un comando che restituisce i percorsi candidati al file da prendere come input per grep tramite il comando xargs

Come esempio pratico di xargs in bash, ho scoperto xargs da una base di codice segreta.

trova -tipo f -nome \*.sh | wc -l
994

Ci sono 994 script bash. Vediamo quanti sono i comandi xargs.

trova -tipo f -nome \*.sh | xargs grep -e xargs elenca tutte le occorrenze
di xargs nel codebase.
…
trova -tipo f -nome \*.sh | xargs grep -e xargs | wc -l
18

Ci sono 18 corrispondenze per xargs nel codebase. Ora potremmo voler capire quanti script usano xargs.

trova -tipo f -nome \*.sh | xargs grep | taglia '-d:' '-f1' | ordina |
uniq elenca gli script usando xargs.
…
trova -tipo f -nome \*.sh | xargs grep -e xargs | taglia '-d:' '-f1' |
ordina | unico | wc -l
10

grande! Ci sono 10 script con xargs nel codebase. Vediamo quali sono.

trova -tipo f -nome \*.sh | xargs grep -e xargs | taglia '-d:' '-f1' | ordina | unico
vim $( !! )

Riepilogo dei risultati

• • Cerca e distruggi i file che contengono un modello nel nome del file

trova $percorso -type f -name \*$modello\* | xargs rm -vf

• • Elenca le informazioni sui file a sinistra del tubo

trova-file | xargs ls -al

• • Rendi eseguibili i file

trova-file | xargs chmod +x

• • Elenca i nomi dei file

trova-file | xargs -I nome dir ""

• • Elimina tutto

percorsi da eliminare | xargs rm -rvf

• • File zip

trova-file-da-zip | xargs -I archivio-$( data +%s )

• • Elenca i nomi di base dei file

trova-file | xargs -I nomebase

Esempio) Installa il software da un elenco usando apt-get in Ubuntu

Quando si aggiorna Ubuntu, dopo aver eseguito il backup del sistema potrebbe essere necessario installare un nuovo software. Supponiamo di avere un elenco di software da installare utilizzando apt-get in Ubuntu.

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

Esempio) Curl sige usando xargs in bash

Supponiamo che tu abbia un mucchio di URL che portano a un singolo nodo da qualche parte su Internet e desideri impostare un assedio usando curl in bash. Preferibilmente, questo è uno dei tuoi nodi e l'assedio non è nel tuo ambiente di produzione. Ecco come poniamo l'assedio usando xargs in bash.

#declar -f filter
filtro ()

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

get-arg-file()

ricciolo https://linuxhint.com/mappa del sito.xml --silent \
| filtro \
| xargs -i curl --silent \
| filtro \
| xargs -i echo > arg-file

#declare -f curl
arricciare ()

echo (falso) $FUNCNAME "$@"

dichiarare -xf curl
carico utile()

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

assedio()

test -f "file-arg" || ottenere-$_
carico utile

assedio

Bash xargs debug

Quando ti siedi davanti al terminal sei il capo. Tuttavia, quando qualcosa va storto, è utile sapere come eseguire effettivamente il debug degli script bash come un capo.

Giocare sul sicuro, avere un metodo per convalidare il successo quando si utilizza xargs in bash piuttosto che aspettarsi ciecamente che tutto andrà bene è altamente raccomandato. Cioè, devi assicurarti che tutti i comandi completi di successo e fallimento non siano lasciati deselezionati.

metodi

• Dimensione dell'output dell'errore standard
  Se l'errore standard contiene 1 o più caratteri, qualcosa è andato storto
• Somma dei codici di uscita dei comandi
  Se la somma dei codici di uscita è maggiore di 0, qualcosa è andato storto
• Convalida del carico utile
  Se manca un pezzo del carico utile, qualcosa è andato storto
• Fine della convalida dello script
• Eseguendo i comandi xargs come script, se la fine dello script non viene raggiunta qualcosa è andato storto. Nota che errexit è impostato e i comandi vengono eseguiti dall'interno di una funzione.
• Altro metodo
  Se il risultato è diverso da quello previsto, qualcosa potrebbe essere andato storto

Esempio) Debug di xargs utilizzando la dimensione dell'output dell'errore standard

Ecco una funzione anonima che testiamo il debug di xargs usando l'errore stardart.

# dichiara -f _, i.e. Non ho scritto il codice qui sotto
# se ti accorgi di essere un po' arrugginito dichiari che ho scritto un altro tutorial su
#
come funziona il comando di dichiarazione in bash
_ ()

rm -vf errore;
tocca $_;
echo 1… 10 | xargs -x -P 10 '-d ' -i bash -c "test $(( $RANDOM % $1 )) -eq 0 ||
eco 1>&2 ; Uscita ; ; echo " 2> errore;
test ! $( wc < errout -c ) -gt 0 || echo something went wrong…

## prova
_ 1 # probabilità di fallimento (=1-1/1=0%)
_ 2 # probabilità di fallimento (=1-1/2=1/2=50%)
_ 3 # probabilmente di fallimento (=1-1/3=2/3=60%)
…

Se non usi l'errore standard per nient'altro, usare la dimensione dell'errore standard per eseguire il debug di xargsèun metodo che potrebbe funzionare per te.

Funzioni di Bash xargs

A volte quello che vuoi fare è usare le funzioni che hai definito in xargs. Per farlo dobbiamo rendere disponibile la funzione a xargs. Ecco come.

#dichiarare -f _
_ ()

eco $@^^

echo a… z1… 9 | xargs '-d ' -i bash -c "_ "
bash: _: comando non trovato
…
dichiarare -xf _
echo a… z1… 9 | xargs '-d ' -i bash -c "_ "
A1
la2
LA3
…
# o
echo a… z1… 9 | xargs '-d ' -i echo "_ " | bash
…
Z7
Z8
Z9

Nota che l'esempio di sessione interattiva sopra può essere velocizzato usando bash xargs parallel.

Conclusione

Xargs è uno dei tanti comandi esterni che è meglio conoscere in bash. Scrivendo questa guida sul comando xargs, ho appreso personalmente alcune opzioni extra. Si consiglia di rivedere ogni tanto. Solo allora sarai in grado di utilizzare xargs al suo vero potenziale. Fino ad allora, codice attivo.