5 esempi di script Bash per aiutarti a imparare la programmazione Linux

La programmazione tramite script Bash rappresenta una delle metodologie più diffuse e accessibili per interagire con il tuo sistema Linux. Gli esempi di script che seguono sono pensati per facilitare la comprensione di questo processo, fornendo un’introduzione alle basi della programmazione in Bash.

1. Come visualizzare “Hello World” in Bash

L’esempio “Hello World” è un classico punto di partenza nell’apprendimento di qualsiasi linguaggio di programmazione, e Bash non fa eccezione.

Ecco come ottenere la visualizzazione di “Hello World” utilizzando Bash:

Apri un editor di testo e crea un nuovo file, inserendo le righe di codice che verranno illustrate.
La prima linea di uno script Bash deve sempre essere la seguente:
```
#!/bin/bash
```
Il comando Shebang (#!/bin/bash) è cruciale, poiché la shell lo utilizza per determinare come eseguire lo script, in questo caso, attraverso l’interprete Bash.
Ogni riga che inizia con il simbolo # è interpretata come un commento. La riga Shebang è un caso speciale, ma puoi utilizzare i commenti per chiarire il tuo codice. Aggiungi, ad esempio, un commento alla riga 2:
```
# Questo è un commento
```
Per visualizzare un output standard, si utilizza il comando `echo`, seguito dal testo che si vuole mostrare. Aggiungi la seguente riga (riga 3):
```
echo "Hello World"
```
Salva lo script, preferibilmente con l’estensione .sh, ad esempio hello_world.sh. L’estensione non è obbligatoria, ma è una convenzione utile da seguire.
Per rendere lo script eseguibile, usa il comando `chmod` (“change mode”) con l’argomento +x (“eseguibile”), seguito dal nome del file dello script:
```
chmod +x hello_world.sh
```
Per avviare lo script dalla sua directory, utilizza il comando:
```
./hello_world.sh
```
Dopo l’esecuzione, lo script mostrerà il testo “Hello World” nel tuo terminale:

2. Creare una directory acquisendo l’input

Attraverso gli script, è possibile eseguire qualsiasi programma che normalmente si esegue da riga di comando. Per esempio, puoi creare una nuova directory con il comando `mkdir` all’interno di uno script.

Inizia come prima con la dichiarazione:
```
#!/bin/bash
```
Chiedi all’utente di inserire il nome della directory utilizzando il comando `echo`:
```
echo "Inserisci il nome della nuova directory:"
```
Utilizza il comando integrato `read` per recuperare l’input dell’utente. L’argomento di `read` specifica la variabile in cui verrà memorizzato l’input:
```
read newdir
```
Per utilizzare il valore di una variabile, bisogna anteporre il simbolo del dollaro ($). Il contenuto della variabile può essere passato come argomento al comando `mkdir` per creare una directory:
```
mkdir $newdir
```
Quando lo script verrà eseguito, ti verrà chiesto di inserire un input. Digitando un nome valido, lo script creerà una directory nella tua directory corrente:

3. Creare una directory usando gli argomenti della riga di comando

In alternativa all’acquisizione interattiva dell’input, la maggior parte dei comandi Linux supporta gli argomenti. Un argomento può essere fornito all’avvio di un programma per modificarne il comportamento.

All’interno di uno script, è possibile fare riferimento al primo argomento tramite la variabile speciale `$1`, al secondo tramite `$2`, e così via.

Crea una directory utilizzando il comando `mkdir` come nell’esempio precedente, ma questa volta, utilizza la variabile integrata `$1`:
```
#!/bin/bash
mkdir $1
```
Esegui lo script, passando il nome della nuova directory come argomento:
```
./arg_dir.sh Test
```

Potresti chiederti cosa succede se lo script viene avviato senza alcun argomento. Provalo per scoprirlo; dovresti ricevere un messaggio di errore che inizia con “usage: mkdir”:

Senza argomenti, il valore di `$1` sarà vuoto. Quando lo script chiama `mkdir`, non gli verrà passato alcun argomento, causando l’errore. Per evitarlo, si può introdurre un controllo per presentare un messaggio di errore più chiaro:

Come sempre, inizia con la riga shebang:
```
#!/bin/bash
```
Prima di chiamare `mkdir`, controlla se il primo argomento è vuoto, usando l’istruzione `if` di Bash che esegue un blocco di codice a seconda di una condizione:
```
if [ "$1" = "" ]; then
```

Se il primo argomento è vuoto, visualizza un messaggio di errore ed esci dallo script:

    echo "Per favore, inserisci il nome della directory come primo argomento"
    exit

La parola chiave `fi` (ovvero “if” al contrario) indica la fine dell’istruzione `if` in Bash:
```
fi
```
Ora lo script può proseguire come prima, gestendo il caso in cui è presente un argomento:
```
mkdir $1
```

Avviando questa nuova versione dello script, verrà mostrato un messaggio di avviso se si dimentica di inserire un argomento:

4. Eliminare un file utilizzando una funzione Bash

Quando ti ritrovi a ripetere lo stesso codice, valuta la possibilità di incapsularlo in una funzione. Potrai poi richiamare la funzione tutte le volte che serve.

Ecco un esempio di funzione per eliminare un file:

Inizia con la riga shebang:
```
#!/bin/bash
```
Definisci una funzione scrivendone il nome, seguito da parentesi vuote e i comandi racchiusi tra parentesi graffe:
```
del_file() {
    echo "Eliminazione di $1"
    rm $1
}
```
Puoi richiamare la funzione passando il nome del file da eliminare:
```
del_file test.txt
```

Quando una funzione viene chiamata, essa imposta la variabile speciale `$?` con il codice di uscita dell’ultimo comando eseguito. Il codice di uscita è utile per la gestione degli errori; in questo caso, è possibile verificare se il comando `rm` è andato a buon fine:

if [ $? -ne 0 ]; then
    echo "Impossibile eliminare il file"
fi

5. Creare una calcolatrice di base per calcoli aritmetici

Quest’ultimo esempio mostra una calcolatrice semplificata. In fase di esecuzione, verranno richiesti due valori numerici e poi verrà chiesta un’operazione aritmetica da eseguire.

Ecco il codice per calc.sh:

#!/bin/bash

echo "Inserisci il primo numero: "
read a

echo "Inserisci il secondo numero: "
read b

echo "Scegli l'operazione aritmetica:"
echo "1. Addizione"
echo "2. Sottrazione"
echo "3. Moltiplicazione"
echo "4. Divisione"
read choice

case $choice in
    1)
    result=`echo $a + $b | bc`
    ;;
    2)
    result=`echo $a - $b | bc`
    ;;
    3)
    result=`echo $a \* $b | bc`
    ;;
    4)
    result=`echo "scale=2; $a / $b" | bc`
    ;;
esac

echo "Risultato: $result"

Si noti l’uso di `case … esac`, equivalente all’istruzione `switch` di altri linguaggi. Permette di testare un valore, in questo caso la variabile `choice`, rispetto a diversi valori fissi ed eseguire il codice corrispondente.

Questo script utilizza il comando `bc` per eseguire ogni calcolo.