[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home] [volume] [parte]


Capitolo 161.   Strumenti per la realizzazione di script di shell

Lo script di shell è un programma molto semplice, che di solito ha solo lo scopo di automatizzare delle operazioni banali, ma ripetitive. Tuttavia, con l'uso di programmi di servizio realizzati appositamente per questi scopi, si possono costruire degli script piuttosto sofisticati con poca fatica.

161.1   Scansione delle opzioni della riga di comando

Se si realizza uno script che deve essere richiamato fornendogli degli argomenti (dei parametri) sotto forma di opzione, come si è abituati con i programmi di servizio comuni, può essere conveniente l'utilizzo di programmi o comandi appositi. Tradizionalmente si fa riferimento a getopt, del quale esistono però diverse interpretazioni; in particolare, la shell Bash fornisce il comando interno getopts (simile, ma non compatibile con getopt), descritto nella sezione 144.4.1. È importante osservare che anche tra una distribuzione GNU/Linux e l'altra ci possono essere differenze tra i programmi di servizio getopt.

161.1.1   Versione tradizionale di «getopt»

Il programma di servizio getopt tradizionale ha la sintassi seguente:

getopt stringa_di_opzioni parametro...

La stringa di opzioni è un elenco di lettere che rappresentano le opzioni ammissibili; se ci sono opzioni che richiedono un argomento, le lettere corrispondenti di questa stringa devono essere seguite dal simbolo due punti (:). Gli argomenti successivi sono i valori dei parametri da analizzare. Lo scopo del programma è solo quello di controllare che tutto sia in ordine e di mettere a posto ciò che è possibile sistemare, emettendo l'elenco delle opzioni, nel modo «corretto». Per esempio:

getopt ab:c -a uno -b due -c tre quattro[Invio]

Potrebbe restituire il testo seguente:

-a -b due -c -- uno tre quattro

Infatti, avendo utilizzato la definizione ab:c, è stato stabilito che solo l'opzione -b ha un argomento, per cui, l'argomento uno è stato spostato alla fine delle opzioni, dopo il trattino doppio (--).

Se il programma getopt di cui si dispone è aderente strettamente alle specifiche POSIX, il risultato che si ottiene è diverso, dal momento che la scansione termina nel momento in cui si trova il primo argomento che non riguarda le opzioni:

-a -- uno -b due -c tre quattro

L'esempio seguente dovrebbe chiarire in che modo si può utilizzare getopt per scandire gli argomenti della riga di comando:

#!/bin/sh
# scansione_1.sh

# Si raccoglie la stringa generata da getopt.
STRINGA_ARGOMENTI=`getopt ab:c "$@"`

# Si trasferisce nei parametri $1, $2,...
eval set -- "$STRINGA_ARGOMENTI"

while true ; do
    case "$1" in
        -a) echo "Opzione a"
            shift
            ;;
        -b) echo "Opzione b, argomento «$2»"
            shift 2
            ;;
        -c) echo "Opzione c"
            shift
            ;;
        --) shift
            break
            ;;
        *)  echo "Errore imprevisto!"
            exit 1
            ;;
        esac
done

echo "Argomenti rimanenti:"
for argomento in "$@"
do
    echo "$argomento"
done

In pratica, si comprende che lo scopo di getopt è solo quello di fare un po' di ordine tra le opzioni e di distinguere le opzioni dal resto. Supponendo che il nome dello script sia scansione_1.sh, se si utilizza come nell'esempio già visto, si dovrebbe ottenere il risultato seguente:

./scansione_1.sh -a uno -b due -c tre quattro[Invio]

Opzione a
Opzione b, argomento «due»
Opzione c
Argomenti rimanenti:
uno
tre
quattro

Se invece getopt è strettamente aderente alle specifiche POSIX, il risultato cambia come segue:

Opzione a
Argomenti rimanenti:
uno
-b
due
-c
tre
quattro

161.1.2   Il funzionamento di «getopt» nella versione dei programmi di servizio Linux

I programmi di servizio Linux si compongono anche di una versione di getopt(1) un po' più evoluta dello standard, che comunque è compatibile con il passato. È ammissibile l'uso della stessa sintassi vista nella sezione precedente e in particolare si può anche forzare l'aderenza alle specifiche POSIX definendo la variabile di ambiente POSIXLY_CORRECT. Questa edizione di getopt è in grado di identificare anche le opzioni «lunghe». Oltre allo schema sintattico già visto, si può utilizzare in particolare quello seguente:

