Uno degli strumenti più importanti per la maggior parte degli amministratori di sistema è l'automazione. Scriviamo e manteniamo script per automatizzare le attività comuni e frequenti che dobbiamo eseguire.
Ho dozzine di sceneggiature, brevi e lunghe, che ho scritto e modificato nel corso degli anni. Alcuni dei miei script più utili sono stati l'esecuzione di backup regolari ogni mattina, l'installazione di pacchetti software aggiornati con correzioni e miglioramenti e l'aggiornamento da una versione di Fedora a quella successiva. Alcuni giorni fa ho aggiornato tutti i miei host e server personali a Fedora 34 utilizzando uno script abbastanza semplice.
[ Potrebbe piacerti anche: Più stupidi trucchi Bash:variabili, trova, descrittori di file e operazioni remote ]
Due delle cose più comuni che faccio per tutti i miei script sono la creazione di una funzione di aiuto e una funzione che visualizza la dichiarazione di licenza GPL3. Mi piace includere modalità dettagliate o di test per aiutare nella determinazione dei problemi nei miei script. In alcuni script, passo anche valori come un nome utente, la versione di Fedora a cui eseguire l'aggiornamento, nomi di file e altro.
La possibilità di utilizzare parametri posizionali, altrimenti noti come argomenti, per specificare i dati da utilizzare come valori per le variabili negli script è un metodo per ottenere ciò. Un altro è l'uso di opzioni e argomenti di opzione. Questo articolo esplora questi due metodi per inserire i dati nello script e controllare il percorso di esecuzione dello script.
Parametri di posizione
Bash utilizza uno strumento chiamato parametri posizionali per fornire un mezzo per inserire dati in un programma Bash quando viene invocato dalla riga di comando. Esistono dieci parametri posizionali che partono da $0 attraverso $9 , sebbene ci siano modi per aggirare quel limite.
A partire da un semplice script che visualizza un nome immesso sullo schermo. Crea un file chiamato script1.sh con il seguente contenuto e renderlo eseguibile.
#!/bin/bash
echo $0
Ho inserito questo script nella mia ~/bin directory , dove devono essere archiviati file eseguibili personali come gli script. Guarda il tuo $PATH variabile, che contiene /home/username/bin come un componente. Se il ~/bin directory non esiste, puoi crearla. Oppure puoi semplicemente mettere questo file dove vuoi e usarlo da lì.
Quindi esegui lo script senza parametri.
[student@testvm1 ~]$ script1.sh
/home/dboth/bin/script1.sh
[student@testvm1 ~]$ L'output di questo script è il nome dello script. I $ 0 parametro è riservato e predefinito come nome dello script in esecuzione e non può essere utilizzato per nessun altro scopo. Questo può essere utile all'interno di uno script perché non è necessario passare allo script il proprio nome se lo richiede.
Quindi cambia lo script per utilizzare $1 per la variabile posizionale ed eseguirla di nuovo:
#!/bin/bash
echo $1 Eseguilo di nuovo, questa volta utilizzando un singolo parametro:
[student@testvm1 ~]$ script1.sh help
help
[student@testvm1 ~]$ Cosa succede se il parametro è composto da due parole?
[student@testvm1 ~]$ script1.sh help me
help
[student@testvm1 ~]$ In realtà si tratta di due parametri, ma puoi rimediare con le virgolette, come mostrato qui:
[student@testvm1 ~]$ script1.sh "help me"
help me
[student@testvm1 ~]$ Questo può essere utile quando si suppone che l'input sia un indirizzo o qualcosa con più parole, come questo:
[student@testvm1 ~]$ script1.sh "80486 Intel St."
80486 Intel St.
[student@testvm1 ~]$ Ma ci sono momenti in cui hai bisogno di più parametri, ad esempio con nomi o indirizzi completi.
Cambia il programma in modo che assomigli a questo:
#!/bin/bash
echo "Name: $1"
echo "Street: $2"
echo "City: $3"
echo "State/Province/Territory: $4"
echo "Zip/Postal code: $5" Ed eseguilo usando i parametri come mostrato:
[student@testvm1 ~]$ script1.sh "David Both" "80486 Intel St." Raleigh NC XXXXX
Name: David Both
Street: 80486 Intel St.
City: Raleigh
State/Province/Territory: NC
Zip/Postal code: XXXXX Naturalmente, ci sono molti modi per utilizzare i parametri posizionali una volta assegnati i valori, ma questo piccolo programma rende facile vedere cosa sta succedendo. Inoltre, è facile sperimentare in modo sicuro.
Prova a mettere i parametri in un ordine diverso per vedere come funziona. Questi parametri sono posizionali e questa è una considerazione chiave. Devi considerare quanti parametri sono necessari, come l'utente li ricorda e in quale ordine posizionarli.
Hai bisogno di un modo per rendere irrilevante l'ordine dei parametri e hai comunque bisogno di un modo per modificare il percorso di esecuzione.
Opzioni
Puoi fare queste due cose usando le opzioni della riga di comando.
Trovo che anche i semplici programmi Bash dovrebbero avere una sorta di funzione di aiuto, anche se è abbastanza rudimentale. Molti dei programmi di shell Bash che scrivo sono usati abbastanza raramente da poter dimenticare l'esatta sintassi del comando che devo emettere. Alcuni sono così complessi che ho bisogno di rivedere le opzioni e gli argomenti richiesti anche se li uso frequentemente.
Avere una funzione di aiuto integrata ti consente di visualizzare queste cose senza ricorrere all'ispezione del codice stesso. Una buona e completa funzionalità di aiuto è anche una parte della documentazione del programma.
Informazioni sulle funzioni
Le funzioni della shell sono elenchi di istruzioni del programma Bash memorizzate nell'ambiente della shell e possono essere eseguite come qualsiasi altro comando digitandone il nome nella riga di comando. Le funzioni della shell possono anche essere conosciute come procedure o subroutine, a seconda dell'altro linguaggio di programmazione in uso.
Le funzioni vengono chiamate nei tuoi script o dalla CLI usando i loro nomi, proprio come faresti per qualsiasi altro comando. In un programma CLI o in uno script, i comandi nella funzione vengono eseguiti quando vengono chiamati. Quindi la sequenza del flusso del programma ritorna all'entità chiamante e viene eseguita la serie successiva di istruzioni del programma in tale entità.
La sintassi di una funzione è:
NomeFunzione(){dichiarazioni del programma}
Creare una semplice funzione nella CLI. La funzione è archiviata nell'ambiente della shell per l'istanza della shell in cui è stata creata. Creerai una funzione chiamata hw , che sta per Hello world . Inserisci il seguente codice nella CLI e premi Invio . Quindi inserisci hw come faresti con qualsiasi altro comando di shell.
[student@testvm1 ~]$ hw(){ echo "Hi there kiddo"; }
[student@testvm1 ~]$ hw
Hi there kiddo
[student@testvm1 ~]$ Ok, quindi sono un po' stanco dello standard "Hello world!" Di solito inizio con. Ora elenca tutte le funzioni attualmente definite. Ce ne sono molti, quindi ho mostrato solo il nuovo hw funzione. Quando viene chiamata dalla riga di comando o all'interno di un programma, una funzione esegue il proprio compito programmato. Quindi esce, restituendo il controllo all'entità chiamante, alla riga di comando o alla successiva istruzione del programma Bash in uno script dopo l'istruzione chiamante.
[student@testvm1 ~]$ declare -f | less
<snip>
hw ()
{
echo "Hi there kiddo"
}
<snip>
Ora rimuovi quella funzione perché non ne hai più bisogno. Puoi farlo con unset comando, in questo modo:
[student@testvm1 ~]$ unset -f hw ; hw
bash: hw: command not found
[student@testvm1 ~]$ Lo script hello.sh
Crea un nuovo script della shell Bash, ~/bin/hello.sh e rendilo eseguibile. Aggiungi il seguente contenuto, mantenendolo di base per iniziare:
#!/bin/bash
echo "hello world!" Eseguilo per verificare che stampi "ciao mondo!".
[dboth@david ~]$ hello.sh
hello world!
[dboth@david ~]$ Lo so, non posso farne a meno, quindi sono tornato a "ciao mondo!".
Creazione della funzione di aiuto
Aggiungi la guida funzione mostrata di seguito al codice del programma ciao. Inserisci la aiuto funzione tra le due affermazioni che hai già. Questo aiuto La funzione visualizzerà una breve descrizione del programma, un diagramma sintattico e una breve descrizione di ciascuna opzione disponibile. Aggiungi anche una chiamata alla assistenza funzione per testarla e alcune righe di commento che forniscono una demarcazione visiva tra le funzioni e la parte principale del programma.
Il programma ora si presenta così.
#!/bin/bash
############################################################
# Help #
############################################################
Help()
{
# Display Help
echo "Add description of the script functions here."
echo
echo "Syntax: scriptTemplate [-g|h|v|V]"
echo "options:"
echo "g Print the GPL license notification."
echo "h Print this Help."
echo "v Verbose mode."
echo "V Print software version and exit."
echo
}
############################################################
############################################################
# Main program #
############################################################
############################################################
Help
echo "Hello world!" Le opzioni descritte in questa guida funzione potrebbe essere tipica nei programmi che scrivo, sebbene nessuno sia ancora presente nel codice. Esegui il programma per testarlo.
[student@testvm1 ~]$ hello.sh
Add a description of the script functions here.
Syntax: scriptTemplate [-g|h|v|V]
options:
g Print the GPL license notification.
h Print this Help.
v Verbose mode.
V Print software version and exit.
Hello world!
[student@testvm1 ~]$
Poiché non hai aggiunto alcuna logica per visualizzare la guida quando lo desideri, il programma visualizzerà sempre la guida. Tuttavia, sai che la funzione funziona correttamente, quindi puoi aggiungere della logica solo per mostrare l'aiuto quando usi un -h opzione al richiamo della riga di comando del programma.
Opzioni di gestione
La capacità di uno script Bash di gestire le opzioni della riga di comando come -h per visualizzare la guida fornisce alcune potenti capacità per dirigere il programma e modificare ciò che fa. Nel caso del tuo -h opzione, vuoi che il programma stampi il testo della guida sulla sessione del terminale e poi si chiuda senza eseguire il resto del programma. La capacità di elaborare le opzioni immesse dalla riga di comando può essere aggiunta allo script Bash usando il while comando insieme a getops e case comandi.
Il getops comando legge tutte le opzioni specificate nella riga di comando e crea un elenco di tali opzioni. Il while Il comando scorre l'elenco delle opzioni impostando la variabile $options per ciascuno nel codice sottostante. Il case istruzione viene utilizzata per valutare ciascuna opzione a turno ed eseguire le istruzioni nella stanza corrispondente. Il while continueranno a valutare l'elenco delle opzioni fino a quando non saranno state elaborate tutte o fino a quando non verrà rilevata un'istruzione di uscita, che interromperà il programma.
Assicurati di eliminare la guida chiamata alla funzione appena prima dell'eco "Hello world!" istruzione in modo che il corpo principale del programma ora assomigli a questo.
############################################################
############################################################
# Main program #
############################################################
############################################################
############################################################
# Process the input options. Add options as needed. #
############################################################
# Get the options
while getopts ":h" option; do
case $option in
h) # display Help
Help
exit;;
esac
done
echo "Hello world!"
Notare il doppio punto e virgola alla fine dell'istruzione di uscita nell'opzione case per -h . Questo è richiesto per ogni opzione. Aggiungi a questa dichiarazione del caso per delineare la fine di ogni opzione.
I test ora sono un po' più complessi. Devi testare il tuo programma con diverse opzioni e nessuna opzione per vedere come risponde. Innanzitutto, controlla per assicurarti che senza opzioni venga stampato "Hello world!" come dovrebbe.
[student@testvm1 ~]$ hello.sh
Hello world! Funziona, quindi ora verifica la logica che mostra il testo della guida.
[student@testvm1 ~]$ hello.sh -h
Add a description of the script functions here.
Syntax: scriptTemplate [-g|h|t|v|V]
options:
g Print the GPL license notification.
h Print this Help.
v Verbose mode.
V Print software version and exit. Funziona come previsto, quindi prova ora alcuni test per vedere cosa succede quando inserisci alcune opzioni impreviste.
[student@testvm1 ~]$ hello.sh -x
Hello world!
[student@testvm1 ~]$ hello.sh -q
Hello world!
[student@testvm1 ~]$ hello.sh -lkjsahdf
Add a description of the script functions here.
Syntax: scriptTemplate [-g|h|t|v|V]
options:
g Print the GPL license notification.
h Print this Help.
v Verbose mode.
V Print software version and exit.
[student@testvm1 ~]$ Gestione delle opzioni non valide
Il programma ignora semplicemente le opzioni per le quali non hai creato risposte specifiche senza generare errori. Anche se nell'ultima voce con il -lkjsahdf opzioni, poiché nell'elenco è presente una "h", il programma l'ha riconosciuta e ha stampato il testo della guida. I test hanno dimostrato che una cosa che manca è la capacità di gestire input non corretti e terminare il programma se ne viene rilevato uno.
È possibile aggiungere un'altra stanza case all'istruzione case che corrisponderà a qualsiasi opzione per la quale non esiste una corrispondenza esplicita. Questo caso generale corrisponderà a qualsiasi cosa per cui non hai fornito una corrispondenza specifica. Il caso l'istruzione ora è simile a questa.
while getopts ":h" option; do
case $option in
h) # display Help
Help
exit;;
\?) # Invalid option
echo "Error: Invalid option"
exit;;
esac
done Questo pezzo di codice merita una spiegazione su come funziona. Sembra complesso ma è abbastanza facile da capire. Il mentre – fatto struttura definisce un ciclo che viene eseguito una volta per ogni opzione in getopts – opzione struttura. Il :h" string —che richiede le virgolette—elenca le possibili opzioni di input che verranno valutate da case – esac struttura. Ciascuna opzione elencata deve avere una stanza corrispondente nell'istruzione case. In questo caso, ce ne sono due. Uno è h) stanza che chiama la procedura della Guida. Al termine della procedura della Guida, l'esecuzione torna all'istruzione di programma successiva, exit;; che esce dal programma senza eseguire più codice anche se ne esiste. Anche il ciclo di elaborazione delle opzioni è terminato, quindi non verranno controllate opzioni aggiuntive.
Nota la corrispondenza generale di \? come ultima stanza nella dichiarazione del caso. Se vengono immesse opzioni non riconosciute, questa stanza stampa un breve messaggio di errore ed esce dal programma.
Eventuali casi specifici aggiuntivi devono precedere il catch-all finale. Mi piace posizionare le stanze dei casi in ordine alfabetico, ma ci saranno circostanze in cui si desidera assicurarsi che un caso particolare venga elaborato prima di alcuni altri. L'istruzione case è sensibile alla sequenza, quindi tienilo presente quando costruisci la tua.
L'ultima istruzione di ogni stanza nel costrutto case deve terminare con il doppio punto e virgola (;; ), che viene utilizzato per contrassegnare esplicitamente la fine di ogni stanza. Ciò consente a quei programmatori a cui piace usare punti e virgola espliciti per la fine di ogni istruzione invece di quelli impliciti di continuare a farlo per ogni istruzione all'interno di ciascuna stanza case.
Testare di nuovo il programma utilizzando le stesse opzioni di prima e vedere come funziona ora.
Lo script Bash ora ha questo aspetto.
#!/bin/bash
############################################################
# Help #
############################################################
Help()
{
# Display Help
echo "Add description of the script functions here."
echo
echo "Syntax: scriptTemplate [-g|h|v|V]"
echo "options:"
echo "g Print the GPL license notification."
echo "h Print this Help."
echo "v Verbose mode."
echo "V Print software version and exit."
echo
}
############################################################
############################################################
# Main program #
############################################################
############################################################
############################################################
# Process the input options. Add options as needed. #
############################################################
# Get the options
while getopts ":h" option; do
case $option in
h) # display Help
Help
exit;;
\?) # Invalid option
echo "Error: Invalid option"
exit;;
esac
done
echo "hello world!"
Assicurati di testare questa versione del tuo programma molto accuratamente. Usa input casuali e guarda cosa succede. Dovresti anche provare a testare opzioni valide e non valide senza usare il trattino (- ) davanti.
Utilizzo delle opzioni per inserire i dati
Innanzitutto, aggiungi una variabile e inizializzala. Aggiungi le due righe mostrate in grassetto nel segmento del programma mostrato di seguito. Questo inizializza il $Nome variabile a "mondo" come impostazione predefinita.
<snip>
############################################################
############################################################
# Main program #
############################################################
############################################################
# Set variables
Name="world"
############################################################
# Process the input options. Add options as needed. #
<snip>
Cambia l'ultima riga del programma, l'echo comando, a questo.
echo "hello $Name!" Aggiungi la logica per inserire un nome in un momento, ma prima prova di nuovo il programma. Il risultato dovrebbe essere esattamente lo stesso di prima.
[dboth@david ~]$ hello.sh
hello world!
[dboth@david ~]$
# Get the options
while getopts ":hn:" option; do
case $option in
h) # display Help
Help
exit;;
n) # Enter a name
Name=$OPTARG;;
\?) # Invalid option
echo "Error: Invalid option"
exit;;
esac
done $OPTARG è sempre il nome della variabile usata per ogni nuovo argomento di opzione, non importa quanti ce ne siano. Devi assegnare il valore in $OPTARG a un nome di variabile che verrà utilizzato nel resto del programma. Questa nuova stanza non ha un'istruzione di uscita. Questo cambia il flusso del programma in modo che, dopo aver elaborato tutte le opzioni valide nell'istruzione case, l'esecuzione passi all'istruzione successiva dopo il costrutto case.
Testare il programma rivisto.
[dboth@david ~]$ hello.sh
hello world!
[dboth@david ~]$ hello.sh -n LinuxGeek46
hello LinuxGeek46!
[dboth@david ~]$ hello.sh -n "David Both"
hello David Both!
[dboth@david ~]$ Il programma completato si presenta così.
#!/bin/bash
############################################################
# Help #
############################################################
Help()
{
# Display Help
echo "Add description of the script functions here."
echo
echo "Syntax: scriptTemplate [-g|h|v|V]"
echo "options:"
echo "g Print the GPL license notification."
echo "h Print this Help."
echo "v Verbose mode."
echo "V Print software version and exit."
echo
}
############################################################
############################################################
# Main program #
############################################################
############################################################
# Set variables
Name="world"
############################################################
# Process the input options. Add options as needed. #
############################################################
# Get the options
while getopts ":hn:" option; do
case $option in
h) # display Help
Help
exit;;
n) # Enter a name
Name=$OPTARG;;
\?) # Invalid option
echo "Error: Invalid option"
exit;;
esac
done
echo "hello $Name!" Assicurati di testare la funzione di aiuto e come il programma reagisce a input non validi per verificare che la sua capacità di elaborarli non sia stata compromessa. Se tutto funziona come dovrebbe, allora hai imparato con successo come utilizzare le opzioni e gli argomenti delle opzioni.
[ Ottieni questo ebook gratuito:Gestione dei cluster Kubernetes per i manichini. ]
Concludi
In questo articolo, hai utilizzato i parametri posizionali per inserire i dati nel programma Bash durante l'invocazione dalla riga di comando e hai utilizzato le opzioni per dirigere il flusso del programma e per inserire i dati nel programma. Hai aggiunto una funzione della guida e la possibilità di elaborare le opzioni della riga di comando per visualizzare la guida in modo selettivo. E hai aggiunto un argomento facoltativo che consente di inserire un nome sulla riga di comando.
Questo piccolo programma di test è progettato per essere semplice, quindi puoi facilmente sperimentarlo tu stesso per testare questo metodo di input da solo. Come esercizio, rivedi il programma per prendere un nome e un cognome. Prova a inserire le opzioni per nome e cognome in ordine inverso per vedere cosa succede.
Risorse
- Come programmare con Bash:sintassi e strumenti
- Come programmare con Bash:operatori logici ed espansioni della shell
- Come programmare con Bash:Loops