Shell Scripting Parte V: Funzioni in Bash

Ciao! Benvenuto nella serie di tutorial sulla shell scripting di HowToForge. Se vuoi leggere le versioni precedenti del tutorial, sentiti libero di cliccare qui per la parte1, parte2, parte3 e parte4 del tutorial. In questa parte, imparerai come strutturare in modo efficiente i tuoi script creando funzioni. Alla fine di questo tutorial, sarai in grado di sapere come creare funzioni nella Shell Bash di Linux, passare parametri alle tue funzioni e restituire alcuni valori da una funzione al tuo codice principale. Iniziamo!

Introduzione

Una funzione, nota anche come subroutine nei linguaggi di programmazione, è un insieme di istruzioni che esegue un compito specifico per una routine principale [1]. Permette ai programmatori di suddividere un codice complicato e lungo in piccole sezioni che possono essere chiamate ogni volta che necessario. Ogni funzione deve essere chiamata da una routine principale per essere eseguita, quindi è isolata dalle altre parti del tuo codice e questo crea un modo semplice per testare il codice. Inoltre, le funzioni possono essere chiamate in qualsiasi momento e ripetutamente, questo ti consente di riutilizzare, ottimizzare e ridurre al minimo i tuoi codici. Come la maggior parte dei linguaggi di programmazione, anche la shell bash supporta le funzioni.

Sintassi Generale:

1. Sintassi 1: function function_name { ##### insieme di comandi }
2. Sintassi 2: function_name() { #### insieme di comandi }

Creazione di Funzioni

La bash supporta due strutture per le funzioni. Utilizzando la prima sintassi, devi usare la parola chiave function, seguita dal nome della tua funzione e dalle parentesi tonde e graffe per separare i contenuti delle tue funzioni dalla tua routine principale. Troverai questa sintassi familiare se hai una formazione in PHP perché le funzioni in PHP sono dichiarate nello stesso modo. L’altra sintassi consiste solo in un nome di funzione, parentesi tonde aperte e chiuse e graffe.

#!/bin/bash  
myfunction(){  
    echo "La mia funzione funziona!"  
}  
myfunction

Ho usato la seconda sintassi nel nostro esempio. Dopo aver creato la funzione myfunction, è stata quindi invocata chiamando il suo nome di funzione nella nostra routine principale. La routine principale sarà ovunque nel nostro script che non è stata definita come parte della nostra funzione.

Ora riordiniamo il nostro codice per testare se le funzioni possono essere dichiarate ovunque nel nostro script. Considera il codice qui sotto:

#!/bin/bash  
echo "testando la mia funzione"  
myfunction  
  
myfunction(){  
    echo "La mia funzione funziona!"  
}

La riga 3 nel codice sopra restituisce un errore di comando non trovato. Questo significa solo che:

La funzione funziona solo se è dichiarata prima della tua routine principale. L'interprete restituirà un errore se hai dichiarato la tua funzione dopo la tua routine principale.

Ristrutturazione dei codici utilizzando funzioni

Una delle migliori caratteristiche delle funzioni è la possibilità di riutilizzare i codici. Quando una procedura richiede di eseguire ripetutamente comandi ma non può essere strutturata utilizzando dichiarazioni di loop, allora una funzione può essere una soluzione.

Ad esempio, considera il codice qui sotto:

#!/bin/bash  
while(true)  
do  
    clear  
    printf "Scegli tra le seguenti operazioni: \n"  
    printf "[a]ddizione\n[b]Sottrazione\n[c]Moltiplicazione\n[d]Divisione\n"  
    printf "################################\n"  
    read -p "La tua scelta: " choice  
    case $choice in  
    [aA])  
        read -p "Inserisci il primo intero: " int1  
        read -p "Inserisci il secondo intero: " int2  
        res=$((int1+int2))  
   
    ;;  
    [bB])  
        read -p "Inserisci il primo intero: " int1  
        read -p "Inserisci il secondo intero: " int2  
    res=$((int1-int2))  
   
    ;;  
    [cC])  
        read -p "Inserisci il primo intero: " int1  
        read -p "Inserisci il secondo intero: " int2  
        res=$((int1*int2))  
   
    ;;  
    [dD])  
        read -p "Inserisci il primo intero: " int1  
        read -p "Inserisci il secondo intero: " int2  
        res=$((int1/int2))  
   
    ;;  
    *)  
        res=0  
        echo "scelta sbagliata!"  
    esac  
  
    echo "Il risultato è: " $res  
    read -p "Vuoi continuare? [y]es o [n]o: " ans  
    if [ $ans == 'n' ]  
        then  
         echo "Uscita dallo script. Buona giornata!"  
        break  
    else  
        continue  
    fi  
  
