Ciao! Benvenuti nella serie di tutorial sugli script di shell di HowToForge. Se vuoi leggere le versioni precedenti del tutorial, fai clic qui per la parte 1, parte 2, parte 3 e parte 4 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 in Linux Bash Shell, 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]. Consente ai programmatori di suddividere un codice complicato e lungo in piccole sezioni che possono essere chiamate quando necessario. Ogni funzione deve essere chiamata da una routine principale per essere eseguita, quindi è isolata con altre parti del codice e questo crea un modo semplice per testare il codice. Inoltre, le funzioni possono essere richiamate in qualsiasi momento e ripetutamente, ciò consente di riutilizzare, ottimizzare e ridurre al minimo i codici. Come la maggior parte dei linguaggi di programmazione, anche la shell bash supporta le funzioni.
Sintassi generale:
- Sintassi 1:
function function_name
{
##### set of commands
} - Sintassi 2:
function_name()
{
#### set of commands
}
Creazione di funzioni
Il bash supporta due strutture per le funzioni. Nell'usare la prima sintassi, devi usare la parola chiave funzione, seguita dal nome della tua funzione e aprire e chiudere parentesi e parentesi graffe per separare il contenuto delle tue funzioni dalla tua routine principale. Troverai questa sintassi familiare se hai un background in PHP perché le funzioni in PHP sono dichiarate allo stesso modo. L'altra sintassi consiste solo in un nome di funzione, parentesi aperte e chiuse e parentesi graffe.
#!/bin/bash
myfunction(){
echo "My function works!"
}
myfunction
Ho usato la seconda sintassi nel nostro esempio. Dopo aver creato la funzione myfunction, è stata quindi invocata chiamando il nome della sua funzione nella nostra routine principale. La routine principale sarà ovunque nel nostro script che non è stato definito come parte della nostra funzione.
Ora riorganizziamo il nostro codice per verificare se le funzioni possono essere dichiarate ovunque nel nostro script. Considera il codice seguente:
#!/bin/bash
echo "testing my function"
myfunction
myfunction(){
echo "My function works!"
}
La riga 3 nel codice precedente restituisce un errore di comando non trovato. Questo significa solo che:
The function only works if it is declared before your main routine. The interpreter will return an error if you have declared your function after your main routine.
Ristrutturazione di codici utilizzando le funzioni
Una delle migliori caratteristiche delle funzioni è la possibilità di riutilizzare i codici. Quando una procedura richiede l'esecuzione ripetuta di comandi ma non può essere strutturata utilizzando istruzioni di ciclo, una funzione può essere una soluzione.
Ad esempio, considera il codice seguente:
#!/bin/bash
while(true)
do
clear
printf "Choose from the following operations: \n"
printf "[a]ddition\n[b]Subtraction\n[c]Multiplication\n[d]Division\n"
printf "################################\n"
read -p "Your choice: " choice
case $choice in
[aA])
read -p "Enter first integer: " int1
read -p "Enter second integer: " int2
res=$((int1+int2))
;;
[bB])
read -p "Enter first integer: " int1
read -p "Enter second integer: " int2
res=$((int1-int2))
;;
[cC])
read -p "Enter first integer: " int1
read -p "Enter second integer: " int2
res=$((int1*int2))
;;
[dD])
read -p "Enter first integer: " int1
read -p "Enter second integer: " int2
res=$((int1/int2))
;;
*)
res=0
echo "wrong choice!"
esac
echo "The result is: " $res
read -p "Do you wish to continue? [y]es or [n]o: " ans
if [ $ans == 'n' ]
then
echo "Exiting the script. Have a nice day!"
break
else
continue
fi
done
Lo script funziona bene, tuttavia, nota che le righe per accettare gli input vengono ripetute ripetutamente in ogni schema nella nostra istruzione switch.
#!/bin/bash
inputs(){
read -p "Enter first integer: " int1
read -p "Enter second integer: " int2
}
exitPrompt(){
read -p "Do you wish to continue? [y]es or [n]o: " ans
if [ $ans == 'n' ]
then
echo "Exiting the script. Have a nice day!"
break
else
continue
fi
}
while(true)
do
clear
printf "Choose from the following operations: \n"
printf "[a]Addition\n[b]Subtraction\n[c]Multiplication\n[d]Division\n"
printf "################################\n"
read -p "Your choice: " 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 "wrong choice!"
esac
echo "The result is: " $res
exitPrompt
done
Abbiamo migliorato il nostro codice creando sottosezioni input e exitPrompt. Funziona esattamente allo stesso modo con il nostro codice precedente, tuttavia, il nostro codice attuale è più facile da risolvere perché è strutturato correttamente.
Trasmissione di parametri su funzioni
Come la maggior parte dei linguaggi di programmazione, puoi passare parametri ed elaborare quei dati in funzioni in bash. Il codice seguente mostra la procedura su come passare i valori nello scripting della shell:
#!/bin/bash
myfunction(){
echo $1
echo $2
}
myfunction "Hello" "World"
Nota nel nostro esempio, abbiamo aggiunto i valori "Hello" e "World" dopo aver chiamato la mia funzione. Questi valori vengono passati alla myfunction come parametri e archiviati in una variabile locale. Tuttavia, a differenza di altri linguaggi, l'interprete memorizza i valori passati in variabili predefinite, che prendono il nome in base alla sequenza di passaggio dei parametri, 1 come nome iniziale fino all'ordine di passaggio. Si noti che la parola "Ciao" è memorizzata nella variabile 1 e il valore "Mondo" è memorizzato nella variabile 2.
Nota:1 e 2 nel nostro esempio sono variabili locali e quindi non sono accessibili ad altre parti dello script a parte la funzione in cui vengono passati i parametri.
Ad esempio,
#!/bin/bash
myfunction(){
echo $1
echo $2
}
myfunction "Hello" "World"
echo $1
echo $2
L'echo $1 e l'echo $2 nelle ultime due righe del nostro script non hanno display poiché l'interprete non riconosce entrambe le variabili perché sono entrambe locali alla mia funzione.
Restituire valori dalle funzioni
Oltre a creare funzioni e passarvi parametri, le funzioni bash possono passare i valori di una variabile locale di una funzione alla routine principale usando la parola chiave return. I valori restituiti vengono quindi archiviati nella variabile predefinita $? Ad esempio, considera il seguente codice:
#!/bin/bash
add(){
sum=$(($1+$2))
return $sum
}
read -p "Enter an integer: " int1
read -p "Enter an integer: " int2
add $int1 $int2
echo "The result is: " $?
Nell'esempio, passiamo i parametri int1 e int2 alla funzione add. Successivamente la funzione add lo elabora attraverso la riga sum=$(($1+$2)). Quindi il valore della variabile sum viene passato alla routine principale tramite la riga return $sum. Per impostazione predefinita, i valori di $sum verranno archiviati nella variabile predefinita $? Infine, la riga fa eco "Il risultato è:" $? stampa il risultato.
Note: Shell scripts can only return a single value.
A differenza di altri linguaggi di programmazione, gli script di 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 "Enter an integer: " int1
read -p "Enter an integer: " int2
add $int1 $int2
echo "The result is: " $?
echo "The result is: " $?
Per riassumere
Facciamo un altro esempio che usa funzioni, gli passa parametri e restituisce valore.
#!/bin/bash
#####################
#Author: HowtoForge #
#####################
clear(){
clear
}
bin(){
bin1=$(echo "obase=2;$1"|bc)
echo $bin1
}
dec(){
dec1=$(echo "ibase=2;$1"|bc)
return $dec1
}
########Main#########
printf "Choose from the following operations:\n[1]Decimal to Binary Conversion\n"
printf "[2]Binary to Decimal Conversion\n"
read -p "Your choice: " op
case $op in
1)
read -p "Enter integer number: " int
bin $int
;;
2)
read -p "Enter binary number: " int
dec $int
echo "The decimal equivalent of $int is $?"
;;
*)
echo "Wrong Choice!"
esac
L'esempio fornito converte un dato input in un valore sia 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.
Note: It's better to use echo directly when converting from decimal to binary because when you return command to pass a binary value, the bash converts the binary value to decimal before returning it.
Inoltre, abbiamo convertito il valore binario in decimale usando il comando $(echo "ibase=2;$1"|bc).
È inoltre necessario ricordare che l'interprete è in grado di accettare solo cifre binarie a 8 bit. Immetterai la cifra che supera 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 nella parte destra (bit più significativo) verranno omessi, quindi 1000001010 diventerà uguale a 00001010 che è uguale a 10. Se si vuoi un'operazione che accetti cifre binarie superiori a 8 bit, devi creare il codice manualmente.
Conclusione
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 migliorato le tue conoscenze sugli script di shell attraverso le funzioni. Funziona negli script della shell per fornire modularità all'utente, semplificando la risoluzione dei problemi degli script e consentendo il riutilizzo del codice.