getopt [opzioni_di_getopt] -o|--options stringa_di_opzioni_corte \
  \     [opzioni_di_getopt] -- parametro_da_scandire...

In pratica, questa versione di getopt può avere delle opzioni per conto proprio, che ne regolano il funzionamento, tra le quali -o è obbligatoria, dal momento che il suo argomento è proprio la stringa che definisce quali opzioni possono essere presenti nei parametri. Eventualmente, per indicare opzioni lunghe, si utilizza l'opzione -l.

La stringa che definisce le opzioni corte, si comporta fondamentalmente come già spiegato nella sezione precedente. In particolare, se si usano due volte i due punti (::), si specifica che l'opzione ha un argomento facoltativo e non obbligatorio. La stringa che definisce le opzioni lunghe è simile a quella delle opzioni corte, con la differenza che, dovendo indicare dei nomi e non solo delle lettere singole, questi sono separati attraverso una virgola; per quanto riguarda l'uso dei due punti, la modalità è la stessa.

Questa versione di getopt ha anche la particolarità di essere in grado di proteggere gli argomenti che ne hanno bisogno, ma per arrivare a questo deve sapere con quale shell si sta operando. Infatti, dal momento che getopt restituisce una stringa che poi deve essere scandita nuovamente, se un argomento contiene caratteri particolari che richiedono una qualche forma di protezione (come gli spazi), è necessario che venga fatta una trasformazione opportuna, che non può essere unica per tutte le situazioni. In condizioni normali, il risultato che si ottiene è adatto per Bash, altrimenti occorre utilizzare l'opzione -s.

Tabella 161.6. Alcune opzioni.

Opzione Descrizione
-o stringa_di_opzioni_corte
--options stringa_di_opzioni_corte
Definisce le opzioni normali che devono essere cercate tra i parametri, specificando anche se queste hanno un argomento, obbligatorio o facoltativo.
-l stringa_di_opzioni_lunghe
--longoptions \
  \stringa_di_opzioni_lunghe
Definisce le opzioni lunghe che devono essere cercate tra i parametri, specificando anche se queste hanno un argomento, obbligatorio o facoltativo.
-s {sh|bash|csh|tcsh}
--shell {sh|bash|csh|tcsh}
Definisce il tipo di shell che si sta utilizzando, permettendo di definire il modo migliore per proteggere i caratteri che richiedono questo tipo di accortezza.
-n nome_del_programma
--name nome_del_programma
Dal momento che getopt può segnalare gli errori, con questa opzione è possibile definire il nome del programma al quale attribuire l'errore generato.

Come esempio viene mostrata una variante dello script proposto nella sezione precedente, dove si scandiscono anche le opzioni lunghe e l'ultima ha un argomento facoltativo.

#!/bin/sh
# scansione_1.sh

# Si raccoglie la stringa generata da getopt.
STRINGA_ARGOMENTI=`getopt -o ab:c:: -l a-lunga,b-lunga:,c-lunga:: -- "$@"`

# Si trasferisce nei parametri $1, $2,...
eval set -- "$STRINGA_ARGOMENTI"

while true ; do
    case "$1" in
        -a|--a-lunga)
            echo "Opzione a"
            shift
            ;;
        -b|--b-lunga)
            echo "Opzione b, argomento «$2»"
            shift 2
            ;;
        -c|--c-lunga)
            case "$2" in
                "") echo "Opzione c, senza argomenti"
                    shift 2
                    ;;
                *)  echo "Opzione c, argomento «$2»"
                    shift 2
                    ;;
            esac
            ;;
        --) shift
            break
            ;;
        *)  echo "Errore imprevisto!"
            exit 1
            ;;
        esac
done

echo "Argomenti rimanenti:"
for argomento in "$@"
do
    echo "$argomento"
done

Supponendo che il nome dello script sia scansione_2.sh, se si utilizza come nell'esempio seguente,

./scansione_2.sh -auno -bdue -ctre quattro[Invio]

oppure