done

Lo script funziona bene, tuttavia, nota che le righe per accettare input sono ripetutamente fatte in ogni modello nella nostra istruzione switch.

#!/bin/bash  
inputs(){  
     read -p "Inserisci il primo intero: " int1  
    read -p "Inserisci il secondo intero: " int2  
}  
  
exitPrompt(){  
    read -p "Vuoi continuare? [y]es o [n]o: " ans  
    if [ $ans == 'n' ]  
    then  
        echo "Uscita dallo script. Buona giornata!"  
        break  
    else  
        continue  
    fi  
}  
  
while(true)  
    do  
    clear  
    printf "Scegli tra le seguenti operazioni: \n"  
    printf "[a]Addizione\n[b]Sottrazione\n[c]Moltiplicazione\n[d]Divisione\n"  
    printf "################################\n"  
    read -p "La tua scelta: " choice  
  
    case $choice in  
    [aA])  
        inputs  
        res=$((int1+int2))  
    ;;  
  
    [bB])  
        inputs  
        res=$((int1-int2))  
    ;;  
  
    [cC])  
        inputs  
        res=$((int1*int2))  
    ;;  
  
    [dD])  
        inputs  
        res=$((int1/int2))  
    ;;  
  
    *)  
        res=0  
        echo "scelta sbagliata!"  
    esac  
  
    echo "Il risultato è: " $res  
    exitPrompt  
done

Abbiamo migliorato il nostro codice creando sottosezioni inputs e exitPrompt. Funziona esattamente come il nostro codice precedente, tuttavia, il nostro codice attuale è più facile da risolvere perché è strutturato correttamente.

Passaggio di parametri alle funzioni

Come la maggior parte dei linguaggi di programmazione, puoi passare parametri e elaborare quei dati nelle funzioni in bash. Il codice qui sotto mostra la procedura su come passare valori nella shell scripting:

#!/bin/bash  
myfunction(){  
    echo $1  
    echo $2  
}  
  
myfunction "Ciao" "Mondo"

Nota nel nostro esempio, abbiamo aggiunto i valori “Ciao” e “Mondo” dopo aver chiamato la myfunction. Quei valori vengono passati alla myfunction come parametri e memorizzati in una variabile locale. Tuttavia, a differenza di altri linguaggi, l’interprete memorizza i valori passati in variabili predefinite, che sono nominate in base alla sequenza di passaggio dei parametri, 1 come nome iniziale fino all’ordine di passaggio. Nota che la parola “Ciao” è memorizzata nella variabile 1 e il valore “Mondo” è memorizzato nella variabile 2.

Nota: Le variabili 1 e 2 nel nostro esempio sono variabili locali e quindi non sono accessibili ad altre parti dello script al di fuori della funzione in cui vengono passati i parametri.

Ad esempio,

#!/bin/bash  
myfunction(){  
    echo $1  
    echo $2  
}  
  
myfunction "Ciao" "Mondo"  
echo $1  
echo $2

L’echo $1 e l’echo $2 nelle ultime due righe del nostro script non hanno alcuna visualizzazione poiché l’interprete non riconosce entrambe le variabili perché sono entrambe locali alla myfunction.

Restituzione di Valori dalle Funzioni

Oltre a creare funzioni e passare parametri ad esse, le funzioni bash possono restituire i valori di una variabile locale della funzione alla routine principale utilizzando la parola chiave return. I valori restituiti vengono quindi memorizzati nella variabile predefinita $?. Ad esempio, considera il seguente codice:

