## page was renamed from LinguaggioBash
#format wiki 
#LANGUAGE it
<<BR>>
<<Indice(depth=1)>>
<<Informazioni(forum="http://forum.ubuntu-it.org/viewtopic.php?f=46&t=620802";)>>

= Introduzione =

'''Bash''' (acronimo per '''b'''ourne '''a'''gain '''sh'''ell) è una '''[[https://it.wikipedia.org/wiki/Shell_(informatica)|shell]]''' del progetto '''[[https://it.wikipedia.org/wiki/Progetto_GNU|GNU]]''' usata nei sistemi operativi '''[[https://it.wikipedia.org/wiki/Unix-like|Unix-like]]''' e specialmente in '''GNU/Linux'''.<<BR>>
Si tratta di un interprete di comandi che permette all'utente di comunicare col sistema operativo attraverso una serie di funzioni predefinite e di eseguire programmi. 

Tecnicamente '''bash''' è un clone evoluto della shell standard di Unix (`/bin/sh`), chiamata anche ''Bourne Shell'' da Stephen Bourne, nome del suo autore originario. Il nome esteso ''Bourne again shell'' («''un'altra shell Bourne''») contiene un gioco di parole in quanto la sua pronuncia in lingua inglese risulta simile a «''Born again shell''» («''shell rinata''»). 

In pratica '''Bash''' può essere considerata come un processore di macro. Alcune delle sue principali caratteristiche sono le seguenti:

 * Può essere eseguita sia tramite dei comandi digitati nel [[AmministrazioneSistema/Terminale|terminale]], sia tramite degli appositi [[Programmazione/Script|script]] (combinando così più comandi tra di loro, per svolgere compiti più complessi).
 * Possibilità, se necessario, di raccogliere in file una serie di comandi (in modo tale da creare script eseguibili contenenti variabili, funzioni e controlli di flusso, come nei più comuni linguaggi di programmazione).
 * Possibilità di ridirezione dell'input e dell'output (''redirect''), che consente di eseguire più programmi "a cascata", dove l'output di un comando può diventare l'input di un comando successivo.

'''Bash''' è qindi uno strumento ricco di funzionalità, che tuttavia potrebbero essere poco note agli utenti novizi. Per questo la guida si propone come una raccolta (non esaustiva) di consigli e "trucchi" relativi all'utilizzo dello scripting in '''Bash'''.

= Variabili =

Le variabili in ''bash scripting'' non hanno bisogno di inizializzazione. L'assegnazione avviene usando la forma:
{{{
VAR=valore
}}}
È molto importante che il valore sia scritto subito dopo l'uguale senza nessuno spazio.
I riferimenti a tutte le variabili si scrivono anteponendo il carattere '''$''' al nome della variabile:
{{{
VAR=world
echo hello $VAR!
}}}

= Variabili speciali =

 * '''$N''',  dove N è un numero intero, corrisponde all'argomento N-esimo passato da terminale al programma ($0 è il nome del programma).

 * '''$*''' stringa che contiene tutti gli argomenti passati da terminale al programma.

 * '''$#''' contiene il numero di argomenti passati da terminale al programma ($0 escluso).

 * '''$@''' Contiene la lista dei parametri passati allo script corrente. Ogni parametro viene opportunamente quotato e questo permette l'utilizzo di questa variabile nei cicli ''for'' per processare, ad esempio, una lista di nomi di file che possono contenere anche spazi. L'uso di questa variabile è quindi in genere consigliato rispetto a $* che ha la stessa funzione ma non quota i vari parametri. 

 * '''$? ''' Contiene il valore di uscita dell'ultimo comando o funzione. Il comando ha successo se ritorna zero, qualsiasi altro valore indica invece un codice di errore. 

 * '''$$''' contiene il PID del processo in esecuzione.

 * '''$!'''  contiene il PID dell'ultimo job in background.

= Esecuzione comandi =

Dato che non è un vero linguaggio di programmazione, molte funzionalità non sono incluse nel ''bash scripting'' ma sono comunque usabili tramite dei programmi esterni.

Per prima cosa è utile sapere che per leggere l'output di un programma e, per esempio, inserirlo in una variabile si usa la forma:
{{{
VAR=`uname -r`
echo `pwd`
}}}
oppure:
{{{
VAR=$(uname -r)
echo $(pwd)
}}}
Tramite i caratteri di back-quote ('''ALT GR + ' ''') o il carattere dollaro ('''Shift + 4''') l'interprete bash esegue il comando e sostituisce con l'output tutta la chiamata. In questo caso, al posto di ''{{{`uname -r`}}}'' o ''$(uname -r)'', è equivalente una scrittura del tipo:
{{{
VAR=5.13.0-28
echo /usr/src/linux
}}}

== Programmi utili ==

 * '''expr''': dato che non si possono eseguire semplici operazioni matematiche direttamente tramite l'interprete, tale comando può essere d'aiuto.

 * '''grep''': utile per mostrare solo alcune righe di un determinato output.

 * '''cut''': serve per "tagliare" una stringa in tante sotto-stringhe in base ad un determinato separatore. È molto simile allo !StringTokenizer in java.
 
 * '''cat''': data l'assenza di funzioni proprie dell'interprete per l'apertura e la lettura dei file, questo comando apre il file e stampa il suo contenuto. L'output stampato può essere reindirizzato in una variabile come spiegato sopra.

Per maggiori informazioni sui singoli comandi si rimanda ai manuali dei relativi programmi.

= Manipolazione delle stringhe =

Tradizionalmente, nelle shell '''Unix-like''', la manipolazione delle stringhe viene fatta attraverso programmi esterni alla '''shell''' come '''sed''', '''awk''' e '''perl'''.

Questi programmi vengono ancora usati quando si vuole mantenere la compatibilità con la '''shell sh'''. Tuttavia imparare anche il solo '''sed''' (il più semplice dei tre) non è cosa immediata.

Se si usa '''Bash''' non è necessario usare nessun programma esterno, ma basta imparare i tre operatori fondamentali e alcuni concetti di base per poter eseguire tutte le manipolazioni più comuni.

In '''Bash''' una stringa non è altro che una variabile. Dunque si indica con '''${nome}''' oppure con la forma abbreviata '''$nome'''. Il nome dentro le graffe può essere seguito da un modificatore che manipola la variabile, ad esempio:
{{{
 VAR="stringa-di-esempio"
 echo ${VAR#stringa-}
}}}
elimina "'''stringa-'''" dall'inizio della variabile.

I modificatori sono molti, ma possono essere facilmente ricordati se si imparano i tre fondamentali:

 * '''#''': sottrae dall'inizio della stringa (minimale).
 * '''%''': sottrae dalla fine della stringa (minimale). 
 *'''/ ''': sostituisce una sotto-stringa con un'altra (solo la prima volta che viene incontrata). 

Questi operatori sono minimali. Ciò vuol dire che se si usano le espressioni regolari per indicare la sotto-stringa (da eliminare o sostituire) verrà individuata in caso di ambiguità la sotto-stringa più piccola (o solo la prima nel caso della sostituzione).

Per ottenere gli operatori massimali basta raddoppiare il simbolo:
 * '''##''': sottrae dall'inizio della stringa (massimale).
 * '''%%''': sottrae dalla fine della stringa (massimale). 
 * '''//''': sostituisce una sotto-stringa con un altra (tutte le volte che viene incontrata).

Gli operatori massimali cercano di individuare la sotto-stringa più grande che corrisponde all'espressione regolare (nel caso del modificatore '''//''' tutte le sotto-stringhe vengono sostituite). Gli operatori di questo tipo vengono comunemente detti anche ''greedy'' («ingordi»).

Per ulteriori informazioni più dettagliate su tutti i modificatori e le altre modalità di manipolazione delle stringhe in '''Bash''' consultare [[http://www.tldp.org/LDP/abs/html/string-manipulation.html|questa guida]].

== Esempio:  Manipolazione delle stringhe ==
{{{
 VAR="questa.è.una.stringa.di.esempio"
 
                                    # Risultato:
 
 echo ${VAR#*.}      # --> è.una.stringa.di.esempio
 echo ${VAR##*.}     # --> esempio
 
 echo ${VAR%.*}      # --> questa.è.una.stringa.di
 echo ${VAR%%.*}     # --> questa
 
 echo ${VAR/st/ST}   # --> queSTa.è.una.stringa.di.esempio
 echo ${VAR//st/ST}  # --> queSTa.è.una.STringa.di.esempio
}}}

== Alternativa a basename ==

Quando in uno script occorre fare riferimento al nome dello script stesso, è usuale utilizzare il comando '''basename''' (esterno a Bash). Tuttavia, tramite i modificatori del paragrafo precedente, Bash stessa è in grado di fornire questa funzionalità. Basta usare l'espressione ${0##*/}.

Ad esempio:
{{{
usage () {
        echo "usage: ${0##*/} "
        exit 1
}
}}}

== Esempio:  cambiare l'estensione ai file ==
Rinomina tutti i file `*.txt` della directory corrente in `*.log`:{{{
for f in *.txt; do mv "$f" "${f/%txt/log}"; done
}}}

= Condizioni =
Le operazioni condizionali in '''bash''' possono essere eseguite in due modi: tramite il blocco '''if..then..else''' (simile al suo omonimo in linguaggio c), oppure tramite il blocco '''case..in''' (simile allo switch).

== If..Then..Else ==

Tutto il lavoro di questo blocco è svolto dal programma bash '''test'''. Il suo uso è:

{{{
test [espr]
}}}
ci sono molte espressioni possibili, di cui le più comuni sono:
 * '''-f nomefile''': ritorna vero se il file esiste.
 * '''-d directory''': ritorna vero se la directory esiste.
 * '''str1 = str2''': ritorna vero se la str1 è uguale alla str2.
 * '''str1 != str2''': ritorna vero se la str1 è diversa dalla str2.
 * '''arg1 -eq arg2''': confronto numerico, ritorna vero se arg1 è uguale a arg2.
 * '''arg1 -ne arg2''': confronto numerico, ritorna vero se arg1 è diverso a arg2.
 * '''arg1 -lt arg2''': confronto numerico, ritorna vero se arg1 è minore a arg2 ('''-le''' per maggiore o uguale).
 * '''arg1 -gt arg2''': confronto numerico, ritorna vero se arg1 è maggiore a arg2 ('''-ge''' per maggiore o uguale).
 * '''espr1 -o espr2''': concatena più condizioni, uguale all'or, ritorna vero o se l'espr1 o se l'espr2 ritorna vero.
 * '''espr1 -a espr2''': concatena più condizioni, uguale all'and, ritorna vero se sia l'espr1 che l'espr2 ritornano vero.

Questo è un esempio d'uso del costrutto if:

{{{
if [ -f prova.txt ]
 then
       echo Il file esiste!
  else
       echo Il file non esiste!
fi
}}}

Un'altra forma del costrutto ''if'':

{{{
if [ -f prova.txt ];then echo Il file esiste!;else echo Il file non esiste!;fi
}}}

Come si può notare, inserire tra parentesi quadre l'espressione da testare è equivalente a scrivere:
{{{
test -f prova.txt
}}}
L'if bash è molto rigoroso dal punto di vista sintattico. Dopo l'espressione da valutare è necessario andare o a capo e scrivere la parola chiave ''then'', oppure frapporre un ''';''' e scrivere di seguito la parola chiave.

Si noti inoltre che non c'è bisogno di parentesi graffe, infatti il blocco viene terminato con la parola chiave ''fi''.

== Case..in ==

L'uso del blocco ''case'' è molto semplice:

{{{
case $a in 
 1) echo sono un 1;;
 2) echo sono un 2;;
 3) echo sono un 3;;
 *) echo Non sono ne un 1 ne un 2 ne un 3;;
esac
}}}
viene valutata '''$a''' e in base al valore contenuto vengono eseguite le operazioni associate.<<BR>>
Si noti inoltre che non c'è bisogno di parentesi graffe, infatti il blocco viene terminato con la parola chiave ''esac''.

= Cicli enumerativi =

Al contrario di altri linguaggi, nel Bash Scripting i cicli sono del tipo enumerativo, cioè eseguono le operazioni per tutti gli elementi presenti un una lista indicata. Il più importante è sicuramente il ciclo ''for..do''.

== For..do ==

La sua forma è:
{{{
for [VAR] [in [LIST]]
 do
    [COMANDI]
done
}}}
il cui parametro dopo ''in'' rappresenta la lista prima citata.<<BR>>
Nel seguente esempio il ciclo stamperà sullo standard output ''1 2 3 4 5'':
{{{
for i in 1 2 3 4 5
 do
    echo sono $i
done
}}}

In questo altro esempio il ciclo stamperà una lista di file:
{{{
for i in *
 do
    echo Sono il file $i
done
}}}

= Ulteriori risorse =

 * [[https://www.gnu.org/software/bash/|Sito ufficiale del progetto]]
 * [[https://it.wikipedia.org/wiki/Bash|Pagina enciclopedica]]
 * [[http://www.gnu.org/software/bash/manual/bash.html|Manuale ufficiale di Bash]]
 * [[http://www.tldp.org/LDP/abs/html/|Guida avanzata di scripting Bash]]
 * [[http://www.pluto.it/files/ildp/guide/abs/index.html|Guida avanzata di scripting Bash in italiano]]

----
CategoryProgrammazione