./scansione_2.sh --a-lunga=uno --b-lunga=due --c-lunga=tre \
  \                 quattro
[Invio]

si dovrebbe ottenere il risultato seguente:

Opzione a
Opzione b, argomento «due»
Opzione c, argomento «tre»
Argomenti rimanenti:
uno
quattro

Tuttavia, se utilizzando le opzioni corte, gli argomenti di queste non vengono attaccati alle lettere rispettive, come nell'esempio seguente,

./scansione_2.sh -a uno -b due -c tre quattro[Invio]

gli argomenti facoltativi non vengono presi in considerazione:

Opzione a
Opzione b, argomento «due»
Opzione c, senza argomenti
Argomenti rimanenti:
uno
tre
quattro

161.2   File temporanei

Quando si realizzano degli script, si ha spesso la necessità di realizzare dei file temporanei, magari solo per accumulare il risultato di un'elaborazione senza tentare di fare altri tipi di acrobazie. Il programma di servizio che si usa per queste cose è tempfile: (2)

tempfile [opzioni]

Nella maggior parte dei casi, tempfile viene usato senza argomenti, ottenendo la creazione di un file vuoto nella directory temporanea (/tmp/), con permessi normali (lettura e scrittura per tutti, meno quanto filtrato dalla maschera dei permessi), ottenendo il percorso assoluto di questo file dallo standard output.

Tabella 161.10. Alcune opzioni.

Opzione Descrizione
-d directory
--directory directory
Se non si vuole usare la directory temporanea standard, si può specificare la directory di destinazione del file temporaneo con questa opzione.
-m modalità_dei_permessi
--mode modalità_dei_permessi
Se si vuole evitare che il file temporaneo che viene creato abbia dei permessi di accesso troppo ampi, si può utilizzare questa opzione per stabilire qualcosa di diverso.

Segue la descrizione di alcuni esempi.

161.3   Ambiente

In situazioni determinate, può essere importante avviare un programma, o un altro script con un insieme di variabili di ambiente diverso da quello che si erediterebbe normalmente. Per questo si può usare il programma di servizio env:(3)

env [opzioni] comando [argomenti_del_comando]

Come si può intuire, le opzioni di env servono a eliminare o ad aggiungere delle variabili di ambiente, senza interferire con l'ambiente dello script.

Tabella 161.12. Alcune opzioni.

Opzione Descrizione
-u variabile
--unset=variabile
Permette di eliminare la variabile di ambiente nominata.
-
-i
--ignore-environment
Azzera completamente tutto l'ambiente.

A titolo di esempio, si supponga di avere due script: nel primo viene dichiarata la variabile di ambiente CIAO e viene chiamato il secondo eliminando questa variabile dall'ambiente; il secondo script si limita a mostrare il contenuto di questa variabile, se è disponibile.

#!/bin/sh
# ./primo.sh
CIAO="ciao a tutti"
export CIAO
env -u CIAO ./secondo.sh
echo $CIAO
#!/bin/sh
# ./secondo.sh
echo $CIAO

Il risultato è che funziona solo la visualizzazione della variabile che avviene con il comando echo del primo script, perché nel secondo non è disponibile. Sarebbe stato diverso se il primo e unico script fosse stato quello seguente:

#!/bin/sh
# ./primo.sh
CIAO="ciao a tutti"
export CIAO
env -u CIAO echo $CIAO
echo $CIAO

In questo caso, anche se il comando echo viene avviato senza la disponibilità della variabile CIAO, si otterrebbe ugualmente la sua visualizzazione, dal momento che l'espansione della stessa avviene prima della chiamata del programma env.

161.4   Interazione con l'utente

Spesso, la realizzazione di uno script di shell interattivo, è molto difficile; o meglio, è difficile realizzare qualcosa di pratico da usare. La shell offre il comando interno read, per leggere ciò che viene inserito attraverso la tastiera, ma questo permette di ottenere un'interazione molto banale, a livello di riga di comando. In alternativa si possono usare dei programmi realizzati appositamente per abbellire gli script, come nel caso di dialog.

161.4.1   Utilizzo di «read»

Di norma, read è un comando interno delle shell POSIX, anche se potrebbe essere disponibile un programma di servizio equivalente, da utilizzare con una shell differente. Il modello sintattico seguente rappresenta una semplificazione che dovrebbe essere compatibile in generale con le shell POSIX:

