Espansione di bash Shell Espansione del tutore, espansione dei parametri e altro ancora
- Ambiente
- Sostituzione del comando
- Sostituzione del processo
- Sostituzione variabile
- Espansione del tutore
- Espansione dei parametri
- Parametri posizionali
- Espansione di Tilde
- Sostituzione aritmetica
- Divisione delle parole
- Espansione del nome file
- Conclusione
Ambiente
Al fine di testare tutte le funzionalità di espansioni bash di Shell, dobbiamo assicurarci di eseguire una versione recente di Bash. Di seguito sono riportate le informazioni del sistema per questo articolo. I test in questo articolo sono in esecuzione su Ubuntu 19.10 come mostrato di seguito.
$ uname -a
Linux Instance-1 5.3.0-1014-GCP #15-Obuntu SMP mar 3 04:14:57
UTC 2020 x86_64 x86_64 x86_64 GNU/Linux
La versione bash per questi test è Bash versione 5, che è abbastanza recente. Le versioni precedenti di Bash mancano un sacco di funzionalità.
$ Bash -Vversion
Gnu Bash, versione 5.0.3 (1) -release (x86_64-PC-Linux-Gnu)
Copyright (C) 2019 Free Software Foundation, Inc.
Licenza GPLV3+: GNU GPL versione 3 o successiva
Sostituzione del comando
La sostituzione dei comandi consente l'esecuzione di uno o più comandi e l'acquisizione di output e azioni da tali comandi e includerli in un altro comando tutto in una riga o meno righe rispetto a tutti i comandi separatamente. La sostituzione del comando ha due sintassi; La sintassi più popolare è la sintassi del backtick in cui il comando da eseguire è racchiuso in due backquote o backtick. L'altra sintassi che è altrettanto potente racchiude i comandi nella sintassi di $ () e l'output può essere utilizzata da quella nuova espansione. Diamo un'occhiata a una serie di esempi di sostituzione del comando di seguito.
Sostituzione del comando semplice usando la sintassi $ () per eseguire il comando della data.
$ echo $ (data)
Mer 18 marzo 01:42:46 UTC 2020
Sostituzione del comando semplice usando la sintassi del backtick per eseguire il comando della data.
$ echo 'data'
Mer 18 marzo 01:43:17 UTC 2020
L'uso dell'operatore stdin all'inizio della sintassi di sostituzione del comando è un modo elegante per leggere il testo di un file in una variabile e usarlo in un comando sulla shell come sotto.
$ echo "ciao mondo"> mytext
$ echo $ (< mytext)
Ciao mondo
Leggi un file in una variabile da utilizzare in un comando usando il comando CAT e la sostituzione del comando.
$ echo "ciao mondo"> mytext
$ echo $ (cat mytext)
Ciao mondo
Come sopra, leggi un file e usalo nella sostituzione del comando usando backtics e comando cat.
$ echo "ciao mondo"> mytext
$ echo 'cat mytext'
Ciao mondo
Combina la sostituzione del comando incorporata con un'altra sostituzione del comando usando sia $ () che i retrovini insieme
$ echo 'echo $ (data) | cut -d "" -f 1'> myfile
$ cat myfile
Sposa
Sostituzione del comando incorporata all'interno di un altro utilizzando due operazioni di sintassi $ ()
$ echo "Oggi è $ (echo $ (data) | taglio -d" "-f 1)"> myfile
$ cat myfile
Oggi è sposato
Usa l'output da un comando come argomenti in un altro comando, con la sintassi del backtick. Riceveremo un elenco di file eseguendo Cat che contiene un file per riga e quindi passeremo questo nel comando RM che rimuoverà ogni file
$ TOUCT UNE; Tocca due
$ echo one> myfiles; Echo due >> myfiles
$ rm 'cat myfiles'
Come sopra ma con $ () sintassi, passa il comando output da cat in comando rm per eliminare i file.
$ TOUCT UNE; Tocca due
$ echo one> myfiles; Echo due >> myfiles
$ rm $ (cat myfiles)
Memorizza l'output da un comando Cat in una variabile e quindi loop attraverso la variabile in modo da poter vedere più chiaramente cosa sta succedendo.
$ TOUCT UNE; Tocca due
$ echo one> myfiles; Echo due >> myfiles
$ Myfiles = $ (cat myfiles)
$ per F in $ myfiles; fare eco $ f; rm $ f; Fatto
uno
due
Come sopra, ma usa la sintassi dei backtick per eseguire il comando CAT e memorizzare l'output in una variabile e quindi loop tramite i file int la variabile.
$ TOUCT UNE; Tocca due
$ echo one> myfiles; Echo due >> myfiles
$ Myfiles = 'cat myfiles'
$ per F in $ myfiles; fare eco $ f; rm $ f; Fatto
uno
due
Utilizzare la sostituzione del comando con l'operatore STDIN per leggere una riga del file per riga in una variabile e quindi loop attraverso la variabile post -parola
$ TOUCT UNE; Tocca due
$ echo one> myfiles; Echo due >> myfiles
$ Myfiles = $ (< myfiles)
$ per F in $ myfiles; fare eco $ f; rm $ f; Fatto
uno
due
Sostituzione del processo
La sostituzione del processo è una caratteristica documentata di Bash; è abbastanza criptico secondo me. In effetti non ho trovato molti buoni casi d'uso da raccomandare. Un esempio è incluso qui per completezza in cui utilizziamo la sostituzione del processo per ottenere l'output di un comando e quindi usarlo un altro comando. Stamperemo l'elenco dei file in ordine inverso con comando Ording in questo esempio dopo aver recuperato i file dal comando LS.
$ TOUCT UNE.TXT; Tocca due.TXT; Tocca tre.TXT
$ SORT -r <(ls *txt)
due.TXT
tre.TXT
uno.TXT
Sostituzione variabile
La sostituzione variabile è ciò che puoi considerare l'uso di base delle variabili e sostituire il valore della variabile quando si fa riferimento. È abbastanza intuitivo, alcuni esempi sono forniti di seguito.
Semplice assegnazione variabile e utilizzo in cui inseriamo una stringa in variabile x e quindi stamparla su stdout
$ X = 12345
$ echo $ x
12345
Controlla se una variabile viene assegnata qualcosa o nullo, in questo caso è assegnato, quindi lo stampiamo su StDout
$ X = 12345
$ se [-z "$ x"]; quindi eco "x è null"; else echo $ x; fi
12345
Controlla se una variabile viene assegnata qualcosa o nullo, in questo caso non è impostato, quindi stampiamo "è null" anziché il valore.
$ Unset x
$ se [-z "$ x"]; quindi eco "x è null"; else echo $ x; fi
X è nullo
Espansione del tutore
L'espansione del tutore è una caratteristica super potente di Bash che consente di scrivere script e comandi più compatti. Ha molte funzionalità e opzioni diverse descritte di seguito. All'interno delle parentesi graffe la sintassi viene interpretata in una sintassi più verbosa a seconda di quando si entra nelle parentesi graffe ricci. Diamo un'occhiata a una serie di esempi per l'espansione del tutore.
Viene eseguita ogni versione degli elementi nell'elenco in parentesi graffe. Quindi passiamo da un comando eco e stampiamo 3 versioni della parola sotto separate da spazi.
$ echo a, m, p _warehouse
A_warehouse m_warehouse p_warehouse
Le espressioni nell'espansione causano l'esecuzione più volte. Per dimostrarlo, utilizziamo il comando Data e Sleep per convalidare che il comando Data viene eseguito una volta per ogni iterazione del modello nell'espansione del tutore.
$ echo a, m, p _ $ (data; sleep 1)
A_SUN 22 marzo 18:56:45 UTC 2020 M_SUN 22 marzo 18:56:46 UTC
2020 P_SUN 22 marzo 18:56:47 UTC 2020
Le espansioni usando i numeri con ... causano l'espansione dei numeri sequenziali in una sequenza numerica
$ echo 1… 8 _warehouse
1_warehouse 2_warehouse 3_warehouse 4_warehouse 5_warehouse 6_warehouse 7_warehouse
8_warehouse
Espansione del tutore dell'ordine inverso con sequenza di numeri
$ echo 8… 1 _warehouse
8_warehouse 7_warehouse 6_warehouse 5_warehouse 4_warehouse 3_warehouse 2_warehouse
1_warehouse
Utilizzando un valore di incremento opzionale per specificare gli incrementi numerici dell'espansione del braccio
$ echo 1… 9… 3 _warehouse
1_warehouse 4_warehouse 7_warehouse
L'espansione del tumulto lessicografico iterirà attraverso lettere nell'alfabeto nell'ordine del locale
$ echo a… e _warehouse
A_Warehouse B_Warehouse C_Warehouse D_Warehouse E_Warehouse
Espansione del braccio lessicografico dell'ordine inverso
$ echo e ... a _warehouse
e_warehouse d_warehouse c_warehouse b_warehouse a_warehouse
L'espansione del tumulto lessicografica con incremento specificato iterirà attraverso un elenco di caratteri dall'inizio al punto finale, ma salta i caratteri in base al valore dell'incremento
$ echo a… z… 5 _warehouse
A_warehouse f_warehouse k_warehouse p_warehouse u_warehouse z_warehouse
Espansione del tutore moltiplicativo con 2 espansioni del tutore in un comando
$ echo a… e 1… 5 _warehouse
A1_Warehouse A2_Warehouse A3_Warehouse A4_Warehouse A5_Warehouse B1_Ware House
B2_Warehouse B3_Warehouse B4_Warehouse B5_Warehouse C1_Warehouse C2_Ware House
C3_Warehouse C4_Warehouse C5_Warehouse d1_warehouse d2_warehouse d3_warehouse
d4_warehouse d5_warehouse e1_warehouse e2_warehouse e3_warehouse e4_warehouse
e5_warehouse
Espansione del tutore per utilizzare la stessa radice due volte in un comando. Questo crea un foo.File TAR TGZ da una directory in nome foo. È una pratica sintassi in cui lo stai usando all'interno di un altro ciclo e vuoi presumere che la base della parola sia usata più volte. Questo esempio lo mostra con catrame, ma può anche essere usato con MV e CP secondo questo esempio.
$ mkdir foo
$ touch foo/foo a… e
$ tar czvf foo .tgz,
foo/
foo/foob
foo/fooc
foo/fooa
foo/cibo
foo/fooe
Espansione dei parametri
L'espansione dei parametri è anche una bella sintassi compatta con molte funzionalità come: consentire agli script di impostare i valori predefiniti per variabili o opzioni nont, operazioni di sottostringa stringa, ricerca e sostituzione delle sostituzioni e altri casi d'uso. Gli esempi sono di seguito.
Verificare per null e utilizzare il parametro se non null o il valore predefinito. In questo caso X non è nullo, quindi verrà utilizzato
$ X = 1
$ echo $ x: -2
1
Verificare per null e utilizzare il parametro se non null o il valore predefinito. In questo caso X è nullo, quindi verrà utilizzato il valore predefinito
$ Unset x
$ echo $ x: -2
2
Controlla se la variabile è nulla e imposta e riecheggia se è nullo. X è assegnato 2 e stampato $ X. Questo può entrambi impostare la variabile e usarla nel comando con la sintassi $ : =.
$ Unset x
$ se [-z "$ x"]; Quindi eco null; fi
NULLO
$ echo $ x: = 2
2
$ se [-z "$ x"]; Quindi eco null; else echo $ x; fi
2
L'espansione della sottostringa sostituirà da un punto di offset un certo numero di caratteri nella stringa
$ X = "Hello World"
$ echo $ x: 0: 7
Ciao w
Cambia l'offset nel secondo carattere e stampa 7 caratteri di sottostringa
$ X = "Hello World"
$ echo $ x: 1: 7
Ello Wo
La sottostringa dall'inizio della stringa ma taglia gli ultimi 2 caratteri
$ X = "Hello World"
$ echo $ x: 0: -2
Ciao wor
Ottieni una lunghezza della stringa con questa versione dell'espansione dei parametri
$ X = "Hello World"
$ echo $ #x
11
Cerca e sostituisci all'interno di una variabile. In questo esempio sostituire il primo minuscolo o con la maiuscola
$ X = "Hello World"
$ echo $ x/o/o
Ciao mondo
Cerca e sostituisci all'interno di una variabile ma con tutte le partite sostituite a causa della barra principale nel modello di ricerca.
$ X = "Hello World"
$ echo $ x // o/o
Ciao mondo
I modelli che iniziano con #, significano che la corrispondenza deve iniziare all'inizio della stringa per essere sostituita
$ X = "Hello World"
$ echo $ x/#h/j
Mondo Jello
Esempio in cui la ricerca di corrispondenza all'inizio della stringa, ma non riuscita perché la corrispondenza è più tardi nella stringa
$ X = "Hello World"
$ echo $ x/#w/j
Ciao mondo
I modelli che iniziano con % corrisponderanno solo alla fine della stringa come in questo esempio.
$ X = "Hello World"
$ echo $ x/%d/d oggi
Ciao mondo oggi
Esempio per la fine di String Match che fallisce perché la corrispondenza è all'inizio della stringa.
$ X = "Hello World"
$ echo $ x/%h/oggi
Ciao mondo
Usa Shopt con Nocasematch per eseguire la sostituzione insensibile al caso.
$ shopt -s nocasematch
$ X = "Hello World"
$ echo $ x/hello/welcome
Mondo di benvenuto
Spegni Shopt con Nocasematch per fare una sostituzione del caso Sensibile.
$ shopt -u nocasematch
$ X = "Hello World"
$ echo $ x/hello/welcome
Ciao mondo
Cerca variabili di ambiente che corrispondono a uno schema.
$ My_a = 1
$ My_b = 2
$ My_c = 3
$ echo $ !MIO*
My_a my_b my_c
Ottieni un elenco di variabili corrispondenti e quindi corri attraverso ogni variabile e stampa il suo valore
$ My_a = 1
$ My_b = 2
$ My_c = 3
$ variabili = $ !MIO*
$ per i in $ variabili; Echo $ i; echo "$ !i "; fatto
My_a
1
My_b
2
IL MIO C
3
Crea una corda tutta maiuscola
$ X = "Hello World"
$ echo $ x ^^
CIAO MONDO
Crea una corda tutta minuscola
$ X = "Hello World"
$ echo $ x ,,
Ciao mondo
Fare il primo carattere di una corda maiuscola
$ X = "George Washington"
$ echo $ x^
George Washington
Rendi il primo carattere di una corda minuscola
$ X = Bob
$ echo $ x,
Bob
Parametri posizionali
I parametri posizionali sono normalmente considerati come parametri della riga di comando, come usarli sono mostrati con esempi di seguito.
Il parametro $ 0 è il nome dello script in esecuzione e quindi $ 1, $ 2, $ 3 ecc. Sono i parametri della riga di comando passati a uno script.
$ Cat Script.sh
Echo $ 0
Echo $ 1
Echo $ 2
Echo $ 3
$ bash ./script.carota di banana di mela sh
./script.sh
mela
banana
carota
Il parametro $* è una singola variabile con tutti gli argomenti della riga di comando concatenati.
$ Cat Script.sh
Echo $ 1
Echo $ 2
echo $*
$ bash ./script.Banana di mela SH
mela
banana
Banana di mela
Il parametro $# è un numero con la quantità di parametri posizionali passati a uno script in questo caso in basso sono passati 2 argomenti.
$ Cat Script.sh
Echo $ 1
Echo $ 2
echo $*
Echo $#
$ bash ./script.Banana di mela SH
mela
banana
Banana di mela
2
Espansione di Tilde
L'espansione di Tilde è comunemente vista con nomi utente e directory home, sono mostrati esempi di seguito.
Espansione di Tilde per ottenere la home directory dell'utente attuale, utilizzando solo tilde senza il nome utente.
$ echo $ utente
radice
$ cd ~/
$ pwd
/radice
Fare riferimento alla home directory di un utente specifico, non all'utente corrente con Tilde e al nome utente
$ cd ~ linuxhint
$ pwd
/Home/Linuxhint
Sostituzione aritmetica
La sostituzione aritmetica consente a bash di eseguire operazioni matematiche nella shell o in una sceneggiatura. Di seguito sono riportati esempi di usi comuni.
Sostituzione aritmetica semplice con parentesi $ e doppie
$ echo $ ((2 + 3))
5
L'operatore post incremento aggiornerà il valore di uno dopo il comando corrente, si noti che non c'è un decremento di post equivalente non mostrato qui.
$ X = 2
$ echo $ ((x ++))
2
$ echo $ x
3
L'operatore di pre -incremento aggiornerà il valore di uno appena prima del comando corrente, si noti che esiste un operatore predefinito equivalente non mostrato qui.
$ X = 2
$ echo $ ((++ x))
3
$ echo $ x
3
L'operatore esponente può sollevare un numero a una potenza esponenzialmente
$ echo $ ((5 ** 2))
25
Shind Bitwise Shift; In questo caso sposta i bit del numero decimale 8 a sinistra che lo moltiplica essenzialmente per 2
$ echo $ ((8<<1))
16
Giust a destra bitwise; In questo caso sposta i bit del numero decimale 8 a destra che essenzialmente divide il numero per 2
$ echo $ ((8 >> 1))
4
Bitwise e l'operatore confronteranno i numeri bit per bit e il risultato saranno i bit che sono tutti impostati.
$ echo $ ((4 e 5))
4
Bitwise o operatore confronterà i numeri bit per bit e i risultati saranno i bit in cui uno degli ingressi ha il bit set.
$ echo $ ((4 | 9))
13
L'operatore di uguaglianza aritmetica testerà per la verità e restituirà 1 o 0
$ echo $ ((4 == 4))
1
L'operatore di disuguaglianza aritmetica testerà per non equalità e restituirà 1 o 0
$ echo $ ((4 != 4))
0
L'operatore condizionale testerà il primo argomento se vero, sostituirà con il secondo argomento e se false sostituirà con il terzo. In questo caso 5 è uguale a 4+1 quindi il primo condizionale è vero e 9 viene restituito. 5 non è uguale a 4+2, quindi nel secondo eco 7 viene restituito.
$ echo $ ((5 == 4+1 ? 9: 7))
9
$ echo $ ((5 == 4+2 ? 9: 7))
7
Puoi usare numeri esadecimali nelle espansioni aritmetiche, in questo caso 0xa è equivalente a 10 e 10+7 = 17.
$ echo $ ((0xa + 7))
17
Divisione delle parole
Usando la variabile di ambiente IFS per registrare un delimitatore e usando i comandi Read e ReadArray, possiamo analizzare le stringhe in un array di token e quindi contare i token e operare su di essi. Esempi sono mostrati di seguito.
Usa il parametro IFS come delimitatore, leggi i token in un array diviso da IFS che è impostato su un carattere spaziale e quindi stampare i token uno per uno
$ text = "Hello World"
$ Ifs = "
$ read -a token <<< "$text"
$ echo "Ci sono $ #token [*] nel testo."
Ci sono 2 parole nel testo.
$ per i in "$ token [@]"; Echo $ i; Fatto
Ciao
Mondo
L'utente readarray senza IFS e specifica delimitatore nel comando readarray. Nota Questo è solo un esempio in cui abbiamo diviso un percorso di directory in base al delimitatore della barra. In questo caso il codice ha incluso la stringa vuota prima della prima barra che dovrebbe essere regolata in un utilizzo reale, ma stiamo solo mostrando come chiamare ReadaRray per dividere una stringa in token in un array con un delimitatore.
$ path = "/home/linuxhint/usr/locale/bin"
$ readarray -d / -t token <<< "$path"
echo "Ci sono $ #token [*] nel testo."
Ci sono 6 parole nel testo.
$ per i in "$ token [@]"; Echo $ i; Fatto
casa
Linuxhint
usr
Locale
bidone
Espansione del nome file
Quando si desidera fare riferimento a un elenco di file o directory nel filesystem, un comando bash o uno script bash possono utilizzare l'espansione del nome file per generare un elenco di file e directory da semplici comandi. Esempi sono mostrati di seguito.
Il personaggio * si espande a un jolly e raccoglie tutti i file corrispondenti con il resto della stringa wild card. Qui prendiamo tutti i file che finiscono .txt e trasmetterli nel comando Du per il controllo della dimensione del disco.
$ touch a.txt b.txt c.TXT
$ echo "ciao mondo"> contenuto.TXT
$ du *.TXT
0 a.TXT
0 b.TXT
0 c.TXT
4 contenuti.TXT
IL ? Il personaggio corrisponderà solo a un singolo personaggio non a un numero infinito di caratteri, e quindi in questo esempio prenderà solo nomi di file con un singolo carattere seguito da .TXT.
$ touch a.txt b.txt c.TXT
$ echo "ciao mondo"> contenuto.TXT
$ du ?.TXT
0 a.TXT
0 b.TXT
0 c.TXT
I personaggi tra parentesi si espandono per abbinare uno qualsiasi dei personaggi. In questo esempio a.txt e c.txt sono raccolti dall'espansione
$ touch a.txt b.txt c.TXT
$ echo "ciao mondo"> contenuto.TXT
$ du [AC].TXT
0 a.TXT
0 c.TXT
I caratteri tra parentesi possono essere una gamma di caratteri e vediamo qui tutti i file da una gamma a c seguiti da .Il suffisso txt viene raccolto
$ touch a.txt b.txt c.TXT
$ echo "ciao mondo"> contenuto.TXT
$ du [a-c].TXT
0 a.TXT
0 b.TXT
0 c.TXT
Conclusione
Abbiamo coperto molti tipi di espansioni di shell in questo articolo e spero che i semplici esempi possano fungere da libro di cucina per ciò che è possibile in Bash per renderti più produttivo con espansioni di shell. Come ulteriori riferimenti, consiglio di leggere il manuale completo bash e anche i numerosi buoni articoli sul sito Web Nixcraft sullo script bash, inclusi le espansioni di shell. Abbiamo altri articoli che potrebbero esserti di interesse su LinuxHint tra cui: 30 Esempi di script bash, stringhe maiuscole bash, abbinamento del modello bash e esempi di stringhe split bash. Inoltre abbiamo un popolare corso gratuito di 3 ore sulla programmazione bash puoi trovare su YouTube.