|
|
| Riga 1: |
Riga 1: |
| {{Versioni_compatibili}} | | {{Da_cancellare}} |
| =Introduzione=
| | La guida è stata spostata al seguente link: |
| Questa non è una guida completa, per la vastità dell'argomento trattato. In particolare non sono trattati alcuni comandi importanti, alcuni introdotti proprio da questa shell:
| |
| * di condizione ed esecuzione condizionata avanzata (<code>[[</code>, <code>((</code>, <code>case</code>);
| |
| * per effettuare il parsing degli argomenti (<code>getopts</code>);
| |
| * di redirezione here-document e di processo;
| |
| * modificatore declare (per interi, array e array associativi);
| |
| * ecc...
| |
|
| |
|
| Lo scopo della guida è invece, partendo dai concetti più basilari, di evidenziare i comportamenti più distintivi e facili da sbagliare di '''bash''', con enfasi particolare sulle espansioni di stringhe, estremamente diverse da altri linguaggi di programmazione. Così da passare poi a guide più avanzate. Si cercherà anche di presentare le istruzioni in una sintassi il più possibile compatibile con la shell '''sh'''.
| | [[Bash scripting - introduzione | Bash scripting]] - introduzione della nuova guida, divisa in più pagine con sommario verticale |
| | |
| Quando si fa riferimento a comandi esterni, per conoscere la loro sintassi si può consultare il manuale (<code>man nome-comando-esterno</code>). La principale utilità dello scripting con la shell è proprio la semplicità di ampliarne le funzionalità richiamando altri eseguibili, quindi è consigliata anche la conoscenza dei principali (in particolare sulla [[Guida_ai_comandi_da_terminale_-_Gestione_di_file_e_directory | gestione di file e directory]]).
| |
| | |
| Per l'uso interattivo della shell si rimanda invece a [[Bash tips]]. Si noti che l'espansione della history, che qui non è trattata, è attiva soltanto in modalità interattiva mediante i caratteri speciali <code>!</code> e <code>^</code>, che di default non hanno invece nessun significato particolare all'interno di uno script.
| |
| | |
| ==Breve storia della shell==
| |
| GNU '''bash''' (''Bourne-Again SHell'') è una delle shell derivate da '''sh''' (la ''Bourne shell'', progettata da Stephen Bourne), la prima progettata per lo scripting. Bash è la scelta di default per l'uso interattivo su Debian e molte distribuzioni GNU/Linux, il che la rende una delle più diffuse, e incorpora molte nuove funzionalità rispetto a '''sh''', alcune derivanti da altre shell ('''csh''' e '''ksh''') e altre presenti soltanto in '''bash'''.
| |
| | |
| Quando si scrivono script con questa shell bisogna sapere che le nuove funzionalità comportano un costo, in termini di portabilità, rispetto agli script che si limitano alla sola sintassi prevista da ''POSIX'', lo standard che specifica come scrivere applicazioni funzionanti su tutti i sistemi UNIX e che per la shell prescrive le sole istruzioni supportate da '''sh'''. Infatti uno script scritto per '''sh''' secondo lo standard ''POSIX'' sarà supportato anche da altri sistemi operativi della famiglia UNIX e Unix-like che non hanno '''bash''' installato di default, come per esempio quelli della famiglia *BSD, a patto che anche i comandi esterni e le loro opzioni siano scelte secondo lo standard.
| |
| | |
| Inizialmente '''bash''' era usata anche per gli script di sistema (con <code>/bin/sh</code> che puntava a <code>/bin/bash</code>), ma per questa funzione è stata rimpiazzata da '''dash''' (''Debian Almquist Shell''): più veloce, con meno dipendenze di librerie e aderente molto più strettamente a ''POSIX''.
| |
| | |
| Per quanto possibile in questa guida, in presenza di sintassi alternative, si tenderà a prediligere quella presente in ''POSIX'' e si segnalerà ogni volta che un'istruzione è presente unicamente in '''bash'''.
| |
| | |
| ==Come creare uno script==
| |
| Uno script, per poter essere eseguito come un eseguibile qualsiasi, in ambiente UNIX e Unix-like deve:
| |
| * avere il bit di esecuzione attivo;
| |
| * iniziare con due caratteri: '''<code>#!</code>''' (''shebang'').
| |
| Questo specifica che il file è uno script, ossia non è compilato e direttamente eseguibile, e va eseguito indirettamente invocandone l'interprete con il percorso e le eventuali opzioni scritte sulla stessa riga dello shebang.
| |
| | |
| Per scrivere uno script in '''bash''' basta quindi creare un file con la prima riga che faccia riferimento al percorso della shell:
| |
| <pre>
| |
| #! /bin/bash
| |
| </pre>
| |
| | |
| È consigliato inoltre di determinare esplicitamente il valore di ritorno (''exit status'') di uno script, facendolo terminare con l'istruzione <code>exit</code> seguita dall'exit status, che è un valore intero compreso tipicamente tra 0 (l'unico valore per successo) e 255. In assenza di tale istruzione il valore di ritorno dello script sarà determinato dall'exit status dell'ultimo comando eseguito.
| |
| | |
| Inoltre è bene sapere che l'esecuzione di uno script in '''bash''', così come uno in '''sh''' (''POSIX''), di default non è interrotta in presenza di errori. È importante quindi controllare l'exit status dei comandi eseguiti, se possono fallire, con <code>if</code> oppure con gli operatori logici di concantenazione <code>&&</code> e <code>||</code>, che saranno introdotti.
| |
| | |
| Fa eccezione l'istruzione <code>exec</code> che, se seguita da un eseguibile esterno (anche un altro script), fa eseguire al processo corrente il nuovo eseguibile. Le istruzioni successive nello script non verranno eseguite, e il valore di uscita dello script è determinato da quello del nuovo eseguibile.
| |
| | |
| ===Commenti===
| |
| È considerato commento tutto ciò che segue il carattere <code>#</code> fino alla nuova riga, purché <code>#</code> non sia racchiuso tra virgolette, apici o preceduto da <code>\</code>, in tal caso mantiene il suo valore letterale.
| |
| | |
| I commenti sono ovviamente ignorati dall'interprete, ma rendono più leggibile il codice.
| |
| | |
| Si noti che lo stessa ''shebang'' introduce una riga di commento, così da poter essere riconosciuta dal sistema grazie al sistema dei ''magic pattern'' e allo stesso tempo essere ignorata dall'interprete.
| |
| | |
| ===Il primo script===
| |
| Esempio di classico programma che si limita a stampare "Hello world!" sullo schermo:
| |
| <pre>
| |
| #! /bin/bash
| |
| printf %s\\n "Hello world!"
| |
| exit 0
| |
| </pre>
| |
| | |
| ===Rendere eseguibile uno script===
| |
| Una volta scritto lo script, non resta che attivarne il bit di esecuzione. Supponendo si chiami ''script.sh'', da un terminale dare:
| |
| <pre>
| |
| $ chmod +x script.sh
| |
| </pre>
| |
| | |
| E dalla directory in cui si trova è possibile eseguirlo dal terminale con:
| |
| <pre>
| |
| $ ./script.sh
| |
| </pre>
| |
| | |
| ==Debug integrato==
| |
| '''Bash''', proprio come '''dash''' (la cui sintassi è limitata quasi soltanto alla shell POSIX), 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:
| |
| <pre>
| |
| $ bash -n script.sh
| |
| </pre>
| |
| | |
| 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 lo script se si accede a una variabile mai assegnata;
| |
| * <code>-e</code> interrompe lo script in caso di errore (se il comando non è controllato da un <code>if</code>, <code>while</code> o dalla concatenazione con <code>||</code>).
| |
| | |
| E possono essere usate anche dopo lo shebang nella prima riga dello script. Per esempio:
| |
| <pre>
| |
| #! /bin/bash -e
| |
| </pre>
| |
| | |
| =Comandi essenziali=
| |
| I comandi introdotti in questa sezione sono descritti solo limitatamente alla loro sintassi base, così che il loro impiego nelle sezioni successive possa essere facilmente compreso.
| |
| | |
| La lettura della sezione può essere tralasciata, se si hanno già nozioni basilari di '''bash''', ma la parte sui comandi di output serve anche a giustificare la scelta di <code>printf</code> in luogo del più noto <code>echo</code> come unico comando di output e a spiegarne brevemente la sintassi, almeno per le invocazioni più comuni.
| |
| | |
| ==Comandi di output: echo e printf==
| |
| Il comando <code>echo</code> è largamente diffuso in Bash per stampare delle stringhe su schermo, perché ha una sintassi più semplice di <code>printf</code> e non risente delle stesse limitazioni della shell sh (''POSIX''), che interpreta ed espande i caratteri di escape (si legga la sezione dedicata) senza che ci sia un modo di stampare letteralmente una stringa (non nota a priori).
| |
| | |
| Tuttavia negli script l'uso di <code>echo</code> non è sempre possibile, rendendo necessaria la conoscenza almeno basilare di <code>printf</code>. In particolare, se si vuole stampare il contenuto di $var, '''non''' è sempre corretto scrivere:
| |
| <pre>
| |
| echo -n "$var" # stampa senza a capo finale
| |
| echo "$var" # stampa con a capo finale
| |
| </pre>
| |
| perché $var potrebbe iniziare con il carattere "<code>-</code>" ed essere una combinazione delle opzioni: -e, -E, -n.
| |
| | |
| Con <code>echo</code> non esiste un modo che assicuri la stampa del contenuto di una variabile in ogni situazione possibile. E non sempre il contenuto è noto a priori: in presenza di espansioni, come vedremo poi, o di input dell'utente. Per non incorrere in errori difficili da riconoscere, <code>echo</code> andrebbe usato soltanto nella shell interattiva, dove l'uso è più comodo, e <code>printf</code> andrebbe preferito anche in Bash per gli script, perché ha una sintassi più robusta.
| |
| | |
| In questa guida d'ora in poi si farà riferimento soltanto a <code>printf</code>.
| |
| | |
| ===Uso di printf===
| |
| Sintassi: <code>printf formato [ "stringa" ... ]</code>
| |
| | |
| Gli usi più avanzati non sono trattati in questa guida, ma di seguito sono presentati alcuni esempi:
| |
| * stampa sullo schermo senza a capo finale
| |
| <pre>printf %s "stringa da stampare"
| |
| printf %s "$var"</pre>
| |
| * stampa una riga vuota
| |
| <pre>
| |
| printf \\n # corretto (doppio backslash)
| |
| printf \n # ERRORE: stampa 'n'
| |
| | |
| # tra virgolette
| |
| printf "\\n" # corretto (doppio backslash)
| |
| printf "\n" # corretto (singolo backslash)
| |
| | |
| # tra apici
| |
| printf '\\n' # ERRORE: stampa '\n'
| |
| printf '\n' # corretto (singolo backslash)
| |
| </pre>
| |
| * altri caratteri speciali nel formato (stesse considerazioni sull'uso di " e ')
| |
| <pre>
| |
| printf \\t # tabulazione
| |
| printf \\r # ritorno a inizio riga
| |
| printf \\NNN # stampa il carattere ascii con codice in base 8
| |
| </pre>
| |
| * stampa sullo schermo con a capo finale
| |
| <pre>printf %s\\n "stringa da stampare"
| |
| printf %s\\n "$var"</pre>
| |
| * stampa con a capo prima e dopo
| |
| <pre>printf \\n%s\\n "stringa" </pre>
| |
| | |
| '''Mai''' stampare una stringa e ancora peggio una variabile senza farla precedere dal formato:
| |
| <pre>
| |
| printf "stringa" # ERRORE: le sequenze speciali inizianti in \ e % verrebbero interpretate!
| |
| printf "$var" # ERRORE: come sopra
| |
| printf %s "stringa" # corretto
| |
| printf %s "$var" # corretto
| |
| </pre>
| |
| | |
| Per usi più complessi, anziché rendere più complicato il formato, è preferibile utilizzare più comandi <code>printf</code>:
| |
| <pre>
| |
| # funziona, ma è poco chiaro per chi non ne conosce la sintassi
| |
| printf '%s\n\t%s %s\n' "Sintassi:" "$0" "[ arg ]" # più stringhe
| |
| | |
| # equivalente, ma più leggibile:
| |
| printf %s\\n "Sintassi:"
| |
| printf '\t%s\n' "$0 [ arg ]"
| |
| </pre>
| |
| | |
| ==Condizioni==
| |
| Le condizioni nella shell dipendono dal valore di uscita (exit status) di un comando. Si considera successo un exit status corrispondente a 0, ed è equivalente a una condizione vera/soddisfatta, mentre fallimento un exit status con valori diversi da zero, e sono equivalenti a una condizione falsa/non soddisfatta.
| |
| | |
| Il significato dell'exit status di un comando (successo/fallimento) può essere invertito facendolo precedere da un punto esclamativo (<code>!</code>).
| |
| | |
| Alcuni comandi hanno un exit status predeterminato:
| |
| * <code>:</code> o (equivalentemente) <code>true</code> hanno un exit status sempre di zero (successo/vero);
| |
| * <code>false</code> ha un exit status sempre diverso da zero (fallimento/falso).
| |
| | |
| Per esempio:
| |
| <pre>
| |
| : # exit status 0
| |
| true # equivalente
| |
| ! : # exit status diverso da 0
| |
| false # exit status diverso da 0
| |
| ! false # exit status 0
| |
| </pre>
| |
| | |
| ===Espressioni booleane===
| |
| Le espressioni booleane più basilari, ereditate da ''POSIX'', si possono esprimere con i comandi <code>test</code> e <code>[</code>. L'unica differenza tra i due è che il secondo richiede <code>]</code> come ultimo argomento, ed è preferibile per questioni di leggibilità del codice. D'ora in poi infatti si considera soltanto <code>[ ... ]</code>, e in questa sezione vengono descritte solo le forme più basilari. Per tutte le opzioni supportate si rimanda all'aiuto integrato (<code>help test</code>).
| |
| | |
| <code>[...]</code> restituisce un exit status di 0 (successo/vero) se la condizione contenuta all'interno è vera, e 1 (fallimento/falso) altrimenti. È molto utile all'interno di istruzioni più complesse, come <code>if</code> per l'esecuzione condizionata e <code>while</code> per eseguire cicli.
| |
| | |
| Confronti unari con stringhe (tipicamente l'espansione di variabile o parametro):
| |
| * <code>[ -z "$var" ]</code>: vero se var contiene una stringa di lunghezza zero o non è definita;
| |
| * <code>[ -n "$var" ]</code>: vero se var contiene una stringa che non ha lunghezza zero.
| |
| | |
| Confronti binari tra stringhe (possono essere anche entrambe variabili):
| |
| * <code>[ "$var" = "stringa" ]</code>: vero se il contenuto di var è uguale alla stringa;
| |
| * <code>[ "$var" != "stringa" ]</code>: vero se è diverso.
| |
| | |
| Confronti binari tra stringhe contenenti interi (possono essere anche entrambe variabili):
| |
| * <code>[ "$var" -gt valore ]</code>: ('''g'''reater '''t'''han) vero se l'intero contenuto nella variabile è maggiore del valore dato;
| |
| * <code>[ "$var" -ge valore ]</code>: ('''g'''reater or '''e'''qual to) vero se l'intero contenuto nella variabile è maggiore o uguale al valore dato;
| |
| * <code>[ "$var" -lt valore ]</code>: ('''l'''ower '''t'''han) vero se l'intero contenuto nella variabile è inferiore del valore dato.
| |
| * <code>[ "$var" -le valore ]</code>: ('''l'''ower or '''e'''qual to) vero se l'intero contenuto nella variabile è inferiore o uguale al valore dato.
| |
| Se una delle due stringhe non è un intero, anche negativo, il confronto fallisce e può esserci la stampa di un messaggio d'errore sullo standard error. Per evitarlo va aggiunto <code>2> /dev/null</code> (il significato di tale redirezione sarà trattato in seguito). Per esempio:
| |
| <pre>
| |
| [ "$var" -gt 0 ] 2> /dev/null # non stampa errori se $var non è un intero
| |
| </pre>
| |
| | |
| Confronti unari con stringhe contenenti percorsi di file (percorso di default: directory corrente, se mancante):
| |
| * <code>[ -e "$var" ]</code>: vero se il file (file regolare, directory, link simbolico, fifo, socket, ... ) esiste;
| |
| * <code>[ -f "$var" ]</code>: vero se il file esiste ed è un file regolare;
| |
| * <code>[ -d "$var" ]</code>: vero se il file esiste ed è una directory.
| |
| | |
| Le espressioni più complesse si possono comporre utilizzando gli operatori logici <code>&&</code> e <code>||</code> per aggregare più istruzioni <code>[...]</code>, e le parentesi <code>{ ... ; }</code> per determinarne la priorità, come si vedrà nella parte sui blocchi di istruzioni.
| |
| | |
| ===Esecuzione condizionata===
| |
| Per eseguire un blocco di comandi soltanto se una condizione è soddisfatta si utilizza <code>if</code>, solitamente in combinazione con <code>[...]</code>.
| |
| | |
| La sua sintassi base (in congiunzione con <code>[...]</code>) è:
| |
| <pre>
| |
| if [ espressione-booleana ]; then
| |
| ...
| |
| [ elif [ espressione-booleana ]; then
| |
| ... ]
| |
| ...
| |
| [ else ...
| |
| ... ]
| |
| fi
| |
| </pre>
| |
| | |
| Per esempio:
| |
| <pre>
| |
| if [ -z "$var" ]; then
| |
| printf %s\\n "La variabile var è nulla!"
| |
| elif [ "$var" = "pluto" ]; then
| |
| printf %s\\n "La variabile var contiene pluto"
| |
| else
| |
| printf %s\\n "La variabile var non è nulla e non contiene pluto, ma: ${var}"
| |
| fi
| |
| </pre>
| |
| | |
| ====Controllo degli errori====
| |
| Si ricordi che <code>if</code> accetta un comando qualsiasi come condizione, valutandone l'exit status ed eseguendo il ramo <code>then</code> se ha successo, e quello <code>elif</code>/<code>else</code> immediatamente successivo (se presente) altrimenti. Quindi è un ottimo strumento anche per controllare che un comando venga eseguito senza errori, permettendo anche la terminazione immediata dello script:
| |
| <pre>
| |
| if comando; then
| |
| printf %s\\n "Comando riuscito!"
| |
| else
| |
| printf %s\\n "ERRORE: comando fallito!"
| |
| # esci con errore (exit status 1)
| |
| exit 1
| |
| fi
| |
| </pre>
| |
| e se si è interessati al solo ramo ''else'', basta utilizzare <code>!</code> prima del comando:
| |
| <pre>
| |
| if ! comando; then
| |
| exit 1
| |
| fi
| |
| </pre>
| |
| | |
| =Variabili (stringhe)=
| |
| In '''bash''' ogni variabile di default è trattata come una stringa e, benché siano supportati anche interi e array (indicizzati o associativi), questa guida 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 la concatenazione <code>"$nome$cognome"</code> è 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.
| |
| | |
| ==Assegnazioni==
| |
| Non si deve usare il <code>'''$'''</code> davanti alla variabile a cui assegnare. La forma consigliata, salvo necessità particolari, è quella tra virgolette per le stringhe e le concatenazioni di stringhe e variabili, e senza virgolette per una singola variabile:
| |
| <pre>
| |
| var="stringa"
| |
| var=$var2 # senza virgolette
| |
| var=${var2} # equivalente a sopra
| |
| var="$var2" # come sopra
| |
| var="${var1} testo ${var2}" # con virgolette
| |
| </pre>
| |
| | |
| Altre forme sono possibili, e il loro significato è trattato in seguito:
| |
| <pre>
| |
| var=stringa # assegno una stringa (senza spazi e caratteri speciali)
| |
| var=$'stringa con escape' # come sopra, ma con caratteri di escape e senza espansioni
| |
| var='stringa senza apici' # niente espansioni, né caratteri di escape
| |
| # espansioni...
| |
| var=$(comando) # assegna l'output del comando
| |
| var=$(($n * 10)) # assegna il risultato dell'operazione
| |
| var=~utente # assegna la home di utente
| |
| </pre>
| |
| | |
| ===Modificatori===
| |
| Sono comandi interni che possono essere applicati soltanto a un nome di variabile (senza '''$''') o a un'assegnazione, e in quest'ultimo caso hanno effetto sulla variabile dopo l'avvenuta assegnazione.
| |
| ; export : specifica che la variabile farà parte delle variabili d'ambiente (''environment'') dei comandi esterni eseguiti dallo script:
| |
| <pre>
| |
| var="stringa"
| |
| export var
| |
| # equivalente a:
| |
| export var="stringa"
| |
| # comando esterno
| |
| comando # può accedere al contenuto di var
| |
| </pre>
| |
| È possibile definire una o più variabili nell'ambiente di un comando, senza farle ereditare a quelli successivi, semplicemente scrivendo le assegnazioni prima del nome del comando. Per esempio:
| |
| <pre>
| |
| var="stringa" comando # può accedere al contenuto di var
| |
| printf %s\\n "$var" # $var è vuota!
| |
| </pre>
| |
| | |
| ; readonly : specifica che la variabile (per convenzione scritta con caratteri maiuscoli) è di sola lettura e dev'essere trattata da quel punto in poi come una costante:
| |
| <pre>
| |
| VAR="valore"
| |
| readonly VAR
| |
| # equivalente a:
| |
| readonly VAR="valore"
| |
| VAR="altro valore" # ERRORE! var ora è una costante
| |
| </pre>
| |
| Per convenzione le costanti sono poste tutte all'inizio dello script, prima anche di eventuali definizioni delle funzioni.
| |
| | |
| ===Assegnazione dallo standard input===
| |
| Con l'istruzione <code>read</code> è possibile assegnare a una o più variabili il contenuto di una riga dello standard input, che senza redirezioni e pipe corrisponde a ciò che viene scritto da tastiera prima di un invio.
| |
| | |
| Sintassi (base): <code>read nomevariabile [ ... ]</code>
| |
| | |
| Il nome delle variabili non va preceduto da '''$''', proprio come nelle assegnazioni normali. Se sono presenti più nomi di variabile, la riga letta si divide in stringhe delimitate dai caratteri contenuti in <code>$IFS</code> (di default sono tre: spazio, tabulazione e invio), ma all'ultima variabile viene sempre assegnato tutto il contenuto rimanente fino a fine riga.
| |
| | |
| Esempio:
| |
| <pre>
| |
| printf %s "Scrivi qualcosa e premi invio: "
| |
| read testo
| |
| printf %s\\n "Hai scritto: ${testo}"
| |
| </pre>
| |
| | |
| ===Assegnazione con ciclo===
| |
| Con l'istruzione <code>for</code> è possibile eseguire un blocco di istruzioni per ogni elemento di una lista di stringhe, assegnando un elemento per volta a una variabile.
| |
| | |
| Sintassi (base):
| |
| <pre>
| |
| for nomevariabile [ in ... ]
| |
| do
| |
| ...
| |
| done
| |
| </pre>
| |
| | |
| Al solito il nome della variabile non va preceduto da '''$'''. Se la parola riservata <code>in</code> e la lista di stringhe sono omesse, allora è equivalente a: <code>in "$@"</code>
| |
| | |
| Due modi tipici per generare una lista di stringhe sono:
| |
| * con la variabile speciale <code>"$@"</code>, l'unica che se quotata si espande a una lista di stringhe;
| |
| * con l'espansione di percorso, che sarà trattata in seguito;
| |
| | |
| Per esempio:
| |
| <pre>
| |
| for file in /percorso/*.txt
| |
| do
| |
| if [ -e "$file" ]; then
| |
| # blocco eseguito su ciascun file .txt in /percorso/ tramite "$file"
| |
| ...
| |
| fi
| |
| done
| |
| </pre>
| |
| | |
| {{Warningbox | Se si utilizza l'espansione di comando per generare una lista di stringhe, bisogna assicurarsi che ogni stringa non contenga spazi oppure caratteri speciali che potrebbero essere espansi nuovamente (<code>* ? [ ]</code>). L'uso combinato con <code>find</code> in particolare è sconsigliato e quasi sempre sbagliato, a meno che non si sappia a priori che ogni file presente nel percorso scelto soddisfa tali condizioni.}}
| |
| | |
| Il ciclo <code>for</code> può essere:
| |
| * interrotto dall'istruzione <code>break</code>;
| |
| * continuato saltando la corrente iterazione del ciclo con <code>continue</code>, che passa al prossimo elemento della lista, se presente, altrimenti esce.
| |
| | |
| ==Espansione di variabile==
| |
| 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 (tramite il comando esterno <code>cp</code>):
| |
| <pre>
| |
| cp -- "$file" "${file}.bak"
| |
| </pre>
| |
| | |
| {{Suggerimento | L'opzione "--" dopo il comando esterno <code>cp</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, come: <code>rm</code>, <code>rmdir</code>, <code>cp</code>, <code>mv</code>, <code>touch</code>, <code>cat</code>, ecc... <br/>
| |
| L'opzione deve essere supportata dal comando esterno, non è trattata specialmente dalla shell.}}
| |
| | |
| 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 che potrebbero essere espansi nuovamente (<code>* ? [ ]</code>), 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"
| |
| ...
| |
| 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>
| |
| | |
| =Caratteri di escape, apici e virgolette=
| |
| Alcuni caratteri hanno un valore speciale per la shell, per consentire le espansioni o determinati costrutti. Di conseguenza se si intende scrivere il carattere per il suo valore letterale, è necessario comunicarlo alla shell facendolo precedere da un carattere di escape '<code>\</code>' oppure racchiudendolo tra apici o virgolette.
| |
| | |
| Una stringa non racchiusa tra apici o tra virgolette ha i seguenti caratteri speciali: <code>$ ' ` " \ { } [ ] * ? ~ & ; ( ) < > | #</code>
| |
| <br/>In determinate circostanze, se non preceduti dal carattere di escape <code>\</code>, possono essere: espansi, eseguiti in background, considerati parte di un nuovo comando, trattati come redirezioni e perfino come commenti. Questa sezione non è esaustiva e non considera tutte le eccezioni, ma consiglia degli accorgimenti che si possono sempre seguire per ridurre il numero di caratteri speciali.
| |
| | |
| Inoltre gli spazi (comprese le tabulazioni) non quotati con apici o virgolette, e non preceduti dal carattere di escape <code>\</code>, vengono compressi e ciò che è scritto prima o dopo è interpretato come appartenente a stringhe diverse.
| |
| | |
| Per esempio:
| |
| <pre>
| |
| printf %s\\n parola1; parola2 # ERRORE: parola2 è considerata un altro comando!
| |
| printf %s\\n "parola1; parola2" # corretto
| |
| printf %s\\n parola1 parola2 # ERRORE: niente spazi e su due righe diverse!
| |
| printf %s\\n "parola1 parola2" # corretto
| |
| | |
| # con una variabile
| |
| var="parola1 parola2" # assegno la stringa alla variabile
| |
| printf %s\\n $var # ERRORE: stampa le parole su due linee diverse
| |
| printf %s\\n "$var" # stampo la stringa 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
| |
| printf %s\\n "testo su \
| |
| più \
| |
| righe"
| |
| | |
| # stampa su più righe
| |
| printf %s\\n "testo su
| |
| più
| |
| righe"
| |
| </pre>
| |
| | |
| ==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>printf %s\\n '$PATH "" \ `ls ..` \$HOME ~ * .[a-z]*' # stampa la stringa tra apici, letteralmente</pre>
| |
| | |
| Lo svantaggio è che non esiste un carattere di escape:
| |
| <pre>printf %s\\n 'L'\''albero di... ' # stampa "L'albero di..." (l'accento non può essere racchiuso tra apici)</pre>
| |
| | |
| ==Racchiudere tra $'...'==
| |
| Una stringa racchiusa tra <code>$'...'</code> non può essere espansa in nessun modo, come se fosse racchiusa tra apici. Il carattere <code>\</code> resta un carattere di escape, quindi è possibile inserire un apice nella stringa facendolo precedere da <code>\</code> e dev'essere preceduto dal carattere di escape anche ogni <code>\</code> da stampare letteralmente.
| |
| | |
| Un carattere <code>\</code> non preceduto da escape permette di stampare caratteri di escape, con la stessa sintassi del formato di <code>printf</code> (quando racchiuso tra apici):
| |
| * '''\n''', nuova riga;
| |
| * '''\b''', backspace (cancella un carattere);
| |
| * '''\r''', carriage return (ritorna a inizio riga);
| |
| * '''\t''', tabulazione;
| |
| * '''\nnn''', carattere ASCII in base 8;
| |
| * ecc...
| |
| | |
| Per esempio:
| |
| <pre>
| |
| printf %s\\n $'stringa' # stampa la stringa
| |
| printf %s $'stringa\n' # equivalente: il carattere "a capo" ora è nella stringa
| |
| printf %s $'$PATH "" `ls ..`\n' # nessuna espansione
| |
| printf %s $'~ * .[a-z]*\n' # nessuna espansione
| |
| printf %s $'{a,b,c} $((2*2))\n' # nessuna espansione
| |
| printf %s $'escape: \\\n' # per stampare un \ dev'essere preceduto da \
| |
| printf %s $'L\'albero di...\n' # stampa "L'albero di..." (l'apice può essere stampato con escape)
| |
| </pre>
| |
| | |
| È un metodo molto meno diffuso rispetto a racchiudere tra apici e virgolette, perché non derivata da '''sh''' (''POSIX'').
| |
| | |
| ==Quotare (tra virgolette)==
| |
| Racchiudere tra virgolette ogni stringa è raccomandabile, anche se non sempre necessario, così da ridurre 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>.
| |
| | |
| All'interno di una stringa quotata tutte le espansioni che '''non''' sono attivabili da <code>$</code> non sono permesse. Sono possibili soltanto le espansioni di variabile/parametro, di comando e aritmetiche.
| |
| | |
| Per esempio:
| |
| <pre>
| |
| printf %s\\n "$PATH" # espande la variabile PATH e ne stampa il contenuto
| |
| printf %s\\n "\$HOME" # stampa letteralmente $HOME, senza espanderla (è equivalente a '$HOME')
| |
| printf %s\\n "\"\" \\" # è equivalente a '"" \'
| |
| printf %s\\n "$(ls ..)" # Esegue il comando "ls .." e ne stampa l'output
| |
| printf %s\\n "$((2*2))" # Esegue l'espressione aritmetica e stampa 4
| |
| printf %s\\n "~ * .[a-z]*" # non effettua le espansioni di tilda e percorso, ma stampa letteralmente
| |
| printf %s\\n "p{a,b,c}s" # niente espansioni
| |
| </pre>
| |
| | |
| =Espansioni in stringhe quotate=
| |
| Le espansione attivate da <code>$</code> avvengono con la stessa priorità, e in una stringa quotata sono le uniche permesse, quindi il risultato di un'espansione non può mai essere espanso un'altra volta. Sono permesse le sole espansioni di variabile, già vista, e di parametro, di comando e aritmetica (intera), che saranno trattate in seguito.
| |
| | |
| ==Espansione di parametro (stringa)==
| |
| È una forma modificata dell'espansione di variabile, che permette di operare sulla stringa contenuta con un modificatore.
| |
| | |
| L'espansione di parametro è utilizzabile ogni volta che lo è quella di variabile, con un'unica differenza: l'espansione di variabile può essere contenuta in alcune espansioni di parametro, purché non al posto del nome della variabile, mentre non è mai possibile annidare più espansioni di parametro.
| |
| | |
| Modificatori:
| |
| * <code>${#var}</code> ritorna il numero di caratteri della stringa contenuta in $var. Espande sempre a una singola stringa;
| |
| * <code>${!var}</code> (non ''POSIX'') ritorna il contenuto della variabile, il cui nome è contenuto in $var (accesso indiretto);
| |
| * espande o assegna valori di default/alternativi;
| |
| * manipolatori di stringa (rimozione, sostituzione, trasformazione in uppercase/lowercase).
| |
| | |
| Esempio:
| |
| <pre>
| |
| var="stringa"
| |
| rif="var" # rif contiene il nome (senza $) di $var
| |
| var2=${!rif} # equivalente a: var2=$var
| |
| printf %s\\n "$var2" # stampa: stringa
| |
| printf %s\\n ${#var2} # stampa: 7 (la lunghezza di "stringa")
| |
| </pre>
| |
| | |
| ===Manipolazione delle stringhe===
| |
| Per manipolare una stringa, è possibile assegnarla a una variabile per poi effettuarne un'espansione di parametro che manipola la stringa, senza modificare il contenuto della variabile. Per esempio:
| |
| <pre>
| |
| VAR="stringa-di-esempio"
| |
| printf %s\\n "${VAR#stringa-}"
| |
| </pre>
| |
| ritorna il contenuto della variable VAR senza il prefisso "stringa-". VAR non viene modificata, salvo una nuova assegnazione:
| |
| <pre>
| |
| VAR=${VAR#stringa-}
| |
| </pre>
| |
| ora il prefisso "stringa-" è stato eliminato anche dalla variabile VAR.
| |
| | |
| I modificatori sono molti, ma possono essere facilmente ricordati se si imparano i fondamentali:
| |
| * <code>#</code> sottrae dall'inizio della stringa ''(minimale)'';
| |
| * <code>%</code> sottrae dalla fine della stringa ''(minimale)'';
| |
| * <code>/</code> (non ''POSIX'') sostituisce una sottostringa con un'altra ''(solo la prima volta che viene incontrata)'';
| |
| * <code>^</code> (non ''POSIX'') trasforma in maiuscola la prima lettera della stringa ''(solo il primo carattere)'';
| |
| * <code>,</code> (non ''POSIX'') trasforma in minuscola la prima lettera della stringa ''(solo il primo carattere)''.
| |
| | |
| Questi operatori sono minimali, questo vuol dire che se si usano le espressioni regolari per indicare la sottostringa (da eliminare, sostituire o trasformare) verrà individuata in caso di ambiguità la sottostringa più piccola (o solo la prima nel caso di sostituzione o trasformazione).
| |
| | |
| 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> (non ''POSIX'') sostituisce una sottostringa con un'altra ''(tutte le volte che viene incontrata)'';
| |
| * <code>^^</code> (non ''POSIX'') trasforma in maiuscola la stringa ''(tutta)'';
| |
| * <code>,,</code> (non ''POSIX'') trasforma in minuscola la stringa ''(tutta)''.
| |
| | |
| Gli operatori massimali cercano di individuare la sottostringa più grande che corrisponde all'espressione regolare, mentre nel caso del modificatore '''//''' tutte le sottostringhe vengono sostituite, e nel caso della trasformazione tutta la stringa e non solo il primo carattere.
| |
| | |
| Si noti che le stringhe interne a un'espansione di parametro possono essere delle variabili, ma non altre espansioni di parametro:
| |
| <pre>
| |
| # cambia l'estensione nella variabile file
| |
| if [ "$file" != "${file%${estensione}}" ]; then
| |
| file=${file%${estensione}}${nuova_estensione}
| |
| fi
| |
| </pre>
| |
| | |
| Le espressioni regolari supportate sono le stesse permesse nelle espansioni di parametro e con lo stesso significato (ossia: <code>? * [ ]</code>), e con gli operatori di sottrazione c'è differenza tra quelli minimali e massimali soltanto se il pattern contiene uno o più <code>*</code>, che è l'unico carattere speciale che può sostituire un numero qualsiasi (zero o più) di caratteri.
| |
| | |
| ====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>. Una possibile alternativa:
| |
| <pre>
| |
| usage () {
| |
| printf %s\\n "Usage: ${0##*/}"
| |
| }
| |
| </pre>
| |
| | |
| ====Esempi: manipolazione delle stringhe====
| |
| <pre>
| |
| VAR="questa.sarebbe.UNA.stringa.di.esempio"
| |
|
| |
| # Risultato:
| |
|
| |
| printf %s\\n "${VAR#*.}" # sarebbe.UNA.stringa.di.esempio
| |
| printf %s\\n "${VAR##*.}" # esempio
| |
|
| |
| printf %s\\n "${VAR%.*}" # questa.sarebbe.UNA.stringa.di
| |
| printf %s\\n "${VAR%%.*}" # questa
| |
|
| |
| printf %s\\n "${VAR/st/LL}" # queLLa.sarebbe.UNA.stringa.di.esempio
| |
| printf %s\\n "${VAR//st/LL}" # queLLa.sarebbe.UNA.LLringa.di.esempio
| |
| | |
| printf %s\\n "${VAR^*}" # Questa.sarebbe.UNA.stringa.di.esempio
| |
| printf %s\\n "${VAR^^*}" # QUESTA.SAREBBE.UNA.STRINGA.DI.ESEMPIO
| |
| | |
| printf %s\\n "${VAR,*}" # questa.sarebbe.UNA.stringa.di.esempio (invariata)
| |
| printf %s\\n "${VAR,,*}" # questa.sarebbe.una.stringa.di.esempio
| |
| </pre>
| |
| | |
| 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]
| |
| | |
| ==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>:
| |
| <pre>$(comando)</pre>
| |
| oppure, meno leggibile e sconsigliata tra <code>`...`</code> (su tastiera con layout italiano: <code>Alt Gr + '</code>):
| |
| <pre>`comando`</pre>
| |
| | |
| Inoltre la prima forma può essere annidata facilmente, mentre la seconda richiederebbe un livello aggiuntivo di escape.
| |
| | |
| 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 la dimensione in bytes di $file
| |
| testo=$(wc -c -- $file) # SBAGLIATO! (se la variabile $file contiene spazi o caratteri speciali)
| |
| testo=$(wc -c -- "$file") # le virgolette attorno alla variabile sono necessarie
| |
| testo="$(wc -c -- "$file")" # equivalente a sopra
| |
| # testo contiene anche altre stringhe, ma sono interessato solo alla prima
| |
| bytes=${testo%% *} # estraggo il primo argomento (espansione di parametro)
| |
| </pre>
| |
| | |
| Passaggio dell'output dei comandi come argomento:
| |
| <pre>
| |
| # stampa stati
| |
| printf %s\\n "Login name: $(logname); Name: $(whoami); UID: $(id -ur); EUID: $(id -u); Groups: $(groups)"
| |
| printf %s\\n "OS: Debian GNU/Linux $(cat /etc/debian_version) ($(lsb_release -sc))" # uguale a $(lsb_release -sd)
| |
| printf %s\\n "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>
| |
| printf %s\\n ciao > ./file_prova # scrive ciao e un "a capo" nel file_prova
| |
| testo=$(cat ./file_prova) # associa il contenuto (SENZA "a capo") a $testo
| |
| printf %s\\n "Bytes: ${#testo}" # NON è la dimensione esatta del file!
| |
| printf %s\\n "$testo" | # invia la stringa a cmp (più un "a capo") per un confronto
| |
| cmp - ./file_prova # nessun errore!!!
| |
| printf %s\\n $? # 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 (non POSIX) ed è il modo consigliato in bash
| |
| | |
| # a titolo esemplicativo per l'espansione di comando
| |
| nr=$(printf \\n) # SBAGLIATO, $nr è vuota
| |
| nr="$(printf \\n)" # SBAGLIATO, $nr è sempre vuota
| |
| | |
| # una possibile soluzione (POSIX)
| |
| nr=$(printf \\n%s X) # $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 aritmetica intera==
| |
| Permette di compiere operazioni aritmetiche tra interi, ritornando sempre una singola stringa contenente l'intero risultante. Può essere quotata, ma non cambia niente.
| |
| | |
| La sintassi è: <code>$((...))</code><br/>
| |
| All'interno delle parentesi è possibile utilizzare:
| |
| * le quattro operazioni: <code>+ - * /</code>
| |
| * resto/modulo: <code>%</code>
| |
| * potenza: <code>**</code>
| |
| * variabili da espandere (contenenti valori interi)
| |
| * parentesi per cambiare le priorità degli operatori: <code>( )</code>
| |
| | |
| Esempio:
| |
| <pre>
| |
| base=9
| |
| altezza=5
| |
| area=$(($base * $altezza))
| |
| printf %s\\n "Area rettangolo: ${area}" # Stampa 45
| |
| printf %s\\n "Area triangolo: $(($area / 2))" # Stampa 22 (RICORDA: solo interi)
| |
| </pre>
| |
| | |
| =Espansioni non quotabili=
| |
| Le espansioni trattate nelle sezioni successive avvengono unicamente in stringhe non quotate, almeno limitatamente ai caratteri speciali che le attivano, e sono attivabili soltanto da caratteri diversi dal '''$'''.
| |
| | |
| Le loro priorità sono tutte diverse: l'espansione di parentesi è quella maggiore, seguita dalla tilda, da tutte le espansioni attivabili con '''$''' (quelle quotabili) e infine dall'espansione di percorso.
| |
| | |
| Inoltre l'espansione di tilda, che è sempre espansa in una singola stringa, è l'unica possibile in un'assegnazione tra le espansioni non quotabili.
| |
| | |
| ==Espansione di tilda==
| |
| Sintassi:
| |
| * <code>~</code> si espande alla home, se non è quotata (equivalente all'uso di $HOME, che può essere quotata);
| |
| * <code>~utente</code> si espande alla home di un dato utente, se esiste, ma la stringa non può essere quotata né essere una variabile.
| |
| | |
| Si distingue dall'espansione di percorso perché:
| |
| * si espande sempre a una singola stringa;
| |
| * può essere espansa in un'assegnazione, se non è quotata;
| |
| * ha priorità maggiore delle espansioni quotabili; per cui, se assegnata quotata a una variabile, non sarà espansa quando si accede alla variabile.
| |
| | |
| Esempi:
| |
| <pre>
| |
| var=~ # assegno la home dell'utente a $var
| |
| var=$HOME # equivalente (ma più chiaro)
| |
| var="~" # assegno ~ a $var
| |
| printf %s\\n "$var" # stampo ~
| |
| printf %s\\n $var # equivalente (nessuna espansione)
| |
| var=~root # assegno a var la home di root
| |
| printf %s\\n ~ # stampo la home dell'utente
| |
| printf %s\\n "$HOME" # equivalente
| |
| printf %s\\n "~" # stampo ~
| |
| printf %s\\n ~root # stampo la home di root
| |
| printf %s\\n ~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...
| |
| | |
| L'espansione di percorso avviene unicamente in base al nome del file, che dev'essere univoco in una cartella, e non al tipo di file. L'unica eccezione sono le directory, perché possono essere identificate anche con lo slash (/) finale.}}
| |
| | |
| Le espansioni di percorso sono possibili solo se i caratteri speciali che la consentono (<code>* ? [ ]</code>) non sono racchiusi tra virgolette, apici o preceduti da <code>/</code>. È sempre consigliabile racchiudere tutto il resto tra virgolette, per non permettere espansioni accidentali.
| |
| | |
| L'espansione non è possibile, direttamente, in un'assegnazione. Avendo la priorità più bassa, contrariamente all'espansione di tilda può avvenire anche in seguito all'espansione di una variabile (e con ogni altra espansione), se non è quotata:
| |
| <pre>
| |
| var="./*" # assegno ./* a $var
| |
| var=./* # come sopra (nessuna espansione in un'assegnazione)
| |
| printf %s\\n "$var" # stampa letteralmente ./*
| |
| printf %s\\n $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 nome di file, con tutti quelli possibili che combaciano con le due stringhe date, ma di default tranne il '''.''' iniziale se manca il prefisso;
| |
| * <code>prefisso'''*'''suffisso</code> può sostituire tutti i caratteri nei nomi di file, ma di default tranne quelli nascosti se manca il prefisso (ossia quelli inizianti con '''.''');
| |
| * <code>prefisso'''[classe]'''suffisso</code> sostituisce un singolo carattere di un nome di file, con tutti quelli possibili appartenenti alla classe data e che combaciano con le due stringhe. La classe può contenere:
| |
| **una lista di caratteri, tutti attaccati, per sostituirne uno qualsiasi della lista;
| |
| **un intervallo composto da due caratteri separati da un trattino <code>-</code>, per sostituirne uno qualsiasi dell'intervallo in base al loro valore ASCII;
| |
| **un <code>!</code> iniziale per farne il complemento, ossia sostituirne uno qualsiasi non presente nella classe;
| |
| **il carattere <code>!</code> può essere contenuto per il suo valore letterale in una classe purché non in prima posizione, mentre <code>-</code> è considerato letteralmente soltanto in prima posizione (o seconda se dopo <code>!</code>) e in ultima posizione.
| |
| | |
| Se un nome di file non include il percorso assoluto (iniziante con la directory radice '''/''') o relativo (iniziante con '''./''' oppure '''../''', dalla directory corrente e da quella superiore rispettivamente), di default si assume che sia nella directory corrente. Tuttavia per evitare ambiguità con i nomi delle opzioni di alcuni comandi, in presenza di possibili nomi di file inizianti con il trattino '''-''', in particolare se la parte iniziale del file è generata dall'espansione di percorso, è sempre bene rendere esplicito il percorso relativo premettendo '''./''' al nome del file.
| |
| | |
| 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>./???.ext</code> si espande a tutti i file con nomi di tre caratteri (salvo i file nascosti, ossia con '''.''' iniziale) ed estensione ext;
| |
| * <code>./*</code> si espande a tutti i file non nascosti nella directory corrente;
| |
| * <code>./*.txt</code> espande a tutti i file con estensione .txt ('''NOTA:''' anche directory e qualsiasi file non regolare avente tale estensione);
| |
| * <code>./*."${estensione}"</code> espande dopo aver espanso la variabile (contrariamente a ~), che può anche essere quotata;
| |
| * <code>"./${nome}"*</code> espande a tutti i file inizianti con ${nome};
| |
| * <code>./*/</code> espande a tutte le directory non nascoste;
| |
| * <code>./.*</code> espande a tutti i file nascosti ('''ATTENZIONE:''' comprese "'''.'''" e "'''..'''", ossia directory corrente e superiore);
| |
| * <code>[a-zA-Z]*</code> espande a tutti i file inizianti con una lettera qualsiasi (nessun file nascosto perché il punto non è nella classe);
| |
| * <code>./*.[tT][xX][tT]</code> espande a tutti i file con estensione txt (ignorando maiuscole e minuscole);
| |
| * <code>./.[!.]*</code> espande a tutti i file nascosti di almeno due caratteri in cui il secondo non è un punto (non espande a '''.''' e '''..''', ma nemmeno a possibili file nascosti inizianti con '''..''');
| |
| * <code>./..?*</code> espande a tutti i file nascosti di almeno tre caratteri in cui il secondo non è un punto (tutti i file nascosti saltati dal precedente, ma sempre escludendo '''.''' e '''..''');
| |
| * <code>./.[!.]* ./..?*</code> espande a tutti i file nascosti, esclusi '''.''' e '''..''' (''POSIX'').
| |
| | |
| È 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. E inoltre <code>*</code>, <code>?</code>, <code>[</code> e <code>]</code> sono caratteri validi per un nome di file.
| |
| | |
| L'esistenza di file ottenuti da tali espansioni va pertanto sempre controllata, impiegando l'espansione per generare una lista di stringhe all'interno di un ciclo <code>for</code>, ed effettuando poi il controllo di esistenza su ognuna:
| |
| <pre>for file in ./*; do
| |
| if [ -e "$file" ]; then
| |
| ...
| |
| fi
| |
| done</pre>
| |
| Si faccia attenzione che tutti i pattern delle espansioni di percorso, e non solo quelli composti da <code>*</code>, possono generare più stringhe, anche se sostituiscono un singolo carattere in presenza di fili multipli con lo stesso prefisso e/o suffisso (per esempio il pattern ''a?c'' può espandersi alla lista ''abc aBC acc'', se esistono questi tre file).
| |
| | |
| In alternativa il comportamento di default dell'espansione può essere cambiato in bash (non ''POSIX''), tramite <code>shopt -s</code>:
| |
| * '''nullglob''' espande a "niente" se non trova nessun file con un dato pattern, rendendo superfluo il controllo sull'esistenza;
| |
| * '''dotglob''' espande ai file nascosti (ma non a '''.''' e '''..''');
| |
| * '''nocaseglob''' espande il percorso a tutte le corrispondenze trovate, ignorando maiuscole e minuscole (''case-insensitive'').
| |
| Per esempio per espandere a tutti i file, compresi quelli nascosti:
| |
| <pre>
| |
| shopt -s dotglob nullglob
| |
| for file in ./*; do
| |
| ...
| |
| done
| |
| </pre>
| |
| | |
| ===Esempio: cambiare l'estensione ai file regolari===
| |
| Rinomina tutti i file regolari <code>*.txt</code> della directory corrente in <code>*.log</code>, tramite il comando esterno <code>mv</code>:
| |
| | |
| <pre>
| |
| for f in ./*.txt; do
| |
| if [ -f "$f" ]; then
| |
| mv -- "$f" "${f%txt}log"
| |
| fi
| |
| done
| |
| </pre>
| |
| | |
| Si noti che utilizzando <code>[ '''-f''' ... ]</code> in luogo di <code>[ '''-e''' ... ]</code>, si saltano anche tutti i file che non sono regolari, e che potrebbero essere restituiti dall'espansione di percorso.
| |
| | |
| ==Espansione di parentesi (graffa)==
| |
| In '''bash''' (non ''POSIX'') 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 per generare una lista di stringhe. E più espansioni di parentesi possono essere annidate.
| |
| | |
| Questa espansione avviene prima di tutte le altre, e il risultato può passare per tutte le altre espansioni. Non può avvenire in un'assegnazione, se non all'interno di altre espansioni.
| |
| | |
| ===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>
| |
| | |
| =Istruzioni composte=
| |
| Sono istruzioni composte tutte le istruzioni che possono contenere al loro interno altre istruzioni. Per esempio <code>if</code> e <code>for</code>, già trattate in precedenza per la loro importanza, sono due istruzioni composte.
| |
| | |
| ==Cicli==
| |
| In aggiunta a <code>for</code>, trattato per le assegnazioni e che può essere considerato equivalente al ''for each'' di alcuni linguaggi di programmazione, con <code>while</code> è possibile eseguire un blocco di comandi se un comando ha successo e ripeterne l'esecuzione fintanto che il comando continua ad avere successo. Proprio come <code>if</code>, <code>while</code> è un'istruzione usata spesso in congiunzione con <code>[...]</code> per ripetere un blocco di codice tutte le volte che la condizione espressa è vera.
| |
| | |
| Sintassi base (in congiunzione con <code>[...]</code>):
| |
| <pre>
| |
| while [ espressione-booleana ]
| |
| do
| |
| ...
| |
| done
| |
| </pre>
| |
| | |
| Per esempio:
| |
| <pre>
| |
| num=
| |
| # ripeti finché non è soddisfatta la condizione (si noti il ! davanti a [...])
| |
| while ! [ "$num" -gt 0 ] 2> /dev/null
| |
| do
| |
| printf %s "Inserisci intero > 0 e premi INVIO: "
| |
| # assegna l'input dell'utente a $num
| |
| read num
| |
| done
| |
| printf %s\\n "Hai inserito: ${num}"
| |
| </pre>
| |
| | |
| Oppure al posto di <code>[...]</code> si può utilizzare un comando qualsiasi, per esempio per eseguire un ciclo infinito:
| |
| <pre>
| |
| while :
| |
| do
| |
| ...
| |
| done
| |
| </pre>
| |
| | |
| Un ciclo può essere sempre:
| |
| * interrotto da <code>break</code>;
| |
| * ripreso dalla prima istruzione del blocco, dopo aver rivalutato l'exit status del comando dopo <code>while</code>, con <code>continue</code>.
| |
| | |
| ==Composizione di comandi con pipe==
| |
| Una ''pipe'' collega due comandi, trattando l'output generato dal primo come input per il secondo, in modo da svolgere funzioni più complesse tramite la composizione comandi che si occupano di funzioni più limitate. Ed è una delle caratteristiche di ''UNIX'' che ogni comando debba svolgere un'unica funzione nel modo migliore possibile, permettendo la comunicazione con l'utente o un altro comando attraverso un flusso di testo, considerato un'interfaccia universale.
| |
| | |
| L'exit status di una serie di pipe è dato dall'ultimo comando.
| |
| | |
| Sintassi:
| |
| * comando1 '''|''' comando2: pipe che invia lo standard output del comando precedente al successivo. Tutti i comandi di una serie di pipe (anche l'ultimo) sono eseguiti in una subshell, e possono stare su righe diverse con la pipe come ultimo carattere;
| |
| * comando1 '''2>&1 |''' comando2: pipe che invia standard output e standard error (si veda la parte sui file descriptor) del comando precedente al successivo. Tutti i comandi di una serie di pipe (anche l'ultimo) sono eseguiti in una subshell, e possono stare su righe diverse con la pipe come ultimo carattere.
| |
| | |
| I più comuni comandi esterni impiegati con una pipe (per informazioni sulle loro opzioni si lascia alla lettura della loro pagina di manuale):
| |
| * <code>cat</code> per concatenare più file;
| |
| * <code>head</code> e <code>tail</code> per leggere la parte iniziale e finale di un file;
| |
| * <code>grep</code> per filtrare le righe di un file in base a un dato pattern;
| |
| * <code>sed</code> per modificare le parti corrispondenti a un dato pattern con altre stringhe;
| |
| * <code>cut</code> per selezionare dei campi da ogni riga, ma in base a un determinato carattere delimitatore (di default la tabulazione), conteggiato anche se ripetuto;
| |
| * <code>awk</code> per selezionare dei campi da ogni riga, separandoli in base a spazi e tabulazioni (ignorando quelli consecutivi). Questa è la sua funzione base, ma <code>awk</code> è un vero e proprio linguaggio di programmazione, che se padroneggiato può sostituire le funzionalità di buona parte degli altri comandi;
| |
| * <code>sort</code> e <code>uniq</code> per ordinare le righe in base a determinati campi e saltare quelle doppie;
| |
| * <code>wc</code> per conteggiare il numero di caratteri, parole e/o linee;
| |
| * <code>tr</code> per rimuovere o trasformare i caratteri di una data classe.
| |
| | |
| Per esempio:
| |
| <pre>
| |
| # filtra le occorrenze di video nel ring buffer del kernel
| |
| dmesg | grep -i video # -i per ignore-case (ignora maiuscole/minuscole)
| |
| | |
| # stampa il gateway utilizzato
| |
| ip route | # stampa la tabella di routing
| |
| grep "^default" | # filtra solo la riga iniziante con default
| |
| awk "{ print \$3 }" # stampa il terzo campo ($3 non dev'essere espanso dalla shell)
| |
| </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 riservato ai soli comandi 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=$'\000' # SBAGLIATO: $var è vuota
| |
| var=$'X\000X' # SBAGLIATO: $var contiene X (solo la prima!)
| |
| var=$(printf %s\000%s X X) # SBAGLIATO: $var contiene XX
| |
| </pre>
| |
| Si noti che mentre è rimosso dalle espansioni, nelle assegnazioni normali viene interpretato come carattere di fine stringa, con il risultato che anche tutto ciò che segue viene tralasciato.
| |
| | |
| ====Nomi di file con caratteri non comuni====
| |
| Questo carattere è utile perché nemmeno i file possono averlo nel proprio nome, mentre invece permettono caratteri jolly (*, ?, ...), come 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 i file trovati 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
| |
| | |
| printf %s\\n "La directory prova contiene ${num_file} file" # restituisce 2 invece di 1
| |
| | |
| # forma corretta (ma non la più efficiente, è solo per esemplificare l'uso del carattere)
| |
| 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
| |
| | |
| printf %s\\n "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>
| |
| | |
| ====Comando find e carattere ASCII n. 0====
| |
| 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 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>.
| |
| | |
| Con '''bash''' (non ''POSIX'') esiste un metodo per trattare indirettamente il carattere ASCII n. 0 anche con i comandi interni della shell, tramite l'istruzione <code>read</code> e l'opzione per impostare il carattere come delimitatore, così da replicare la funzionalità di <code>xargs -0</code>. In questo modo il carattere non verrà assegnato alle variabili, ma sarà usato all'interno di un ciclo per delimitare ogni valore dal successivo, permettendo la lettura dell'output generato da <code>find</code> (con <code>-print0</code>):
| |
| <pre>
| |
| find /percorso -opzione1 ... -opzioneN -print0 |
| |
| while read -d $'\000' file
| |
| do
| |
| # posso usare "$file"
| |
| ...
| |
| done
| |
| </pre>
| |
| Si ricorda però che tutto il blocco <code>while</code>, facendo parte di una pipe, è eseguito in una subshell. E che quindi tutte le variabili sono reimpostate al loro valore precedente al termine del blocco.
| |
| | |
| È invece '''sempre sbagliato''', come soluzione generale se i nomi di file non seguono convenzioni note a priori, utilizzare l'espansione di comando con <code>find</code> all'interno di un ciclo <code>for</code>:
| |
| <pre>
| |
| for file in $(find ...) # NO!
| |
| </pre>
| |
| | |
| ==Concatenazione e blocchi di comandi==
| |
| Più comandi, anche contenenti redirezioni, possono essere concatenati per formarne di più complessi. L'operatore di concatenazione può essere anche l'ultimo di una riga, per facilitare la leggibilità del codice.
| |
| | |
| ; <code>;</code> : separatore di comandi, con cui un comando verrà eseguito a prescindere dal successo del precedente (in uno script è equivalente a un "a capo" e questa è la concatenazione di default)
| |
| ; <code>&</code> : separatore che esegue il comando precedente in background (ritorna exit status sempre positivo e non riceve input da tastiera), passando al successivo
| |
| ; <code>&&</code> : operatore logico AND, che va posizionato tra due comandi, il secondo dei quali è eseguito solo se il primo ha esito positivo
| |
| Esempio:
| |
| <pre>
| |
| cd /percorso/dir && comando
| |
| </pre>
| |
| | |
| Attenzione invece alla '''pericolosità''' di:
| |
| <pre>
| |
| cd /tmp/tmpdir # cambia la cartella corrente in /tmp/tmpdir
| |
| # ma se fallisce, quello successivo verrebbe eseguito comunque!
| |
| rm -- ./* # cancella tutti i file nella directory corrente
| |
| </pre>
| |
| | |
| ; <code>||</code> : operatore logico OR, il secondo comando è eseguito solo se il primo ha effetto negativo (si può usare anche dopo una sequenza di &&, perché ha priorità inferiore):
| |
| | |
| ; <code>{ ... ; }</code> : esegue un blocco di comandi (dopo l'ultimo servono ";" o un "a capo"). È usata nelle funzioni ed è utile per concatenare && e ||:
| |
| <pre>
| |
| # interrompe la catena se un comando fallisce
| |
| cd /tmp/tmpdir &&
| |
| rm -- ./* &&
| |
| rmdir -- /tmp/tmpdir || {
| |
| # il blocco è eseguito solo se un comando fallisce
| |
| retval=$?
| |
| printf %s\\n "ERRORE (exit status: $retval)" >&2
| |
| exit $retval
| |
| }
| |
| </pre>
| |
| | |
| ; <code>( ... )</code> : esegue il blocco di comandi in una subshell (le variabili vengono ripristinate al loro valore precedente, alla fine del blocco).
| |
| | |
| ===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 introduttiva sul debug).
| |
| | |
| Per evitare che un blocco abbia un exit status diverso da zero, si possono usare le concatenazioni <code>&&</code> e <code>||</code> (oppure un <code>if</code>):
| |
| <pre>
| |
| comando &&
| |
| status=0 || # se corretto
| |
| status=$? # se sbagliato
| |
| </pre>
| |
| | |
| ==Funzioni==
| |
| Una funzione è un raggruppamento di comandi eseguito ogni volta che il nome della funzione è utilizzato come un comando. Per convenzione le definizioni delle funzioni precedono il corpo principale dello script.
| |
| | |
| All'interno del blocco di comandi (il corpo della funzione), le variabili speciali relative agli argomenti passati allo script (<code>$# $1 $2 ... $* $@</code>) fanno riferimento a quelli passati alla funzione.
| |
| | |
| Sintassi della definizione:
| |
| <pre>
| |
| nomefunzione () {
| |
| ...
| |
| }
| |
| </pre>
| |
| I comandi contenuti nel corpo della funzione sono eseguiti ogni volta che nomefunzione (una singola stringa senza spazi con le stesse limitazioni dei nomi delle variabili) è scritto come comando. Si noti che <code>()</code> dopo il nome della funzione serve a identificare l'istruzione composta come una definizione di funzione, e non accetta argomenti al suo interno come altri linguaggi di programmazione, ma resta sempre <code>()</code> invariata.
| |
| | |
| In '''bash''' è possibile premettere <code>function</code> al nome della funzione, anche senza bisogno di <code>()</code>, ma questa possibilità non è prevista da ''POSIX''.
| |
| | |
| Nel corpo di una funzione è possibile utilizzare il modificatore <code>local</code> prima di un'assegnazione per rendere la variabile locale, ossia non accessibile fuori dal corpo della funzione. È bene evitare le variabili globali il più possibile (se non sono costanti), ricorrendo ai passaggi di parametri, per evitare la modifica accidentale di variabili esistenti fuori dalla funzione. Questo modificatore non è previsto da ''POSIX'', dove ogni variabile è globale, ma è comunque supportato da ogni moderna shell compatibile.
| |
| | |
| Il valore di ritorno di una funzione è quello dell'ultimo blocco eseguito. In alternativa è possibile specificarlo all'interno dei blocchi direttamente con la parola riservata <code>return</code> seguito dall'exit status (un valore qualsiasi tra 0, l'unico per "successo", e 255), facendo terminare la funzione immediatamente.
| |
| | |
| Se la funzione deve restituire un valore diverso da successo/insuccesso (o comunque per cui basterebbe l'exit status), è possibile:
| |
| * stamparlo come output, così che sia assegnabile a una variabile con l'espansione di comando, ma soltanto se non contiene caratteri non ammissibili (il carattere ASCII n. 0 e possibili "a capo" finali, che verrebbero rimossi). Si noti che questo metodo '''non''' è possibile in generale per i nomi di file, a meno che non seguano convenzioni note a priori;
| |
| * stamparlo come output seguito da un carattere qualsiasi (per esempio X), così che sia assegnabile a una variabile con l'espansione di comando, rimuovendo in seguito il carattere finale in più. Con questo metodo è possibile passare nomi di file qualsiasi, ma al solito non il carattere ASCII n. 0;
| |
| * utilizzare una variabile globale, eventualmente con il nome della funzione per evitare doppioni (per esempio: return_nomefunzione), contenente il valore da restituire nella funzione. Si noti che anche in questo caso il carattere ASCII n. 0 non può essere assegnato.
| |
| | |
| {{Warningbox | Esiste anche la possibilità di ricorrere a <code>eval</code>, ma il suo uso non è trattato in questa guida per la sua potenziale '''pericolosità''': possibile <code>code injection</code> e <code>privilege escalation</code>, se l'input non è controllato (''sanitized''). Su '''bash''' è molto meglio ricorrere all'espansione di parametro per l'accesso indiretto, per accedere a una variabile il cui nome è contenuto in un'altra; e ad array associativi per gli altri casi.}}
| |
| | |
| =File descriptor=
| |
| Su UNIX e Unix-like ogni processo che non è avviato in background ha di default tre '''file descriptor''', nella forma di identificativi interi:
| |
| * 0 ('''stdin'''), lo ''standard input'', da cui si leggono gli input (di default quanto scritto dalla tastiera sul terminale associato);
| |
| * 1 ('''stdout'''), lo ''standard output'', a cui si inviano tutti i messaggi prodotti (di default sul terminale associato);
| |
| * 2 ('''stderr'''), lo ''standard error'', a cui si inviano tutti i messaggi di errore prodotti (di default sul terminale associato).
| |
| Lo standard input è chiuso per i processi avviati in background.
| |
| | |
| Si chiamano ''file descriptor'' perché sono identificativi che fanno riferimento a un file; e infatti perfino i dispositivi, anche virtuali come il terminale, sono considerati dei file. Questo permette la possibilità di associare in modo trasparente questi file descriptor standard anche a file qualsiasi, oltre che ad altri file descriptor, in modo da ridirigerne il contenuto. E disporre di due diversi file descriptor per l'output prodotto da un comando e i messaggi di errore, permette di disabilitare anche solo uno dei due, o di salvarli su due file diversi.
| |
| | |
| ==Redirezioni==
| |
| Alcune comuni redirezioni, da scriversi dopo un comando (la stringa ''file'' può essere anche una variabile quotata):
| |
| * '''< file''' collega lo standard input al file, in modo da leggerne il contenuto. Il file descriptor è implicito, ma sarebbe equivalente scrivere '''0< file''';
| |
| * '''> file''' dopo un comando ne scrive lo standard output sul file (troncandolo, se esiste). Si noti che il file descriptor è implicito, ma sarebbe equivalente scrivere '''1> file''';
| |
| * '''>> file''' (''append'') aggiunge il contenuto dello standard output al file (creandolo, se non esiste). Il file descriptor è implicito, ma sarebbe equivalente scrivere '''1>> file''';
| |
| * '''2> file''' è equivalente a '''> file''', ma qui si specifica di ridirigere lo standard error anziché lo standard output sul file (con ''append'': '''2>> file''');
| |
| * '''>&2''' scrive lo standard output sullo standard error. Il file descriptor dello standard output è implicito, mentre quello alla destra dev'essere preceduto da <code>&</code>, ma sarebbe equivalente scrivere '''1>&2''';
| |
| * '''2>&1''' scrive lo standard error sullo standard output;
| |
| * '''&> file''' (non ''POSIX'', abbreviazione per: '''> file 2>&1''') invia standard output ed error sul file (con ''append'': '''&>> file''');
| |
| * '''<&-''' chiude lo standard input. Il file descriptor è implicito, ma sarebbe equivalente scrivere '''0<&-''';
| |
| * '''>&-''' chiude lo standard output. Il file descriptor è implicito, ma sarebbe equivalente scrivere '''1>&-''';
| |
| * '''2>&-''' chiude lo standard error.
| |
| | |
| Per evitare la scrittura a schermo standard output e/o standard error non vanno chiusi, oppure l'operazione genererebbe un errore (perché il file descriptor relativo non esisterebbe più), ma ridiretti su <code>/dev/null</code>, un file dispositivo la cui esistenza è specificata da ''POSIX'' che non produce mai output e può essere usato per assorbire qualsiasi cosa.
| |
| | |
| Esempi:
| |
| <pre>
| |
| comando &> /dev/null # non stampa niente a schermo, neanche gli errori
| |
| comando > /dev/null 2>&1 # equivalente (POSIX)
| |
| | |
| # si noti la differenza con:
| |
| comando >&- 2>&- # standard output ed error sono chiusi, quindi se
| |
| # venissero usati, l'exit status sarebbe diverso da 0!
| |
| </pre>
| |
| | |
| Una pipe (<code>comando1 '''|''' comando2</code>), già trattata nella sezione sulle istruzioni composte, è anch'essa una forma di redirezione, in cui lo standard output di comando1 diventa lo standard input di comando2.
| |
| | |
| ===Scope della redirezione===
| |
| Si noti che lo ''scope'' (il raggio d'azione) della redirezione non serve soltanto per evitare di scrivere più volte il percorso del file, ma ne influenza anche il significato. In particolare con la redirezione dello standard input (lettura), per garantire che tutte le istruzioni continuino la lettura da dove era rimasta invece che riprenderla sempre dall'inizio, e dello standard output, per garantire che il file non venga troncato da ogni comando ma che i successivi continuino a scrivere in seguito (come se usassero la redirezione con ''append'').
| |
| | |
| Per esempio in genere è '''sbagliato''' scrivere:
| |
| <pre>
| |
| while read riga < file
| |
| do
| |
| # "$riga" contiene *SEMPRE* la prima riga del file
| |
| # quindi il ciclo può essere eseguito per sempre se ha più di una riga!
| |
| | |
| done
| |
| </pre>
| |
| | |
| Mentre quello che si vuole è probabilmente:
| |
| <pre>
| |
| while read riga
| |
| do
| |
| # "$riga" contiene sempre una nuova linea del file
| |
| # il ciclo è eseguito per ogni linea del file
| |
| | |
| done < file
| |
| </pre>
| |
| | |
| Si noti che leggere in questo modo un file ha senso solo per file non binari, che potrebbero contenere anche il carattere ASCII n. 0, che non può essere memorizzato in una variabile. Inoltre l'istruzione <code>read</code> fallisce se non trova un "a capo", per cui l'ultima riga del file è letta all'interno del ciclo soltanto se termina con un "a capo", altrimenti è necessario controllare se è vuota la variabile dopo il ciclo.
| |
| | |
| ==Nuovi file descriptor==
| |
| In aggiunta ai tre file descriptor standard, è possibile aprirne di nuovi, in lettura (<code>FD<...</code>...), in scrittura (<code>FD>...</code>, append: <code>FD>>...</code>) e in lettura/scrittura (<code>FD<>...</code>), dove FD è un intero rappresentante il nuovo file descriptor e al posto dei puntini può esserci sia un file sia un file descriptor già esistente preceduto dal carattere <code>&</code>.
| |
| | |
| È necessario quindi determinare a quale file (o file descriptor, se preceduto da <code>&</code>) il nuovo file descriptor va associato. Ci sono due modi:
| |
| * specificarlo dopo un'istruzione composta, in modo che il file descriptor sia utilizzabile normalmente all'interno;
| |
| * specificarlo con l'istruzione <code>exec</code> senza altri argomenti (o avrebbe un significato diverso).
| |
| | |
| Per usarlo invece, una volta aperto, il file descriptor va scritto subito dopo la redirezione, preceduto dal carattere <code>&</code>.
| |
| | |
| Per esempio:
| |
| <pre>
| |
| {
| |
| # il file descriptor 3 è definito dentro il blocco (in scrittura)
| |
| comando1 >&3 # ridirige lo standard output sul nuovo file descriptor
| |
| comando2
| |
| comando3 >&3 # come per comando1
| |
| } 3> file # apre in scrittura il file descriptor per il contenuto del blocco
| |
| # NOTA: fuori dal blocco il nuovo file descriptor non esiste più
| |
| </pre>
| |
| Sul file scelto sono ridiretti lo standard output di comando1 e comando3. È equivalente a:
| |
| <code>
| |
| comando1 > file # scrittura
| |
| comando2
| |
| comando3 >> file # scrittura con append! (nel blocco è implicito)
| |
| </code>
| |
| | |
| Equivalentemente, con <code>exec</code>:
| |
| <pre>
| |
| exec 3> file # apre il file descriptor in scrittura
| |
| comando1 >&3 # usa il file descriptor
| |
| comando2
| |
| comando3 >&3 # usa il file descriptor
| |
| exec 3>&- # chiude il file descriptor
| |
| </pre>
| |
| Finché un file descriptor non è chiuso, non è garantita la scrittura sul file, ma la scrittura tramite file descriptor è più efficiente.
| |
| | |
| ===Salvare i file descriptor===
| |
| Si noti che <code>exec</code> è equivalente a una redirezione in un blocco, ma la chiusura dei file descriptor aperti dev'essere gestita manualmente. Prima di cambiare quelli standard, per consentirne il successivo ripristino al loro valore originale, vanno salvati in un nuovo file descriptor temporaneo:
| |
| <pre>
| |
| exec 3<&0 # apre un nuovo file descriptor per salvare lo standard input
| |
| exec < file # sovrascrive lo standard input
| |
| read riga # legge la prima riga (se esiste)
| |
| read riga # legge la seconda riga (se esiste)! (e non di nuovo la prima)
| |
| exec <&3 # assegna nuovamente lo standard input al suo valore precedente
| |
| exec 3<&- # chiude il nuovo file descriptor
| |
| </pre>
| |
| si ricordi che invece, senza exec e senza un blocco, una redirezione (di lettura o scrittura senza append) su un singolo comando parte sempre dall'inizio:
| |
| <pre>
| |
| read riga < file # legge la prima riga del file (se esiste)
| |
| read riga < file # legge sempre la prima riga del file (se esiste)!
| |
| </pre>
| |
| | |
| =Segnali=
| |
| Ogni processo in UNIX e Unix-like può ricevere dei segnali da altri processi (se appartengono allo stesso utente oppure da root). Di seguito i principali, tra quelli previsti da ''POSIX'':
| |
| * '''INT''' : è equivalente a <code>Ctrl-c</code> da tastiera, per uno script associato a un terminale (non eseguito in background). L'azione di default è la terminazione;
| |
| * '''QUIT''' : è equivalente a <code>Ctrl-\</code> da tastiera, per uno script associato a un terminale (non eseguito in background). L'azione di default è la terminazione con core dump;
| |
| * '''HUP''' : è equivalente a chiudere il terminale, per uno script associato a un terminale (anche se eseguito in background), o in generale alla morte di un processo padre. L'azione di default è la terminazione;
| |
| * '''TERM''' : è il segnale di terminazione di default. L'azione di default è la terminazione;
| |
| * '''KILL''' : è un segnale di terminazione che non può essere ignorato (si veda trap). L'unica azione che sarà eseguita è la sua terminazione immediata;
| |
| * '''PIPE''' : è equivalente al segnale ricevuto da un processo che invia l'output a una pipe, quando il processo lettore ha terminato. L'azione di default è la terminazione;
| |
| * '''ABRT''' : è il segnale di ''abort''. L'azione di default è la terminazione con core dump;
| |
| * '''STOP''' : è equivalente a <code>Ctrl-z</code> da tastiera, per uno script associato a un terminale (non eseguito in background), ma come KILL non può mai essere ignorato (si veda trap). L'unica azione che sarà eseguita è la sua interruzione immediata;
| |
| * '''CONT''' : è il segnale per continuare l'esecuzione per un processo interrotto. Se il processo non è interrotto, di default il segnale è ignorato;
| |
| * '''TSTP''' : è equivalente a Bloc Scor (o <code>Ctrl-s</code>; per riprendere: <code>Ctrl-q</code>), per bloccare l'output. L'azione di default è interrompere il processo;
| |
| * '''CHLD''' : è il segnale che un processo figlio è terminato (viene inviato automaticamente). Di default è ignorato;
| |
| * '''WINCH''' : è il segnale che la finestra del terminale è stata ridimensionata. Di default è ignorato;
| |
| * '''USR1''' : è un segnale lasciato da definire all'utente. L'azione di default è la terminazione;
| |
| * '''USR2''' : è un segnale lasciato da definire all'utente. L'azione di default è la terminazione.
| |
| | |
| Il ''core dump'' è un dump dello stato (o una sua parte) del processo terminato, a scopo di debug. Può essere limitato e anche disattivato interamente. Se non attivo, l'azione eseguita è equivalente a una terminazione senza core dump.
| |
| | |
| ==Invio e cattura di segnali==
| |
| Alcuni segnali vengono inviati automaticamente, al sussistere di determinate condizioni, ma possono anche essere inviati esplicitamente con il comando <code>kill</code>.<br/>
| |
| Sintassi: <code>kill [ -s SIGNAL ] pid</code><br/>
| |
| Invia un segnale (di default: TERM) al processo con il pid scelto. Si noti che l'invio è asincrono, ossia <code>kill</code> non resta in attesa che il processo con pid scelto effettui l'azione associata al segnale. Di conseguenza il comando ha sempre successo, salvo che il pid non esista o non possa ricevere il segnale (per esempio perché non è dello stesso utente).
| |
| | |
| Le azioni da intraprendere possono essere modificati con l'istruzione <code>trap</code>.<br/>
| |
| Sintassi: <code>trap 'stringa' SIGNAL1 [ ... ]</code><br/>
| |
| Cattura i segnali (se possibile, non lo è per KILL e STOP), con il seguente comportamento:
| |
| * se la stringa è il solo carattere <code>-</code>, le azioni associate alla lista di segnali sono impostate nuovamente come quelle di default per i segnali;
| |
| * se la stringa è vuota, i segnali verranno ignorati;
| |
| * se la stringa è il nome di una funzione, verrà eseguita ogni volta che uno dei segnali viene ricevuto. L'azione normale è sovrascritta, quindi se è necessario preservarla dopo la funzione, dovrà occuparsene la funzione stessa (per esempio di uscire con <code>exit</code> dopo aver effettuato la pulizia);
| |
| * il segnale può essere '''EXIT''', che ha significato solo per questa istruzione, in tal caso la funzione sarà eseguita alla fine dello script, che può essere causata anche da segnali (con l'unica eccezione di KILL), purché lo script non termini con un <code>exec</code> seguito da un eseguibile.
| |
| | |
| {{Warningbox | Al posto di 'stringa' nell'istruzione <code>trap</code> può esserci un qualsiasi comando, ma si consiglia l'uso di una funzione sia per chiarezza del codice, sia soprattutto per evitare la doppia interpretazione con possibili espansioni in fase di definizione di <code>trap</code> prima e di esecuzione del comando poi. Un uso diverso ha la stessa pericolosità di <code>eval</code>, e può portare a <code>code injection</code> e <code>privilege escalation</code>.}}
| |
| | |
| Un esempio classico di <code>trap</code>:
| |
| <pre>
| |
| clean () {
| |
| # funzione di pulizia
| |
| ...
| |
| }
| |
| | |
| trap 'clean' EXIT # la funzione clean è eseguita se si riceve un segnale di terminazione
| |
| ...
| |
| if comando; then
| |
| exec eseguibile # clean NON è eseguita dopo exec e un eseguibile
| |
| fi
| |
| ...
| |
| exit 0 # clean è eseguita anche con exit
| |
| </pre>
| |
| In caso di esecuzione di una subshell le azioni da intraprendere in seguito alla ricezione di un segnale vengono reimpostate al loro valore di default, ma i segnali ignorati continuano a restare ignorati.
| |
| | |
| =Link=
| |
| * [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.
| |
| | |
| {{Autori
| |
| |Autore=[[Utente:TheNoise|~ The_Noise]] (in Bash tips)
| |
| |Verificata_da=
| |
| :[[Utente:S3v|S3v]] (in Bash tips)
| |
| :[[Utente:HAL 9000|HAL 9000]] 18:15, 21 lug 2014 (CEST)
| |
| |Estesa_da=
| |
| :[[Utente:S3v|S3v]] (in Bash tips)
| |
| :[[Utente:HAL 9000|HAL 9000]]
| |
| |Numero_revisori=2
| |
| }}
| |
| | |
| [[Categoria:Bash]][[Categoria:Bash_Scripting]]
| |