read [-p invito] [variabile...]

Il comando read potrebbe essere utilizzato da solo, senza argomenti; in questo caso servirebbe soltanto per attendere la pressione del tasto [Invio], permettendo all'utente di leggere un'informazione che appare sullo schermo, prima di proseguire con altre operazioni.

L'opzione -p dovrebbe essere abbastanza chiara: permette di definire una stringa di invito all'inserimento di qualcosa. Infine, i nomi che vengono collocati in coda alla riga di comando, rappresentano altrettante variabili di ambiente che vengono create appositamente, assegnando loro le parole inserite attraverso read; in particolare, l'ultima variabile dell'elenco raccoglie tutte le parole rimanenti.

#!/bin/sh

echo -n "Inserisci una frase: "
read UNO DUE TRE
echo "La prima parola inserita è «$UNO»"
echo "La seconda parola inserita è «$DUE»"
echo "Il resto della frase è «$TRE»"

L'esempio dovrebbe permettere di capire il funzionamento di read. Si osservi in particolare il fatto che l'invito viene ottenuto attraverso il comando echo, utilizzato con l'opzione -n. Supponendo che si tratti dello script read.sh:

./read.sh[Invio]

Inserisci una frase: ciao come stai? io sto bene[Invio]

La prima parola inserita è «ciao»
La seconda parola inserita è «come»
Il resto della frase è «stai? io sto bene»

161.4.2   Utilizzo di «select»

La shell Korn e la shell Bash offrono una struttura di controllo particolare, utile per la selezione interattiva di un elemento da un elenco. Si tratta di select, la cui sintassi si riassume nello schema sintattico seguente:

select variabile [in valore...]
do
    lista_di_comandi
done

L'elenco di parole che segue in viene espanso, generando una lista di elementi. L'insieme delle parole espanse viene emesso attraverso lo standard error, ognuna preceduta da un numero. Se in (e i suoi argomenti) viene omesso, vengono utilizzati i parametri posizionali. In pratica è come se venisse usato in $@.

Dopo l'emissione dell'elenco, viene mostrato l'invito contenuto nella variabile PS3 e viene letta una riga dallo standard input. Se la riga consiste del numero corrispondente a una delle parole mostrate, allora viene assegnato alla variabile indicata dopo select la parola corrispondente. Se la riga è vuota (probabilmente è stato premuto soltanto [Invio]), l'elenco e l'invito vengono emessi nuovamente. Se viene letto il codice corrispondente a EOF ([Ctrl d]), il comando termina. Qualsiasi altro valore letto fa sì che la variabile sia posta al valore della stringa nulla. La riga letta viene salvata nella variabile REPLY. La lista di comandi che segue do viene eseguita dopo ciascuna selezione fino a che non viene incontrato un comando break o return.

Il valore restituito da select è quello dell'ultimo comando eseguito all'interno della lista do, oppure zero se nessun comando è stato eseguito.

Viene mostrato nuovamente lo stesso esempio già presentato in occasione della descrizione di select fatta nell'ambito dei capitoli dedicati a Bash: fa apparire un menù composto dagli argomenti fornitigli; a ogni selezione mostra quello scelto.

#!/bin/sh
select i in $*
do
    echo "hai selezionato $i premendo $REPLY"
    echo ""
    echo "premi Ctrl+c per terminare"
done

L'esempio seguente proviene dagli script di nanoLinux II 1998 e rappresenta la selezione del nome di un'interfaccia di rete, che viene accumulato nella variabile di ambiente INTERFACCIA:

echo "Selezionare l'interfaccia."
select i in eth0 eth1 eth2 plip0 plip1 plip2
do
    INTERFACCIA=$i
    break
done

161.4.3   Dialog e simili

Dialog e altri programmi più o meno compatibili, hanno lo scopo di gestire effetti più appariscenti in uno script di shell, interagendo con l'utilizzatore attraverso schermate colorate e finestre di dialogo, che a seconda dei casi sono adatte allo schermo a caratteri, oppure richiedono la grafica.(4) (5) (6) (7)

