|
|
(49 versioni intermedie di 2 utenti non mostrate) |
Riga 1: |
Riga 1: |
| {{Versioni_compatibili}} | | {{Versioni compatibili}} |
| ==Introduzione==
| | __TOC__ |
| Questa non può essere una guida completa, per la vastità dell'argomento, ma cercherà di far luce sui comportamenti più distintivi di Bash, partendo dai più facili da fraintendere.
| |
| | |
| Per l'uso interattivo si rimanda a [[Bash tips]].
| |
| | |
| == Variabili (stringhe) ==
| |
| In Bash ogni variabile di default è trattata come una stringa e, benché Bash supporti anche interi e array (indicizzati o associativi), questa sezione si limita al solo tipo base.
| |
| | |
| === Nomi di variabili ===
| |
| Un nome di variabile ammette soltanto caratteri alfabetici (maiuscoli e minuscoli), l'underscore ('_') e numeri (non in prima posizione). E il suo contenuto si accede con <code>${nome}</code> oppure con la forma abbreviata <code>$nome</code>.
| |
| | |
| La forma abbreviata assume che il nome della variabile sia composto da tutti i caratteri validi incontrati. Per esempio <code>"$nome$cognome"</code> (due variabili concatenate) è equivalente a <code>"${nome}${cognome}"</code>, ma <code>"$nome_$cognome"</code> non lo è a <code>"${nome}_${cognome}"</code> perché <code>nome_</code> (con underscore finale) sarebbe un nome valido. Con la concatenazione di variabili è preferibile accedere alle variabili con le graffe, o in alternativa delimitarle una a una dalle virgolette (<code>"$nome"_"$cognome"</code>).
| |
| | |
| === Assegnazioni ===
| |
| Non si deve usare il <code>'''$'''</code> davanti alla variabile a cui assegnare:
| |
| <pre>
| |
| var=stringa # assegno un valore (una stringa senza spazi e caratteri speciali)
| |
| var="stringa con spazi" # assegno una stringa con spazi (con caratteri speciali preceduti da '\')
| |
| var='stringa senza apici' # assegno una stringa contenente spazi e caratteri speciali (ma non apici)
| |
| var=$var2 # assegno un'altra variabile
| |
| var=${var2} # equivalente a sopra
| |
| var="$var2" # equivalente a sopra (non serve quotare nelle assegnazioni)
| |
| var='$var2' # si assegna letteralmente $var2 (e non il suo contenuto)
| |
| var="\$var2" # come sopra, perché $ è preceduto da \
| |
| var="${var1} testo ${var2}_${var3}" # assegno una concatenazione di variabili e stringhe
| |
| </pre>
| |
| | |
| I caratteri speciali (<code>"</code>, <code>`</code>, <code>$</code> e <code>\</code>) nelle stringhe quotate (tra virgolette) devono essere preceduti dal carattere di escape <code>\</code>, mentre quelle tra apici possono contenere tutti i caratteri ma non l'apice, come si vedrà più avanti.
| |
| | |
| === Espansione ===
| |
| Con l'unica eccezione dell'assegnazione, quando si accede al contenuto di una variabile senza quotarla, questa può essere trasformata in più di una singola stringa ('''esplosione''') in base agli spazi (e tabulazioni e "a capo") contenuti, e perfino in "niente" se è vuota. "Niente" proprio come se non presente nel codice.
| |
| | |
| Entrambi i comportamenti non sono intuitivi e costituiscono una comune sorgente di errori. Se si vuole sempre considerare il contenuto della variabile come una singola stringa, è necessario accederla quotata (tra virgolette), ossia con <code>"$variabile"</code> oppure <code>"${variabile}"</code>.
| |
| | |
| Si considerino per esempio i seguenti confronti (usati spesso con <code>if</code> o <code>while</code>):
| |
| <pre>
| |
| [ $var = $var2 ] # SBAGLIATO! (se una delle due è vuota)
| |
| [ "$var" = "$var2" ] # corretto
| |
| [ -n $var ] # SBAGLIATO (se var è vuota)
| |
| [ -n "$var" ] # corretto
| |
| </pre>
| |
| | |
| Ciò è ancora più importante quando si passa la variabile a un comando che agisce su un file indicato dalla variabile, il cui contenuto in presenza di spazi (comuni per i nomi di file degli utenti) potrebbe venir trattato come una lista di file.
| |
| | |
| Esempio di codice che crea un backup di un file indicato da una variabile, se il suo nome non termina già con estensione .bak. Si notino le virgolette attorno alla variabili, omesse solo nelle assegnazioni (senza spazi), per garantire che ogni variabile venga espansa in un solo argomento:
| |
| <pre>
| |
| if [ "$file" = "${file%.bak}" ]; then
| |
| oldfile=$file
| |
| file=${file}.bak
| |
| cp -- "$oldfile" "$file"
| |
| fi
| |
| </pre>
| |
| | |
| D'altra parte accedere una variabile senza quotarla permette di assegnare alla variabile tutte le opzioni da passare a un comando, se sono stringhe senza spazi e caratteri speciali, per poi accederle in una volta sola:
| |
| | |
| <pre>ARGUMENTS="--arg1 --arg2 ..."
| |
| ...
| |
| comando $ARGUMENTS
| |
| </pre>
| |
| | |
| Si noti che usando <code>"$ARGUMENTS"</code> (quotata) per una variabile contenente la stringa vuota, il comando leggerebbe lo stesso un argomento e potrebbe fallire.
| |
| | |
| ===Variabili speciali===
| |
| ; <code>$?</code> : contiene il valore di uscita dell'ultimo comando o funzione (0 solo in caso di successo);
| |
| | |
| ; <code>$0</code> : contiene il nome usato per lanciare lo script;
| |
| | |
| ; <code>$#</code> : contiene il numero di argomenti passati allo script (o a una funzione, all'interno di una funzione);
| |
| | |
| ; <code>$1, $2, ...</code>: contengono, se presenti, i parametri passati allo script (o a una funzione);
| |
| | |
| ; <code>$@</code> : contiene la lista di tutti i parametri passati allo script corrente o a una funzione. Ogni parametro viene opportunamente quotato, se questa variabile è quotata, e questo ne permette l'utilizzo 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 preferito rispetto a <code>'''$*'''</code> che ha la stessa funzione ma, se quotata, non quota i vari parametri ma l'intera stringa;
| |
| | |
| ''Esempio:''
| |
| <pre>
| |
| for file in "$@"; do
| |
| # Fare quello che si vuole con $file
| |
| echo "$file"
| |
| # ...
| |
| done
| |
| </pre>
| |
| | |
| ; <code>$$</code> : PID del processo corrente;
| |
| | |
| ; <code>$!</code> : PID dell'ultimo job in background.
| |
| | |
| ''Esempio:''
| |
| <pre>
| |
| comando & # lancio un comando in background
| |
| pid=$! # ottengo il PID del comando
| |
| ... # eseguo altre operazioni
| |
| wait $pid # attendo la terminazione del comando
| |
| status=$? # catturo il suo exit status
| |
| </pre>
| |
| | |
| == Manipolazione delle stringhe ==
| |
| Nelle shell *nix, storicamente, la manipolazione delle stringhe viene fatto attraverso programmi esterni alla shell come sed, awk e perl. Questi programmi vengono ancora usati quando si vuole mantenere la compatibilità con la shell <code>'''sh'''</code> (''POSIX''), 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 ed alcuni concetti di base, per poter fare tutte le manipolazioni più comuni direttamente sulle variabili.
| |
| | |
| Si assegna una stringa a una variabile e accedendola tramite la forma con le graffe, si può ricorrere a un modificatore che manipola la stringa (senza modificare il contenuto della variabile), ad esempio:
| |
| | |
| VAR="stringa-di-esempio"
| |
| echo "${VAR#stringa-}"
| |
| | |
| ritorna il contenuto della variable VAR senza il prefisso "stringa-". VAR non viene modificata, salvo una nuova assegnazione:
| |
| | |
| VAR=${VAR#stringa-}
| |
| | |
| ora il prefisso "stringa-" è stato eliminato anche dalla variabile VAR.
| |
| | |
| I modificatori sono molti, ma possono essere facilmente ricordati se si imparano i tre fondamentali:
| |
| | |
| ; <code>#</code> : sottrae dall'inizio della stringa ''(minimale)''
| |
| ; <code>%</code> : sottrae dalla fine della stringa ''(minimale)''
| |
| ; <code>/</code> : sostituisce una sottostringa con un'altra ''(solo la prima volta che viene incontrata)''
| |
| | |
| Questi operatori sono minimali, questo vuol dire che se si usano le espressioni regolari per indicare la sottostringa (da eliminare o sostituire) verrà individuata in caso di ambiguità la sottostringa più piccola (o solo la prima nel caso della sostituzione).
| |
| | |
| Per ottenere gli operatori massimali basta raddoppiare il simbolo:
| |
| | |
| ; <code>##</code> : sottrae dall'inizio della stringa ''(massimale)''
| |
| ; <code>%%</code> : sottrae dalla fine della stringa ''(massimale)''
| |
| ; <code>//</code> : sostituisce una sottostringa con un'altra ''(tutte le volte che viene incontrata)''
| |
| | |
| Gli operatori massimali cercano di individuare la sottostringa più grande che corrisponde all'espressione regolare (nel caso del modificatore '''//''' tutte le sottostringhe vengono sostituite).
| |
| | |
| Per una spiegazione dettagliata di tutti i modificatori e anche di altri modi di manipolare le stringhe in Bash (ad esempio <code>expr</code>) vedere:
| |
| | |
| * [http://www.tldp.org/LDP/abs/html/string-manipulation.html Advanced Bash-Scripting Guide: Manipulating Strings]
| |
| | |
| === Esempi: manipolazione delle stringhe ===
| |
| <pre>
| |
| VAR="questa.sarebbe.una.stringa.di.esempio"
| |
|
| |
| # Risultato:
| |
|
| |
| echo "${VAR#*.}" # --> sarebbe.una.stringa.di.esempio
| |
| echo "${VAR##*.}" # --> esempio
| |
|
| |
| echo "${VAR%.*}" # --> questa.sarebbe.una.stringa.di
| |
| echo "${VAR%%.*}" # --> questa
| |
|
| |
| echo "${VAR/st/ST}" # --> queSTa.sarebbe.una.stringa.di.esempio
| |
| echo "${VAR//st/ST}" # --> queSTa.sarebbe.una.STringa.di.esempio
| |
| </pre>
| |
| | |
| ===Esempio: alternativa a basename===
| |
| Quando in uno script ci si deve riferire al nome dello script stesso, è usuale utilizzare il comando esterno <code>'''basename'''</code>. Tuttavia, tramite i modificatori del paragrafo precedente, Bash stessa è in grado di fornire questa funzionalità con l'espressione <code>${0##*/}</code>:
| |
| <pre>
| |
| readonly BASENAME=${0##*/} # associa il basename a una costante
| |
| | |
| usage () {
| |
| echo "Usage: ${BASENAME}"
| |
| }
| |
| </pre>
| |
| | |
| ==Caratteri di escape, apici e virgolette==
| |
| Alcuni caratteri hanno un valore speciale per la shell, per consentirne le espansioni (di variabile, parametro, comando, percorso, ecc...). Di conseguenza se si intende scrivere un carattere speciale senza espanderlo, è necessario comunicarlo alla shell facendolo precedere da un carattere di escape '<code>\</code>' oppure racchiudendolo tra apici o virgolette (a seconda dell'espansione da disattivare).
| |
| | |
| Una stringa non racchiusa tra apici o tra virgolette ha i seguenti caratteri speciali: <code>'</code>, <code>"</code>, <code>`</code>, <code>$</code>, <code>\</code>, <code>{</code>, <code>}</code>, <code>[</code>, <code>]</code>, <code>*</code>, <code>?</code>, <code>~</code> e <code>#</code>. Se non preceduti dal carattere di escape <code>\</code> possono in base ai caratteri immediatamente successivi essere espansi, o tralasciati come commenti nel caso di <code>#</code>. Questa sezione non è esaustiva e non considera tutte le eccezioni, ma consiglia degli accorgimenti che si possono sempre seguire per ridurre la necessità dell'escape.
| |
| | |
| Inoltre gli spazi (comprendendo tabulazioni e a capo) non quotati (con apici o virgolette) e non preceduti dal carattere di escape <code>\</code> vengono compressi:
| |
| <pre>
| |
| echo parola1 parola2 # stampa parola1 parola2 con un singolo spazio
| |
| echo "parola1 parola2" # stampa mantenendo gli spazi tra le due parole
| |
| # con una variabile
| |
| var="parola1 parola2" # assegno la stringa alla variabile
| |
| echo $var # la stampo con un singolo spazio tra le parole
| |
| echo "$var" # la stampo così com'è scritta
| |
| </pre>
| |
| | |
| Il carattere di escape <code>\</code> prima di un "a capo", anche se quotato (tra virgolette), ha un significato speciale che consente di scrivere un comando su più righe, trattando ogni riga preceduta da <code>\</code> come una continuazione della precedente:
| |
| <pre>
| |
| # stampa tutto su una riga
| |
| echo "testo su \
| |
| più \
| |
| righe"
| |
| | |
| # stampa su più righe
| |
| echo "testo su
| |
| più
| |
| righe"
| |
| </pre>
| |
| | |
| ===Espansione dei caratteri di escape===
| |
| Sintassi: <code>$'stringa'</code>
| |
| | |
| Se l'espansione non è quotata o preceduta da escape, e la stringa non è una variabile, ne espande i caratteri di escape (utilizzabili anche con ''printf'' ed ''echo -e''):
| |
| * '''\n''', nuova riga;
| |
| * '''\b''', backspace (cancella un carattere);
| |
| * '''\r''', carriage return (ritorna a inizio riga);
| |
| * '''\t''', tabulazione;
| |
| * '''\nnn''', carattere ASCII in base 8;
| |
| * ecc...
| |
| | |
| ===Racchiudere tra apici===
| |
| Con gli apici (apostrofi) si riducono i caratteri speciali a uno soltanto, lo stesso apice, rappresentando la stringa per il suo solo valore letterale e impedendo tutte le espansioni:
| |
| <pre>echo '$PATH "" \ `ls ..` \$HOME ~ * .[a-z]*' # stampa la stringa tra apici, così com'è scritta</pre>
| |
| | |
| Lo svantaggio è che non esiste un carattere di escape:
| |
| <pre>echo 'L'\''albero di... ' # stampa "L'albero di..." (l'accento non può essere racchiuso tra apici e va preceduto da \)</pre>
| |
| | |
| ===Quotare (tra virgolette)===
| |
| Racchiudere tra virgolette ogni stringa è raccomandabile, anche se non sempre necessario, così da ridurre drasticamente il numero di caratteri speciali a cui pensare, permettendo allo stesso tempo l'espansione sicura delle variabili e dei comandi. I soli caratteri speciali rimasti sono <code>$</code>, <code>`</code> (ma non l'apice), <code>"</code> e <code>\</code>, che devono essere preceduti dal carattere di escape <code>\</code>. Le sole espansioni permesse all'interno di una stringa quotata sono di variabile e parametro (attraverso <code>$</code>) e quelle di comando (attraverso <code>$(...)</code> o <code>`...`</code>).
| |
| | |
| Per esempio:
| |
| <pre>
| |
| echo "$PATH" # espande la variabile PATH e ne stampa il contenuto
| |
| echo "\$HOME" # stampa letteralmente $HOME, senza espanderla (è equivalente a '$HOME')
| |
| echo "\"\" \\" # è equivalente a '"" \'
| |
| echo "$(ls ..)" # Esegue il comando "ls .." e ne stampa l'output
| |
| echo "~ * .[a-z]*" # non effettua le espansioni di tilda e percorso, ma stampa letteralmente.
| |
| echo "{a,b} $'\n'" # stampa letteralmente, senza espansioni
| |
| </pre>
| |
| | |
| ==Espansione di comando==
| |
| Consiste nel trasformare l'output di un comando qualsiasi (interno della shell, esterno, una funzione e anche forme composte) in argomenti per un altro comando, oppure nel valore da assegnare a una variabile. Si effettua racchiudendo un comando tra <code>$(...)</code>, oppure tra due apici gravi <code>`...`</code> (su tastiera con layout italiano: <code>Alt Gr + '</code>):
| |
| <pre>$(comando)</pre>
| |
| oppure, meno leggibile e sconsigliata:
| |
| <pre>`comando`</pre>
| |
| | |
| L'output del comando consiste in zero, una o più stringhe, in base agli spazi presenti nell'output prodotto e in maniera analoga all'espansione a cui sono soggette le variabili. Per trasformare l'output di un comando in una singola stringa è necessario che l'espansione di comando sia quotata, con l'eccezione dell'assegnazione a una variabile.
| |
| | |
| Esempi di assegnazione:
| |
| <pre>
| |
| # assegna alla variabile $oggi la data in formato YYYY_MM_DD
| |
| oggi=$(date +%F) # senza virgolette
| |
| oggi="$(date +%F)" # equivalente a sopra (non servono nelle assegnazioni)
| |
| | |
| # associo a testo il contenuto del file indicato da $file
| |
| testo=$(cat $file) # SBAGLIATO! (se la variabile $file contiene spazi o caratteri speciali)
| |
| testo=$(cat "$file") # le virgolette attorno alla variabile sono necessarie
| |
| testo="$(cat "$file")" # equivalente a sopra
| |
| </pre>
| |
| | |
| Esecuzione dei comandi e passaggio come argomento del loro output:
| |
| <pre>
| |
| # stampa stati
| |
| echo "Login name: $(logname); Name: $(whoami); UID: $(id -ur); EUID: $(id -u); Groups: $(groups)"
| |
| echo "OS: Debian GNU/Linux $(cat /etc/debian_version) ($(lsb_release -sc))" # uguale a $(lsb_release -sd)
| |
| echo "Kernel: $(uname) $(uname -r) ($(uname -v))"
| |
| </pre>
| |
| | |
| ===Output con a capo finali===
| |
| Si noti che l'espansione di comando, come anche in '''sh''' (''POSIX''), non espande il comando a tutto l'output prodotto, ma omette sempre gli "a capo" finali. Se da una parte è utile nella maggior parte delle situazioni, può talvolta avere effetti collaterali difficili da prevedere. Si consideri per esempio:
| |
| <pre>
| |
| echo ciao > file_prova # scrive ciao e un "a capo" nel file_prova
| |
| testo=$(cat file_prova) # associa il contenuto (SENZA "a capo") a $testo
| |
| echo "Bytes: ${#testo}" # NON è la dimensione esatta del file!
| |
| echo "$testo" # stampa il contenuto di $testo (PIÙ un "a capo")
| |
| echo "$testo" | # invia la stringa a cmp per un confronto
| |
| cmp - file_prova # nessun errore!!!
| |
| echo $? # infatti stampa 0
| |
| </pre>
| |
| | |
| {{Warningbox | Una variabile non può contenere il carattere ASCII numero 0, quindi per i file binari è sempre sbagliato accederli in questo modo. È sconsigliabile anche se non si è certi della loro dimensione, e se si è interessati soltanto alla prima riga si può utilizzare:
| |
| | |
| <code>read riga < file_prova</code>}}
| |
| | |
| Un altro esempio, vogliamo associare il carattere "a capo" a una variabile:
| |
| <pre>
| |
| nr="
| |
| " # funziona, ma occupa più righe e rompe l'indentazione
| |
| nr=$'\n' # funziona (con Bash) ed è il modo consigliato
| |
| | |
| # a titolo esemplicativo per l'espansione di comando
| |
| nr=$(echo) # SBAGLIATO, $nr è vuota
| |
| nr="$(echo)" # SBAGLIATO, come sopra
| |
| nr=$(printf "\n") # SBAGLIATO, $nr è sempre vuota
| |
| # una possibile soluzione...
| |
| nr=$(printf "\nX") # $nr contiene "a capo" seguito da X
| |
| nr=${nr%X} # $nr contiene "a capo" (la X è rimossa)
| |
| # Attenzione che il carattere aggiunto dev'essere nell'output del comando
| |
| nr=$(printf "\n")X # SBAGLIATO, $nr contiene solo X
| |
| </pre>
| |
| | |
| ==Espansione di tilda==
| |
| Sintassi:
| |
| * <code>~</code> (tilda) si espande alla home;
| |
| * <code>~utente</code> si espande alla home di un dato utente, se esiste, ma la stringa non può essere quotata né essere una variabile.
| |
| | |
| Esempi:
| |
| <pre>
| |
| var=~ # assegno ~ alla variabile
| |
| echo "$var" # stampa letteralmente ~
| |
| echo $var # equivalente a sopra, nessuna espansione
| |
| var=$(echo ~) # assegno a var la home dell'utente
| |
| var=$HOME # equivalente
| |
| var=$(echo ~root) # assegno a var la home di root
| |
| echo ~ # stampo la home dell'utente
| |
| echo "~" # stampo ~
| |
| echo ~root # stampo la home di root
| |
| echo ~fdsfd # stampo ~fdsfd (l'utente fdsfd non esiste)
| |
| </pre>
| |
| | |
| ==Espansione di percorso==
| |
| {{Box | File | Su UNIX e Unix-like per file si può intendere sia un file regolare, ma anche una directory, un link simbolico, una pipe, un socket, un device, ecc...}}
| |
| | |
| Non racchiudere tra virgolette e apici permette le espansioni di percorso. È sempre consigliabile racchiudere tutto il resto tra virgolette, per non permettere espansioni accidentali.
| |
| | |
| Infatti si noti che l'espansione, contrariamente a quella di tilda, può avvenire anche in base al contenuto di una variabile, se non è quotata:
| |
| <pre>
| |
| var=* # assegno * a $var
| |
| var="*" # come sopra
| |
| echo "$var" # stampa letteralmente *
| |
| echo $var # stampa la lista di tutti i file non nascosti
| |
| # nella directory corrente, oppure * se è vuota
| |
| </pre>
| |
| | |
| Sintassi (prefisso e suffisso possono essere omessi, o essere variabili da espandere):
| |
| * <code>prefisso'''?'''suffisso</code> sostituisce un singolo carattere di un file, con tutti quelli possibili che combaciano con le due stringhe date;
| |
| * <code>prefisso'''*'''suffisso</code> può sostituire tutti i caratteri di un file (di default tranne quelli nascosti se manca il prefisso, ossia inizianti con '''.''').
| |
| | |
| Esempi (nella directory corrente):
| |
| * <code>file.???</code> si espande a tutti i file con nome "file" e con una qualsiasi estensione di tre caratteri;
| |
| * <code>*</code> da solo espande a tutti i file non nascosti nella directory corrente. È sempre buona norma far precedere l'asterisco da un ./, che indica la cartella corrente, se non c'è un prefisso, per impedire espansioni di file inizianti con "-", che potrebbero essere visti come opzioni da alcuni comandi;
| |
| * <code>./*</code> equivalente a <code>*</code> ma più sicuro; di seguito si userà per tutte le espansioni inizianti con <code>*</code>;
| |
| * <code>"$nome"*</code>espande a tutti i file inizianti con $nome (può essere anche un percorso);
| |
| * <code>./*.txt</code> espande a tutti i file con estensione .txt;
| |
| * <code>./*."${estensione}"</code> espande dopo aver espanso la variabile (contrariamente a ~), che può anche essere quotata;
| |
| * <code>./*/</code> espande a tutte le directory non nascoste;
| |
| * <code>./.*</code> espande a tutti i file nascosti ('''ma anche a . e ..''').
| |
| | |
| È importante sapere che, se nessun file combacia con un dato pattern, allora l'espansione '''non''' viene effettuata e i caratteri mantengono il loro valore letterale. Inoltre <code>*</code> e <code>?</code> sono caratteri validi per un nome di file, e un confronto sull'espansione ottenuta non sarebbe sempre risolutivo.
| |
| | |
| L'esistenza di file ottenuti da tali espansioni va pertanto sempre controllata, per esempio con il costrutto <code>[ -e "$file" ]</code>:
| |
| | |
| <pre>for file in ./*; do
| |
| if [ -e "$file" ]; then
| |
| ...
| |
| fi
| |
| done</pre>
| |
| | |
| ===Esempio: cambiare l'estensione ai file ===
| |
| Rinomina tutti i file <code>*.txt</code> della directory corrente in <code>*.log</code>:
| |
| | |
| <pre>
| |
| for f in ./*.txt; do
| |
| if [ -e "$f" ]; then
| |
| mv -- "$f" "${f%txt}log"
| |
| fi
| |
| done
| |
| </pre>
| |
| | |
| {{Suggerimento | L'opzione "--" dopo il comando esterno <code>mv</code> serve per comunicargli che le stringhe che seguono non sono opzioni, nemmeno se iniziassero con il carattere "-". È sempre buona norma utilizzarla come controllo aggiuntivo con comandi che accettano file come argomenti, il cui nome non è noto a priori, in particolare per comandi che manipolano i file come: <code>rm</code>, <code>cp</code>, <code>mv</code>, ecc... <br/>
| |
| L'opzione deve essere supportata dal comando esterno, non è trattata specialmente dalla shell.}}
| |
| | |
| ==Espansione di parentesi (graffa)==
| |
| Se i caratteri <code>{</code> e <code>}</code> non sono quotati, e non sono preceduti dal carattere di escape <code>\</code>, possono essere espansi con due diverse sintassi.
| |
| | |
| ===Con indici di intervallo===
| |
| Sintassi: <code>prefisso{x..y[..z]}suffisso</code>
| |
| | |
| L'espansione avviene per tutte le stringhe nell'intervallo compreso da "prefisso'''x'''suffisso" fino a "prefisso'''y'''suffisso", con incrementi di 1 (o '''z''' se specificato). Le stringhe prefisso e suffisso possono essere omesse, o essere variabili (anche quotate, purché le graffe non lo siano), mentre x e y (e z, se presente) devono essere determinati valori e non possono essere variabili:
| |
| * <code>{x..y}</code> dove x e y sono due interi;
| |
| * <code>{x..y..z}</code> dove x, y e z sono tre interi;
| |
| * <code>{a..b}</code> dove a e b sono due caratteri;
| |
| * <code>{a..b..z}</code> dove a e b sono due caratteri, e z è un intero.
| |
| | |
| Per esempio:
| |
| <pre>
| |
| # crea un file temporaneo, associa il percorso a $tmp_file
| |
| tmp_file=$(tempfile)
| |
| # crea altri dieci file temporanei (.0, .1, .., .9) con lo stesso nome
| |
| touch -- "$tmp_file".{0..9}
| |
| </pre>
| |
| | |
| ===Con lista di stringhe===
| |
| Sintassi: <code>prefisso{stringa1,stringa2,...}suffisso</code>
| |
| | |
| L'espansione avviene per tutte le stringhe nella lista, racchiudendole tra il prefisso e il suffisso dati, se presenti. Il prefisso, il suffisso e tutte le stringhe possono essere variabili, anche quotate, purché non siano quotate le graffe e le virgole interne.
| |
| | |
| Questa espansione è effettuata prima di tutte le altre, e il risultato dell'espansione se non quotato può quindi subire ulteriori espansioni. Per esempio per effettuare un'operazione sui file nella cartella corrente che hanno una data estensione, si può scrivere:
| |
| <pre>
| |
| for file in ./*.{odt,abw,txt,rtf,doc}; do
| |
| if [ -e "$file" ]; then
| |
| ...
| |
| fi
| |
| done
| |
| </pre>
| |
| e la prima riga è equivalente a:
| |
| <pre>
| |
| for file in ./*.odt ./*.abw ./*.txt ./*.rtf ./*.doc; do
| |
| </pre>
| |
| | |
| ==Concatenazione e redirezione==
| |
| ; <code>&&</code> : operatore logico AND, il secondo comando verrà eseguito solo se il primo avrà esito positivo
| |
| ; <code>;</code> : separatore di comandi, il secondo comando verrà eseguito in ogni caso (in uno script è equivalente a un "a capo" e questa è la concatenazione di default)
| |
| | |
| $ cd ... && echo done
| |
| $ cd ... ; echo done
| |
| | |
| Nel caso specifico di un'applicazione che resta in esecuzione il secondo comando non verrà eseguito finché il
| |
| primo non sarà terminato, in questo caso si usa <code>'''&'''</code> e saranno eseguiti entrambi in quanto il primo comando viene mandato in background; prendiamo xterm come esempio:
| |
| | |
| $ xterm && xterm -rv
| |
| $ xterm ; xterm -rv
| |
| $ xterm & xterm -rv
| |
| | |
| ; <code>|</code> : pipe, passa l'output del comando che la precede come input del comando che la segue
| |
| | |
| $ ls -A1 | less
| |
| | |
| ; <code>||</code> : operatore logico OR, restituisce esito positivo se almeno una delle condizioni di verifica valutate è vera
| |
| | |
| <pre>
| |
| $ if [ -f ~/.bashrc ] || [ -d ~/.config ]; then echo 'w00t!'; else echo 'no such file or directory'; fi
| |
| | |
| $ if [ -f ~/.bashrc ] || [ -d ~/.configs ]; then echo 'w00t!'; else echo 'no such file or directory'; fi
| |
| | |
| $ if [ -f ~/.bash ] || [ -d ~/.configs ]; then echo 'w00t!'; else echo 'no such file or directory'; fi
| |
| </pre>
| |
| | |
| * [http://www.tldp.org/LDP/abs/html/special-chars.html Advanced Bash-Scripting Guide: Special Characters]
| |
| | |
| Dirige output di comando su file:
| |
| $ man xterm > xterm.txt
| |
| Dirige output di errore su file:
| |
| $ xterm 2> xterm-errors.log
| |
| Entrambi su file diversi:
| |
| $ xterm > xterm_out.log 2> xterm_err.log
| |
| Entrambi sullo stesso file:
| |
| $ xterm &> xterm.log
| |
| Entrambi sullo stesso file, alternativa:
| |
| $ xterm > xterm.log 2>&1
| |
| Appende nuovo testo a quello già presente in un file:
| |
| $ man uxterm >> xterm.txt
| |
| Cancella contenuto di un file:
| |
| $ :> xterm.txt
| |
| | |
| ===Catturare l'exit status===
| |
| Per catturare lo stato d'uscita di un comando appena eseguito è sufficiente espandere la variabile speciale <code>$?</code>, come già visto. Tuttavia in caso di fallimento del comando, il controllo effettuato via <code>$?</code> avverrebbe soltanto '''dopo''' un blocco con errore (si veda la parte sul debug).
| |
| | |
| Per evitare che un blocco abbia un exit status diverso da zero, si possono usare le concatenazioni (oppure un <code>if</code>):
| |
| <pre>
| |
| comando &&
| |
| status=0 || # se corretto
| |
| status=$? # se sbagliato
| |
| </pre>
| |
| | |
| I comandi precedenti costituiscono un unico blocco, sempre corretto, mentre invece:
| |
| <pre>
| |
| comando # questo comando è anche un blocco
| |
| status=$?
| |
| comando; status=$? # sono sempre due blocchi distinti</pre>
| |
| | |
| ===Output dei comandi e carattere ASCII n. 0===
| |
| Una variabile non può contenere il carattere ASCII n. 0, che è usato per indicare la fine della stringa. Non potendo gestire direttamente il carattere ASCII n. 0, questo non può essere presente nell'espansione di un comando, ma dev'essere lasciato a comandi esterni mediante l'uso di una o più pipe.
| |
| | |
| Infatti non esiste un modo di contenere il carattere ASCII n. 0 in nessuna posizione:
| |
| <pre>
| |
| var=$(printf '\000') # SBAGLIATO: $var è vuota
| |
| var=$(printf '\000X') # SBAGLIATO: $var contiene solo X
| |
| var=$(printf 'X\000X') # SBAGLIATO: $var contiene XX
| |
| var="$(printf 'X\000X')" # SBAGLIATO: equivalente a sopra
| |
| var=$'\000' # SBAGLIATO anche così!
| |
| </pre>
| |
| | |
| L'utilità di questo carattere si deve in particolare al fatto che nemmeno i file possono averlo nel proprio nome, mentre invece permettono caratteri jolly (*, ?, ...) come abbiamo già visto con le espansioni di percorso, e potrebbero contenere perfino il carattere "a capo".
| |
| | |
| L'espansione di percorso funziona normalmente, anche in presenza di "a capo", ma potrebbero sorgere problemi sfruttando l'espansione di comando. Per esempio con il comando esterno <code>find</code>, utilizzato per effettuare ricerche in modo ricorsivo, e che di default restituisce tutti i file trovati che soddisfano determinate condizioni stampandoli uno per riga, assumendo implicitamente che non contengano il carattere "a capo".
| |
| | |
| Uno script a titolo esemplificativo:
| |
| <pre>
| |
| # creo una directory e un file con "a capo" nel nome
| |
| mkdir ./prova
| |
| touch ./prova/"file contenente"$'\n'"a capo nel nome"
| |
| | |
| # SBAGLIATO! (per via del nome del file particolare)
| |
| num_file=$(find ./prova -type f | # stampo i file regolari nella directory, uno per riga
| |
| wc -l) # conto il numero di righe
| |
| | |
| echo "La directory prova contiene ${num_file} file" # restituisce 2 invece di 1
| |
| | |
| # forma corretta
| |
| num_file=$(find ./prova -type f -print0 | # stampo il carattere ASCII n. 0 dopo ogni file
| |
| tr -dc '\000' | # rimuovo tutti i caratteri ASCII diversi dal n. 0
| |
| wc -c) # conto il numero di caratteri
| |
| | |
| echo "La directory prova contiene ${num_file} file" # restituisce 1
| |
| | |
| # pulizia
| |
| rm -- ./prova/file*nome # elimino il file
| |
| rmdir -- ./prova # elimino la directory (se vuota)
| |
| </pre>
| |
| | |
| Un abbinamento comune al comando esterno GNU <code>find</code> (dotato dell'opzione -print0) è il comando esterno GNU <code>xargs</code> (dotato dell'opzione -0):
| |
| <pre>
| |
| find /percorso -opzione1 ... -opzioneN -print0 | # trova file che soddisfano le condizioni date
| |
| xargs -0 comando [ argomenti ... ] # li passa come argomenti a un comando esterno
| |
| </pre>
| |
| Si leggano i rispettivi manuali per maggiori informazioni. <code>find</code> ha inoltre la possibilità di eseguire altri comandi esterni sui file trovati direttamente con le opzioni -exec ed -execdir, ma la sintassi è più complessa e non supporta più di un processo per volta, come invece <code>xargs</code>.
| |
| | |
| == Debug integrato ==
| |
| '''Bash''', proprio come '''dash''', ha delle opzioni che ne consentono il debug.
| |
| | |
| Invocando uno script con <code>-n</code> è possibile effettuare un primitivo controllo di sintassi. Non vengono controllati comandi inesistenti e nemmeno le espansioni, ma può essere utile per verificare che i blocchi sono stati chiusi correttamente prima di eseguire lo script:
| |
| $ bash -n script.sh
| |
| | |
| Altre opzioni utili, che possono essere impiegate anche congiuntamente durante l'esecuzione:
| |
| * <code>-x</code> stampa ogni comando prima di eseguirlo;
| |
| * <code>-v</code> stampa l'intero blocco di codice che è stato letto (solo la prima volta);
| |
| * <code>-u</code> interrompe l'esecuzione dello script se si accede a una variabile che non è mai stata assegnata;
| |
| * <code>-e</code> interrompe lo script in caso un blocco ritorni un errore (se il valore di ritorno di un comando non è controllato da un <code>if</code>, <code>while</code>, <code>until</code> o dalla concatenazione di comandi con <code>||</code>).
| |
| Le opzioni possono essere anche accorpate:
| |
| $ bash -euvx script.sh
| |
| | |
| ==Link==
| |
| Link ad altre risorse su '''GNU Bash''':
| |
|
| |
|
| | La guida sullo scripting in '''bash''' si divide nei seguenti capitoli: |
| | ==[[Bash scripting - introduzione | Introduzione]]== |
| | : spiega lo scopo della guida, la storia della shell, come creare uno script e introduce le opzioni di debug integrate; |
| | ==[[Bash scripting - comandi essenziali | Comandi essenziali]]== |
| | : tratta i comandi di output (<code>printf</code>) e condizionali (<code>if [ ... ]</code>), la cui comprensione è necessaria per il resto della guida; |
| | ==[[Bash scripting - variabili - stringhe | Variabili (stringhe)]]== |
| | : nomi permessi, assegnazioni (anche con <code>read</code> e <code>for</code>), modificatori ed espansione di variabile; |
| | ==[[Bash scripting - caratteri di escape | Caratteri di escape, apici e virgolette]]== |
| | : come quotare le stringhe, per permettere espansioni e caratteri di escape; |
| | ==[[Bash scripting - espansioni quotabili | Espansioni in stringhe quotate]]== |
| | : espansioni di parametro, di comando e aritmetiche; |
| | ==[[Bash scripting - espansioni non quotabili | Espansioni non quotabili]]== |
| | : di tilde, di percorso e di parentesi; |
| | ==[[Bash scripting - istruzioni composte | Istruzioni composte]]== |
| | : cicli, pipe, concatenazioni, condizioni avanzate e blocchi di istruzioni; |
| | ==[[Bash scripting - funzioni | Funzioni]]== |
| | : definizione di funzione e come restituire un valore; |
| | ==[[Bash scripting - file descriptor | File descriptor e redirezioni]]== |
| | : operazioni di input/output su file, con uso (anche implicito) dei file descriptor standard e creazione di nuovi file descriptor; |
| | ==[[Bash scripting - segnali | Segnali]]== |
| | : invio e gestione dei segnali. |
| | <hr/> |
| | '''Link esterni:''' |
| * [http://www.gnu.org/software/bash/manual/bash.html Bash Referece Manual]: manuale ufficiale | | * [http://www.gnu.org/software/bash/manual/bash.html Bash Referece Manual]: manuale ufficiale |
| * [http://www.tldp.org/LDP/abs/html/ Advanced Bash-Scripting Guide]: la '''Bibbia''' dello bash scripting. | | * [http://www.tldp.org/LDP/abs/html/ Advanced Bash-Scripting Guide]: guida avanzata |
| | * [http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html Shell Command Language]: riferimento ''POSIX'' |
|
| |
|
| {{Autori | | {{Autori |
| |Autore=[[Utente:TheNoise|~ The_Noise]] (versione in Bash tips) | | |Autore = [[Utente:HAL 9000|HAL 9000]] 13:15, 18 dic 2015 (CET) |
| |Verificata_da=
| | |Estesa_da = |
| :[[Utente:S3v|S3v]] (versione in Bash tips)
| | |Verificata_da = |
| :[[Utente:HAL 9000|HAL 9000]] 16:24, 6 lug 2014 (CEST)
| | |Numero_revisori = 0 |
| |Estesa_da= | |
| :[[Utente:S3v|S3v]] (versione in Bash tips)
| |
| :[[Utente:HAL 9000|HAL 9000]]
| |
| |Numero_revisori=2 | |
| }} | | }} |
|
| |
|
| [[Categoria:Bash]][[Categoria:Bash_Scripting]] | | [[Categoria:Bash]][[Categoria:Bash Scripting]] |