#!/bin/bash  
add(){  
    sum=$(($1+$2))  
    return $sum  
}  
  
read -p "Inserisci un intero: " int1  
read -p "Inserisci un intero: " int2  
add $int1 $int2  
echo "Il risultato è: " $?

Nell’esempio, passiamo i parametri int1 e int2 alla funzione add. Successivamente, la funzione add li elabora attraverso la riga sum=$(($1+$2)). Poi il valore della variabile sum viene passato alla routine principale attraverso la riga return $sum. Per impostazione predefinita, i valori di $sum verranno memorizzati nella variabile predefinita $?. Infine, la riga echo “Il risultato è: “ $? stampa il risultato.

Nota: Gli script shell possono restituire solo un valore singolo.

A differenza di altri linguaggi di programmazione, gli script shell non possono restituire più valori da una funzione. Diamo un’occhiata a questo esempio:

#!/bin/bash  
add(){  
    sum=$(($1+$2))  
    dif=$(($1-$2))  
    return $sum   
}  
  
read -p "Inserisci un intero: " int1  
read -p "Inserisci un intero: " int2  
add $int1 $int2  
echo "Il risultato è: " $?  
echo "Il risultato è: " $?

Per riassumere

Facciamo un altro esempio che utilizza funzioni, passa parametri ad esse e restituisce valore.

#!/bin/bash  
#####################  
#Autore: HowtoForge #  
#####################  
   
clear(){  
    clear  
}  
  
bin(){  
    bin1=$(echo "obase=2;$1"|bc)  
    echo $bin1  
}  
  
dec(){  
    dec1=$(echo "ibase=2;$1"|bc)  
    return $dec1  
}  
  
########Main#########  
    printf "Scegli tra le seguenti operazioni:\n[1]Conversione da Decimale a Binario\n"  
    printf "[2]Conversione da Binario a Decimale\n"  
    read -p "La tua scelta: " op  
    case $op in  
  
    1)  
        read -p "Inserisci numero intero: " int  
        bin $int  
    ;;  
  
    2)  
        read -p "Inserisci numero binario: " int  
        dec $int  
        echo "L'equivalente decimale di $int è $?"  
    ;;  
  
    *)  
        echo "Scelta Sbagliata!"  
    esac

L’esempio dato converte un input dato sia in valore binario che decimale utilizzando il comando obase e ibase. La riga $(echo “obase=2;$1”|bc) converte un dato valore decimale in cifra binaria e lo memorizza nella variabile bin1. Successivamente abbiamo visualizzato il valore di $bin1 utilizzando il comando echo.

Nota: È meglio usare echo direttamente quando si converte da decimale a binario perché quando restituisci un comando per passare un valore binario, la bash converte il valore binario in decimale prima di restituirlo.

Inoltre, abbiamo convertito il valore binario in decimale utilizzando il comando $(echo “ibase=2;$1”|bc).

Devi anche ricordare che l’interprete è in grado di accettare solo cifre binarie a 8 bit. Se inserisci cifre che superano il limite di 8 bit, genererà un overflow e il bit più significativo della cifra verrà scartato.

La cifra binaria a 10 bit 1000001010 restituisce 10 poiché seguendo la regola degli 8 bit, i restanti 2 bit sul lato destro (bit più significativo) verranno omessi, quindi 1000001010 diventerà uguale a 00001010 che è uguale a 10. Se desideri un’operazione che accetti cifre binarie superiori a 8 bit, allora devi creare il codice manualmente.

Conclusione

La bash ha funzionalità molto simili ai linguaggi di programmazione per fornire numerosi strumenti all’utente e rendere i sistemi Linux più potenti. In questa serie, hai ampliato le tue conoscenze nella shell scripting attraverso le funzioni. Le funzioni negli script shell forniscono modularità all’utente, rendendo gli script più facili da risolvere e consentendo il riutilizzo del codice.

Riferimento:

[1] American Heritage® Dictionary of the English Language, Fifth Edition. Copyright © 2011 di Houghton Mifflin Harcourt Publishing Company. Pubblicato da Houghton Mifflin Harcourt Publishing Company.