dialog [opzioni_generali] [definizione_del_tipo_di_interazione]
whiptail [opzioni_generali] [definizione_del_tipo_di_interazione]
Xdialog [opzioni_generali] [definizione_del_tipo_di_interazione]
gdialog [opzioni_generali] [definizione_del_tipo_di_interazione]

Si può intuire che il programma «standard» è Dialog, che è fatto per i terminali a caratteri e utilizza la libreria Ncurses.(8) Il programma Whiptail, è una rivisitazione, fatta sempre per i terminali senza grafica, ma usa la libreria Newt. (9) Gli altri programmi si usano con la grafica.

La riga di comando distingue due tipi di opzioni: quelle che hanno valore in senso generale influenzando il comportamento del programma e quelle che definiscono un tipo di interazione con l'utilizzatore. Nella documentazione originale, queste ultime sono definite box-options, perché si riferiscono ai riquadri che vengono mostrati sullo schermo. Evidentemente, si può utilizzare al massimo una sola opzione che definisca una finestra di dialogo.

Dovendo definire delle finestre su uno schermo a caratteri, le opzioni che permettono di descriverle, fanno riferimento a delle dimensioni in caratteri. Questi valori non possono essere omessi e in caso si voglia fare riferimento alle dimensioni ottimali, in base alla disponibilità dello schermo, basta indicare il valore zero, tenendo conto però che questa possibilità non funziona sempre.

La documentazione di Dialog in particolare è accompagnata da esempi di script più completi di quelli che si vedono qui. Vale la pena di studiarli per apprendere bene il funzionamento di questi programmi. In generale, dovrebbero trovarsi a partire dalla directory /usr/share/doc/dialog/.

Tabella 161.20. Alcune opzioni generali.

Opzione Descrizione
--clear
Se si utilizza questa opzione generale, si fa in modo di ripulire lo schermo prima di mostrare il riquadro della finestra di dialogo. Nelle versioni grafiche del programma, viene ignorata.
--title titolo_finestra
Permette di dare un titolo alla finestra di dialogo.
--backtitle sottotitolo_finestra
Permette di dare un titolo allo sfondo, che appare nella parte superiore dello schermo, al di fuori della finestra di dialogo relativa. Alcune realizzazioni del programma, ignorano questa opzione.
--separate-output
Questa opzione altera il modo in cui viene emesso il risultato di un'interazione. Per la precisione serve quando si utilizza una finestra di dialogo contenente una lista di caselline da barrare. Si veda a questo proposito l'opzione --checklist.
--fb
Questa opzione riguarda esclusivamente Whiptail e consente di visualizzare pulsanti grafici più appariscenti del normale.

Tabella 161.21. Alcune opzioni per la definizione della finestra di dialogo.

Opzione Descrizione
--yesno testo altezza larghezza
Fa apparire una finestra di dialogo molto semplice, in cui viene mostrato il testo indicato, al quale si deve rispondere con un «sì», oppure con un «no», rappresentati da due pulsanti grafici: <Yes> e <No>. Se la risposta è «sì», viene restituito Vero (il valore zero), altrimenti si ottiene Falso (un valore diverso da zero).
--msgbox testo altezza larghezza
La finestra di dialogo che si ottiene, serve a mostrare un messaggio, per il quale si attende la conferma da parte dell'utilizzatore. Alla base della finestra appare il pulsante grafico <Ok>, selezionando il quale si conclude il funzionamento del programma.
--infobox testo altezza larghezza
In questo caso, più che di una finestra di dialogo, si tratta di una finestra contenente un messaggio, per il quale non viene attesa alcuna azione da parte dell'utente. In pratica, il programma mostra il messaggio e termina immediatamente di funzionare. Può essere paragonato a un comando echo, molto più appariscente.
--inputbox testo \
  \altezza larghezza \
  \[risposta_predefinita]
Questa finestra di dialogo permette all'utilizzatore di inserire un testo libero, dove eventualmente è possibile mostrare inizialmente una risposta predefinita. Alla base della finestra appaiono i pulsanti grafici <Ok> e <Cancel>. Se si seleziona <Ok>, si conferma il testo inserito, che viene emesso attraverso lo standard output; altrimenti, con <Cancel>, non si ottiene alcun risultato.
--passwordbox testo \
  \altezza larghezza \
  \[risposta_predefinita]
