Shell Scripting Parte 3: Strutture di Controllo delle Decisioni negli Script Shell

Ciao! Abbiamo già coperto le basi della programmazione shell come accettare input, elaborare dati attraverso operazioni aritmetiche e generare e visualizzare output nelle parti precedenti di questo tutorial (parte 1 e parte 2). In questa parte, approfondiremo un argomento più avanzato in un linguaggio di programmazione: prendere decisioni in un programma, ma questa volta lo faremo utilizzando la shell bash. Iniziamo!

Introduzione

La maggior parte dei nostri linguaggi di programmazione oggi è in grado di prendere decisioni basate su condizioni che impostiamo. Una condizione è un’espressione che si valuta a un valore booleano: vero o falso. Qualsiasi programmatore può rendere il proprio programma intelligente in base alle decisioni e alla logica che inserisce nel suo programma. La shell bash supporta le dichiarazioni di decisione if e switch (case).

Dichiarazione If

If è una dichiarazione che consente al programmatore di prendere una decisione nel programma in base alle condizioni specificate. Se la condizione è soddisfatta, il programma eseguirà determinate righe di codice, altrimenti, il programma eseguirà altri compiti specificati dal programmatore. La seguente è la sintassi supportata della dichiarazione if nella shell bash.

Sintassi Generale

Decisione singola:

if   
 then  
     ### serie di codice qui  
 fi

Decisione doppia:

if   
 then  
     ### serie di codice se la condizione è soddisfatta  
 else  
     ### serie di codice se la condizione non è soddisfatta  
 fi

Condizione if multipla:

if   
 then  
     ### serie di codice per condizione1  
 elif   
 then  
     ### serie di codice per condizione2  
 else  
     ### serie di codice se la condizione non è soddisfatta  
 fi

Sintassi a parentesi singola

if [ condizione ]  
 then  
     ### serie di codice qui  
 fi

Sintassi a doppia parentesi

if ((condizione))  
 then  
     ### serie di codice qui  
 fi

La sintassi a parentesi singola è la sintassi supportata più antica nella shell bash. Viene utilizzata insieme a tutte le dichiarazioni condizionali in Linux. Nel frattempo, la sintassi a doppie parentesi è utilizzata per una dichiarazione condizionale basata su numeri per fornire una sintassi familiare ai programmatori. Tutti i tipi di dichiarazioni if necessitano di una condizione specificata per eseguire un compito.

Dichiarazioni Condizionali in Linux

Le dichiarazioni condizionali vengono utilizzate insieme a una dichiarazione di controllo delle decisioni. Ci sono diversi tipi di dichiarazioni condizionali che puoi utilizzare nella shell bash, le più comuni sono: condizioni basate su file, condizioni basate su stringhe e condizioni basate su aritmetica.

Condizione basata su file

Le condizioni basate su file sono espressioni unarie e vengono spesso utilizzate per esaminare lo stato di un file. La seguente lista mostra le condizioni basate su file più comunemente utilizzate nella shell bash.

Prendere una decisione basata su file

Facciamo un esempio che illustrerà come costruire una decisione basata su file in uno script bash. In questo esempio, creeremo uno script che determina se il file esiste nella directory home.

#!/bin/bash  
   
cd   
 ls  
 if [ -e sample.sh ]   
 then   
     echo "il file esiste!"   
 else   
     echo "il file non esiste"   
 fi

In questo esempio, ci siamo assicurati che la shell tornasse alla directory home indipendentemente dalla nostra directory attiva attuale utilizzando il comando cd. Inoltre, il comando ls viene utilizzato per mostrare l’elenco dei file nella directory per verificare se il file esiste davvero o meno. Come puoi vedere, lo script restituisce il testo “il file esiste!” perché sample.sh si trova nella directory home.

Nota: Il compilatore della shell è molto rigoroso in termini di sintassi, specialmente con gli spazi. Dovrebbe esserci uno spazio tra if e la parentesi aperta e tra le parentesi e la condizione.

Ora miglioriamo il nostro script rendendo il nostro codice più dinamico consentendo all’utente di inserire un nome di file e determinare i permessi del file dato.

#!/bin/bash  
   
cd  
 ls -l   
 read -p "Inserisci un nome di file: " filename  
 if [ -e $filename ]   
 then   
     echo "il file esiste!"   
     if [ -r $filename ]  
     then   
          status="leggibile "   
     fi   
     if [ -w $filename ]   
     then   
          status=$status"scrivibile "   
     fi   
     if [ -x $filename ]   
     then   
          status=$status"eseguibile"   
     fi   
      echo "permesso del file: "$status   
 else   
     echo "il file non esiste"   
 fi

Condizione basata su stringa

