Capitolo 2. Iniziare con #!

Nel caso più semplice, uno script non è nient'altro che un file contenente un elenco di comandi di sistema. Come minimo si risparmia lo sforzo di ridigitare quella particolare sequenza di comandi tutte le volte che è necessario.

# Cleanup
# Da eseguire come root, naturalmente.

cd /var/log
cat /dev/null > messages
cat /dev/null > wtmp
echo "Log cancellati."

Come si può vedere, non c'è niente di insolito, solo una serie di comandi che potrebbero essere eseguiti uno ad uno dalla riga di comando di una console o di un xterm. I vantaggi di collocare dei comandi in uno script vanno, però, ben al di là del non doverli reimmettere ogni volta. Lo script, infatti, può essere modificato, personalizzato o generalizzato per un'applicazione particolare.

#!/bin/bash
# Corretta intestazione di uno script Bash.

# Cleanup, versione 2

# Da eseguire come root, naturalmente.
#  Qui va inserito il codice che visualizza un messaggio d'errore e l'uscita
#+ dallo script nel caso l'esecutore non sia root.

DIR_LOG=/var/log
# Meglio usare le variabili che codificare dei valori.
cd $DIR_LOG

cat /dev/null > messages
cat /dev/null > wtmp


echo "Log cancellati."

exit # Metodo corretto per "uscire" da uno script.

Adesso incomincia ad assomigliare ad un vero script. Ma si può andare oltre . . .

#!/bin/bash
#  Cleanup, versione 3

#  Attenzione:
#  -----------
#  In questo script sono presenti alcune funzionalità che verranno
#+ spiegate più avanti.
#  Quando avrete ultimato la prima metà del libro,
#+ forse non vi apparirà più così misterioso.



DIR_LOG=/var/log
ROOT_UID=0     # Solo gli utenti con $UID 0 hanno i privilegi di root.
LINEE=50       # Numero prestabilito di righe salvate.
E_XCD=66       # Riesco a cambiare directory?
E_NONROOT=67   # Codice di exit non-root.


# Da eseguire come root, naturalmente.
if [ "$UID" -ne "$ROOT_UID" ]
then
  echo "Devi essere root per eseguire questo script."
  exit $E_NONROOT
fi  

if [ -n "$1" ]
# Verifica se è presente un'opzione da riga di comando (non-vuota).
then
  linee=$1
else  
  linee=$LINEE # Valore preimpostato, se non specificato da riga di comando.
fi  


#  Stephane Chazelas suggerisce il codice seguente,
#+ come metodo migliore per la verifica degli argomenti da riga di comando,
#+ ma è ancora un po' prematuro a questo punto del manuale.
#
#    E_ERR_ARG=65   # Argomento non numerico (formato dell'argomento non valido)
#
#    case "$1" in
#    ""      ) linee=50;;
#    *[!0-9]*) echo "Utilizzo: `basename $0` file-da-cancellare"; exit\
# $E_ERR_ARG;;
#    *       ) linee=$1;;
#    esac
#
#* Vedere più avanti al capitolo "Cicli" per la comprensione delle righe 
#+ precedenti.


cd $DIR_LOG

if [ `pwd` != "$DIR_LOG" ]  # o   if [ "$PWD" != "$DIR_LOG" ]
                            # Non siamo in /var/log?
then
  echo "Non riesco a cambiare in $DIR_LOG."
  exit $E_XCD
fi  #  Doppia verifica per vedere se ci troviamo nella directory corretta,
    #+ prima di cancellare il file di log.

# ancora più efficiente:
#
# cd /var/log || {
#   echo "Non riesco a spostarmi nella directory stabilita." >&2
#   exit $E_XCD;
# }




tail -n $linee messages > mesg.temp # Salva l'ultima sezione del file di
                                    # log messages.
mv mesg.temp messages               # Diventa la nuova directory di log.


# cat /dev/null > messages
#* Non più necessario, perché il metodo precedente è più sicuro.

cat /dev/null > wtmp  #  ': > wtmp' e '> wtmp'  hanno lo stesso effetto.
echo "Log cancellati."

exit 0
#  Il valore di ritorno zero da uno script
#+ indica alla shell la corretta esecuzione dello stesso.

Poiché non si voleva cancellare l'intero log di sistema, questa versione dello script mantiene inalterata l'ultima sezione del file di log messages. Si scopriranno continuamente altri modi per rifinire gli script precedenti ed aumentarne l'efficienza.

I caratteri ( #!), all'inizio dello script, informano il sistema che il file contiene una serie di comandi che devono essere passati all'interprete indicato. I caratteri #! in realtà sono un magic number di due byte, [1] vale a dire un identificatore speciale che designa il tipo di file o, in questo caso, uno script di shell eseguibile (eseguite man magic per ulteriori dettagli su questo affascinante argomento). Immediatamente dopo #! compare un percorso. Si tratta del percorso al programma che deve interpretare i comandi contenuti nello script, sia esso una shell, un linguaggio di programmazione o una utility. L'interprete esegue quindi i comandi dello script, partendo dall'inizio (la riga successiva a #!) e ignorando i commenti. [2]

#!/bin/sh
#!/bin/bash
#!/usr/bin/perl
#!/usr/bin/tcl
#!/bin/sed -f
#!/usr/awk -f

Ognuna delle precedenti intestazioni di script richiama un differente interprete di comandi, sia esso /bin/sh, la shell (bash in un sistema Linux) o altri. [3] L'utilizzo di #!/bin/sh, la shell Bourne predefinita nella maggior parte delle varie distribuzioni commerciali UNIX, rende lo script portabile su macchine non-Linux, sebbene questo significhi sacrificare alcune funzionalità specifiche di Bash. Lo script sarà, comunque, conforme allo standard POSIX [4] sh.

È importante notare che il percorso specificato dopo "#!" deve essere esatto, altrimenti un messaggio d'errore -- solitamente "Command not found" -- sarà l'unico risultato dell'esecuzione dello script.

#! può essere omesso se lo script è formato solamente da una serie di comandi specifici di sistema e non utilizza direttive interne della shell. Il secondo esempio ha richiesto #! perché la riga di assegnamento di variabile, linee=50, utilizza un costrutto specifico della shell. [5] È da notare ancora che #!/bin/sh invoca l'interprete di shell predefinito, che corrisponde a /bin/bash su una macchina Linux.

Questo manuale incoraggia l'approccio modulare nella realizzazione di uno script. Si annotino e si raccolgano come "ritagli" i frammenti di codice che potrebbero rivelarsi utili per degli script futuri. Addirittura si potrebbe costruire una libreria piuttosto ampia di routine. Come, ad esempio, la seguente parte introduttiva di uno script che verifica se lo stesso è stato eseguito con il numero corretto di parametri. E_ERR_ARG=65 parametri_dello_script="-a -h -m -z" # -a = all, -h = help, ecc. if [ $# -ne $Numero_di_argomenti_attesi ] then echo "Utilizzo: `basename $0` $parametri_dello_script" # `basename $0` è il nome dello script. exit $E_ERR_ARG fi Spesso scriverete uno script che svolge un compito specifico. Il primo script di questo capitolo ne rappresenta un esempio. Successivamente potrebbe sorgere la necessità di generalizzare quello script, in modo che possa svolgere altri compiti simili. Sostituire le costanti letterali ("codificate") con delle variabili rappresenta un passo in tale direzione, così come sostituire blocchi di codice che si ripetono con delle funzioni.