Questa finestra di dialogo è analoga a quella che si ottiene con --inputbox, con la differenza che non si vede quanto digitato dall'utente. Funziona solo con Dialog e Whiptail.
--password inputbox testo \
  \altezza larghezza
Questa finestra di dialogo è analoga a quella che si ottiene con --inputbox, con la differenza che non si vede quanto digitato dall'utente. Funziona solo con Xdialog e Gdialog.
--textbox file altezza larghezza
Questa finestra di dialogo serve a permettere la visualizzazione di un file di testo. L'utilizzatore può usare intuitivamente i tasti [Pagina su], [Pagina giù] e i tasti freccia, anche per degli spostamenti orizzontali. Alla base della finestra si vede il pulsante grafico <Exit>, che permette di concludere la visualizzazione.
È il caso di annotare un problema relativo agli stop di tabulazione. Se il testo da mostrare ne contiene, è molto probabile che la visualizzazione di questo avvenga in modo disallineato rispetto alla realtà. Ciò dipende dal fatto che la visualizzazione avviene all'interno di un'area incorniciata, per cui gli stop di tabulazione si trovano spostati rispetto alla loro posizione originale. In questi casi, converrebbe rielaborare il file da visualizzare attraverso il programma expand, prima di passare alla visualizzazione.
--menu testo \
  \altezza larghezza altezza_menù \
  \[elemento descrizione]...
Questo tipo di finestra di dialogo comincia a essere un po' più complicato. Il suo scopo è quello di mostrare un menù, composto da coppie di valori, dove il primo è ciò che viene restituito attraverso lo standard output nel caso di selezione e il secondo è la sua descrizione. Il menù, ovvero l'elenco di queste voci, può avere un'altezza determinata, ma anche in questo caso si può stabilire una larghezza predefinita utilizzando semplicemente lo zero. Sulle voci del menù appare un cursore in forma di barra di scorrimento, che può essere spostata con i tasti freccia o i tasti pagina, mentre alla base della finestra appaiono i pulsanti grafici <Ok> e <Cancel>. Selezionando <Ok>, il programma termina emettendo la stringa corrispondente all'elemento che si trova evidenziato dalla barra di scorrimento; selezionando <Cancel> non si ottiene alcun risultato.
--checklist testo \
  \altezza larghezza altezza_menù \
  \[elemento descrizione on|off]...
Questo tipo di finestra di dialogo è simile a quella che si ottiene con l'opzione --menu. La differenza fondamentale sta nel fatto che in questo caso è possibile selezionare più voci, attraverso delle caselle di selezione: anche qui c'è una barra di scorrimento e quando ci si trova sopra la voce desiderata, la [barra spaziatrice] mette o toglie il segno di selezione. A differenza dell'opzione --menu, le voci del menù possono essere già attivate o meno, pertanto si aggiunge la parola chiave on oppure off.
La particolarità di questo tipo di selezione, richiede attenzione nel modo in cui deve essere interpretato il risultato emesso attraverso lo standard output. Infatti, in condizioni normali, vengono restituite le stringhe corrispondenti alle voci di menù selezionate, delimitate tra apici doppi, o in altro modo, a seconda del programma usato. Se questo sistema crea difficoltà, si può abbinare l'uso dell'opzione --separate-output perché queste stringhe siano separate dal codice di interruzione di riga, senza l'uso di delimitatori di altro tipo.
--radiolist testo \
  \altezza larghezza altezza_menù \
  \[elemento descrizione on|off]...
Questo tipo di finestra di dialogo si comporta in modo simile a quella ottenuta con l'opzione --checklist. La differenza sta nel fatto che si può selezionare solo una voce dall'elenco, per cui il risultato non comporta difficoltà nell'interpretazione. Evidentemente, si può preselezionare solo una delle voci del menù.

Gli esempi seguenti mostrano diverse situazioni, dove si mette anche a confronto il risultato che si ottiene tra i vari programmi.

#/bin/sh

if dialog --title "Domanda" --yesno "Ti piace Dialog?" 0 0
then
    echo "Ottimo!"
else
    echo "Peccato :-)"
fi

In questo script, viene mostrata la finestra di dialogo che si vede nella figura 161.23; in base alla scelta affermativa o negativa, si ottiene la visualizzazione di un messaggio differente.