Prendere decisioni basate su un input stringa dell’utente è possibile anche nella shell bash. La condizione basata su stringa restituisce un’espressione binaria come risultato, il che significa che restituisce vero se la condizione specificata è soddisfatta, altrimenti restituisce falso. I seguenti sono gli operatori condizionali basati su stringa più comunemente usati:

Creiamo uno script di esempio utilizzando la dichiarazione condizionale basata su stringa. Lo script consentirà all’utente di inserire due stringhe e valutare se una delle stringhe è nulla, entrambe le stringhe sono uguali e non uguali.

#!/bin/bash   
   
read -p "Prima Stringa: " str1   
 read -p "Seconda Stringa: " str2   
 if [ -z "$str1" ]   
 then   
     echo "La 1ª stringa è nulla"   
 elif [ -z "$str2" ]   
 then   
     echo "La 2ª stringa è nulla"   
 else   
     if [ $str1 == $str2 ]   
     then   
          echo "Le stringhe sono uguali"   
     else   
         echo "Le stringhe non sono uguali"   
     fi   
 fi

Condizione basata su aritmetica

La shell fornisce diversi modi per dichiarare una condizione basata su aritmetica. Il primo è utilizzare mnemonici che possono essere utilizzati insieme alla sintassi a parentesi singola di vecchio stile e l’altro è utilizzare simboli amichevoli per la matematica che possono essere utilizzati insieme alle doppie parentesi.

Di seguito è riportato l’elenco dei mnemonici disponibili per le dichiarazioni condizionali basate su aritmetica nella shell:

Creiamo uno script che accetta un intero dall’utente e determina se l’intero è zero, negativo, dispari o un numero pari.

#!/bin/bash   
   
read -p "Inserisci un intero: " int1   
 if [ $int1 -eq 0 ]   
 then   
     echo "Zero"   
 elif [ $int1 -lt 0 ]   
 then   
     echo "Negativo"   
 else   
     if [ $((int1%2)) -eq 0 ]   
     then   
         echo "Pari"   
     else   
         echo "Dispari"   
     fi   
 fi

Operatore aritmetico per sintassi a doppie parentesi:

Ora, ricostruiamo il nostro script precedente e utilizziamo la sintassi a doppie parentesi:

#!/bin/bash  
  
read -p "Inserisci un intero: " int1   
 if (( $int1 == 0 ))   
 then   
     echo "Zero"   
 elif (( $int1 < 0 ))   
 then   
     echo "Negativo"   
 else   
     if (( $((int1%2)) == 0 ))   
     then   
         echo "Pari"   
     else   
         echo "Dispari"   
     fi   
 fi

Dichiarazione Switch

La dichiarazione switch è un altro tipo di dichiarazione condizionale nella programmazione shell. Consente a un programmatore di confrontare diversi valori rispetto a una variabile in un modo più semplice rispetto alla dichiarazione condizionale if. La sintassi per la dichiarazione switch è:

 case  in  
 )  
     ##serie di codice per pattern1  
     ;;  
 )  
     ##serie di codice per pattern2  
     ;;  
 )  
     ##serie di codice per patternN  
     ;;  
 *)   
     ##dichiarazioni predefinite  
 esac  
 

Il pattern è il valore possibile della variabile. Ogni pattern è separato da un doppio punto e virgola che funge da dichiarazione di interruzione del pattern. La dichiarazione switch è chiusa con una dichiarazione esac.

#!/bin/bash   
 clear   
 read -p "Intero1: " int1   
 read -p "Intero2: " int2   
 echo "======================"   
 printf "Menu: \n[a] Addizione\n[b]Sottrazione\n[c]Moltiplicazione\n[d]Divisione\n"   
 echo "======================"   
 read -p "La tua scelta: " choice   
 res=0   
 case $choice in   
 a)   
     res=$((int1+int2))   
 ;;   
 b)   
     res=$((int1-int2))   
 ;;   
 c)   
     res=$((int1*int2))   
 ;;   
 d)   
     res=$((int1/int2))   
 ;;   
 *)   
     echo "Input non valido"   
 esac   
 echo "Il risultato è: " $res

Conclusione

La shell bash fornisce molti strumenti utili per i programmatori. Proprio come la maggior parte dei linguaggi di programmazione oggi, è anche in grado di prendere decisioni condizionali che rendono gli script shell più interattivi e intelligenti. Presenteremo le strutture di controllo ripetitive nella prossima serie. ‘Fino alla prossima volta.

Riferimenti

• http://www.gnu.org/software/bash/manual/html_node/Bash-Conditional-Expressions.html
• https://linuxacademy.com/blog/linux/conditions-in-bash-scripting-if-statements/

La prossima Lezione: Strutture di Controllo della Ripetizione