Utilizzo delle istruzioni Case in Bash

Quando si scrivono script Bash, è comune controllare una stringa rispetto a una variabile e quindi fare qualcosa in base a ciò che è stato specificato.

Considera il seguente script. Controlla il primo argomento specificato da un utente e fa cose diverse a seconda di ciò che è stato fornito:

#!/usr/bin/env bash
if [[ "${1}" == "" ]]; then
	echo "No shape was specified."

elif [[ "${1}" == "square" ]]; then
	echo "You specified 'square'."

elif [[ "${1}" == "circle" ]]; then
	echo "You specified 'circle'."

elif [[ "${1}" == "triangle" ]]; then
	"You specified 'triangle'." 
    
else
	echo "Unknown shape '${1}'."
    exit 1

fi

Questo dimostra, anche se senza funzionalità, una semplice attività che può ripetere una forma nota a un utente o, se la forma è sconosciuta, mostrare un messaggio di errore.

Va tutto bene e dandy in questo, e tutto funziona come previsto. Ma guarda quante righe ci sono volute. Guarda come devi gestire ogni singola opzione che un utente passa attraverso un elif dichiarazione?

Ora l'imaging di questo programma ha ancora più opzioni, diciamo 20. Con l'approccio attuale, scriverai un if dichiarazione con 20 elif sezioni al suo interno.

Sì, probabilmente sarai in grado di leggerlo per la maggior parte. Ma è goffo, occupa troppo spazio e, soprattutto, c'è un'alternativa migliore.

Introduzione alla dichiarazione del caso in Bash

È qui che entrano in gioco le istruzioni case. Queste possono ridurre notevolmente il numero di righe di codice necessarie per controllare le cose rispetto a if dichiarazioni.

Lo stesso if l'istruzione che hai utilizzato per verificare le opzioni fornite potrebbe essere riscritta in questo modo all'interno di un caso uno:

#!/usr/bin/env bash
case "${1}" in
	"")         echo "No option was specified."; exit 1 ;;
    square)     echo "You specified 'square'." ;;
    circle)     echo "You specified 'circle'." ;;
    triangle)   echo "You specified 'triangle'." ;;
    *)          echo "Unknown shape '${1}'."; exit 1 ;;
esac

Guarda quanto sembra più semplice e organizzato. Cioè 12 righe di codice in if istruzione e solo 7 nel case uno. E più opzioni consenti, più drastica diventa la differenza.

Ed è qui che case le affermazioni brillano. Anche se entrambi sono completamente leggibili, specialmente per una piccola quantità, case le dichiarazioni semplicemente rendono tutto più pulito e più gestibile a lungo termine.

Come si crea un'istruzione case in Bash?

Le dichiarazioni dei casi sono piuttosto semplici da capire con solo un po' di pratica. Detto questo, ecco le basi di quello che sta succedendo:

La prima riga che hai visto era case ${1} in . Il ${1} fornisce la stringa che verrà confrontata, essendo qui il primo argomento passato allo script.

Ad esempio, considera questa affermazione del caso:

case linux in
    windows)    echo "windows" ;;
    macos)      echo "macos" ;;
    linux)      echo "linux" ;;
esac

In questo esempio, eseguirà sempre echo "linux" . Il case *string* in parte specifica semplicemente la stringa su cui eseguire il controllo, quindi le opzioni sotto di essa eseguiranno i comandi ogni volta che viene trovata una corrispondenza.

Successivamente, inizi a specificare le tue opzioni. Ricorda, avevi "" , square , circle , triangle e * come opzioni nel tuo primo script.

Le dichiarazioni dei casi vengono verificate dall'alto verso il basso e vengono eseguite solo alla prima corrispondenza. Considera il seguente esempio:

case linux in
	linux)      echo "linux" ;;
    windows)    echo "windows" ;;
    linux)      echo "linux 2.0" ;;
esac

Qui, l'unico comando che verrebbe eseguito sarebbe echo "linux" . La seconda corrispondenza verrebbe quindi saltata, poiché era già stata trovata una corrispondenza.

Ogni riga in una dichiarazione del caso deve anche terminare con ;; . Ciò significa la fine dell'elenco dei comandi per un'opzione e che non devono essere elaborati altri comandi.

Gli argomenti vengono elencati in un'istruzione case (il linux) e windows) le parti supportano anche i caratteri jolly. Quindi, inserendo qualcosa come linu*) corrisponderebbe a entrambi linux e linus .

Infine, chiudi la dichiarazione del caso con esac . Questo gli consente di sapere che hai elencato tutto ciò che vorresti elaborare, come done farebbe in un for o while ciclo.

Per ricordare la parola chiave per completare l'istruzione di un caso, ricorda semplicemente che esac è case indietro.

Dichiarazioni del caso in pratica - controlli degli argomenti

Un uso frequente delle istruzioni case nella mia programmazione è il confronto con un elenco di argomenti.

Supponi di consentire la fornitura delle seguenti opzioni al tuo programma:

• --vertical
• --add-txt
• --replace
• --verify

Per verificarlo in una dichiarazione del caso, potresti usare qualcosa del genere:

while [[ "${1}" != "" ]]; do
	case "${1}" in
    	--vertical)    verticle="true" ;;
        --add-txt)     add_txt="true" ;;
        --replace)     replace="true" ;;
        --verify)      verify="true" ;;
    esac
    
    shift 1
done

Questo viene eseguito un while ciclo while ${1} (il primo argomento fornito a uno script) non è vuoto. Quindi controlla un elenco di argomenti e assegna variabili quando è impostata l'opzione fornita.

Dopo aver verificato la dichiarazione del caso, esegue quindi shift 1 , causando il valore di ${2} (il secondo argomento fornito a uno script) per passare al valore di ${1} e lo ripete contro il nuovo ${1} (che in precedenza era ${2} ) fino a ${1} non è impostato su nulla.

Ed ecco qua! Queste sono tutte le basi per utilizzare le istruzioni case.

Conclusione

Le istruzioni Case possono aiutarti a scrivere codice in modo più rapido ed efficiente. Aiutano anche a rendere le cose più leggibili e gestibili a lungo termine.

Se non conosci Bash, puoi imparare le basi di Bash da zero nella nostra serie Bash per principianti.

Hai domande o qualcosa non funziona correttamente? Sentiti libero di lasciare un commento qui sotto e farò del mio meglio per rispondere!