Figura 161.23. Esempio del funzionamento della finestra di dialogo ottenuta con l'opzione --yesno.

.------- Domanda -------.
|   Ti piace Dialog?    |
|-----------------------|
| < Yes >      <  No  > |
`-----------------------'

Seguono altre figure, dove si vede l'uso di altri programmi equivalenti.

Figura 161.24. Esempio con Xdialog e con Gdialog.

Xdialog     Gdialog

Lo script successivo mostrata la finestra di dialogo che si vede nella figura 161.26 e, in base alla scelta del colore, si ottiene il numero corrispondente.

#!/bin/sh

RISULTATO=`tempfile`

dialog --title "Menu'" \
--menu "Scegli il colore che preferisci" \
0 0 0 \
0 nero \
1 marrone \
2 rosso \
3 arancio \
4 giallo \
5 verde \
6 blu \
7 viola \
8 grigio \
9 bianco 2> $RISULTATO

echo `cat $RISULTATO`

Si osservi che è stato evitato l'uso di una lettera accentata, perché alcune delle varie interpretazioni del programma, non sono in grado di gestire altro che la codifica ASCII pura e semplice.

Figura 161.26. Esempio del funzionamento della finestra di dialogo ottenuta con l'opzione --menu.

.------------- Menu' -------------.
| Scegli il colore che preferisci |
| .-----------------------------. |
| |         0  nero             | |
| |         1  marrone          | |
| |         2  rosso            | |
| |         3  arancio          | |
| |         4  giallo           | |
| |         5  verde            | |
| |         6  blu              | |
| |         7  viola            | |
| |         8  grigio           | |
| |         9  bianco           | |
| `-----------------------------' |
|---------------------------------|
|     <  OK  >      <Cancel>      |
`---------------------------------'

Figura 161.27. Esempio con Xdialog e con Gdialog.

Xdialog Gdialog

Lo script successivo è una variante di quello precedente in cui si possono selezionare più colori assieme. Nella figura 161.29 si vede la finestra di dialogo che si ottiene.

#!/bin/sh

RISULTATO=`tempfile`

dialog --separate-output --title "Selezione" \
--checklist "Scegli i colori che preferisci" \
0 0 10 \
0 nero on \
1 marrone off \
2 rosso off \
3 arancio off \
4 giallo off \
5 verde off \
6 blu off \
7 viola off \
8 grigio off \
9 bianco on \
    2> $RISULTATO

echo `cat $RISULTATO`

Figura 161.29. Esempio del funzionamento della finestra di dialogo ottenuta con l'opzione --checklist.

.------------- Menù -------------.
| Scegli i colori che preferisci |
| .----------------------------. |
| |      [X] 0  nero           | |
| |      [ ] 1  marrone        | |
| |      [ ] 2  rosso          | |
| |      [ ] 3  arancio        | |
| |      [ ] 4  giallo         | |
| |      [ ] 5  verde          | |
| |      [ ] 6  blu            | |
| |      [ ] 7  viola          | |
| |      [ ] 8  grigio         | |
| |      [X] 9  bianco         | |
| `----------------------------' |
|--------------------------------|
|     <  OK  >      <Cancel>     |
`--------------------------------'

Figura 161.30. Esempio con Xdialog e con Gdialog. Nel caso di Gdialog si può osservare che i valori predefiniti non vengono presi in considerazione.

Xdialog Gdialog

161.5   Altri programmi affini


1) util-linux: getopt   UCB BSD

2) Debianutils: tempfile   UCB BSD

3) GNU core utilities   GNU GPL

4) Dialog   GNU GPL

5) Whiptail   GNU LGPL

6) Xdialog   GNU GPL

7) Gdialog (Zenity)   GNU GPL

8) Ncurses   software libero con licenza speciale FSF

9) Newt   GNU LGPL

10) Kaptain   GNU GPL


Appunti di informatica libera 2008 --- Copyright © 2000-2008 Daniele Giacomini -- <appunti2 (ad) gmail·com>


Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome strumenti_per_la_realizzazione_di_script_di_shell.htm

[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home]

Valid ISO-HTML!

CSS validator!

Gjlg Metamotore e Web Directory