[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico] [volume] [parte]

Capitolo 63.   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.

63.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 61.4.1. È importante osservare che anche tra una distribuzione GNU/Linux e l'altra ci possono essere differenze tra i programmi di servizio getopt.

63.1.1   Versione tradizionale di getopt

Il programma di servizio getopt tradizionale ha la sintassi seguente:

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 quello che è possibile sistemare, emettendo l'elenco delle opzioni, nel modo «corretto». Per esempio:

$ getopt ab:c -a uno -b due -c tre quattro

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,

$ ./scansione_1.sh -a uno -b due -c tre quattro

si dovrebbe ottenere il risultato seguente:

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

63.1.2   getopt nella versione dei programmi di servizio Linux

I programmi di servizio Linux si compongono anche di una versione di getopt ⁽¹⁾ 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:

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.

Alcune opzioni

-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.

Esempi

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

oppure

$ ./scansione_2.sh --a-lunga=uno --b-lunga=due --c-lunga=tre quattro

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

gli argomenti facoltativi non vengono presi in considerazione:

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

63.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:

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.

Alcune opzioni

-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.

Esempi

$ tempfile

Crea un file temporaneo e ne restituisce il nome attraverso lo standard output.

#!/bin/sh TEMPORANEO=`tempfile` ls -l / > $TEMPORANEO ... rm -r $TEMPORANEO

Quello che si vede è l'esempio tipico di uno script, incompleto, in cui si crea un file temporaneo accumulandone il nome in una variabile di ambiente; quindi si fa qualcosa con quel file (in questo caso si inserisce il risultato del comando ls -l), infine si elimina il file, sempre utilizzando l'espansione della variabile che ne contiene il nome.

63.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:

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.

Alcune opzioni

-u variabile | --unset=variabile

Permette di eliminare la variabile di ambiente nominata.

- | -i | --ignore-environment

Azzera completamente tutto l'ambiente.

Esempi

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.

63.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.

63.4.1   $ read

Di norma, read è un comando interno della shell Bash, anche se potrebbe essere disponibile un programma di servizio equivalente, da utilizzare con una shell differente. Il modello sintattico seguente rappresenta una semplificazione di quello relativo al comando interno di Bash, volutamente, per generalizzare la descrizione di questo comando che potrebbe essere disponibile in forma differente.

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»

63.4.2   $ 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:

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 fosse stato 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 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

63.4.3   Dialog e Whiptail

Dialog ⁽²⁾ e Whiptail ⁽³⁾ sono due programmi abbastanza compatibili che hanno lo scopo di gestire effetti più appariscenti in uno script di shell, dal momento che interagiscono con l'utilizzatore attraverso schermate colorate e finestre di dialogo, anche se solo a livello di carattere e senza una grafica vera e propria.

La differenza più importante tra i due sta nell'utilizzo di librerie differenti: Dialog usa la libreria Ncurses, ⁽⁴⁾ mentre Whiptail usa la libreria Newt. ⁽⁵⁾

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.

Alcune opzioni generali

--clear

Se si utilizza questa opzione generale, si fa in modo di ripulire lo schermo prima di mostrare il riquadro della finestra di dialogo.

--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.

--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.

Alcune opzioni per la definizione della finestra di dialogo

--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.

--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 visualizzare 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. 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ù.

Esempi

Gli esempi seguenti vengono mostrati con Dialog, ma funzionano nello stesso modo anche con Whiptail.

#/bin/sh if dialog --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 63.1; in base alla scelta affermativa o negativa, si ottiene la visualizzazione di un messaggio differente.

Figura 63.1. Esempio del funzionamento della finestra di dialogo ottenuta con l'opzione --yesno. .-----------------------. | Ti piace Dialog? | |-----------------------| | < Yes > < No > | `-----------------------'

Nello stesso modo, lo script seguente, che utilizza Whiptail con l'aggiunta dell'opzione --fb, si traduce in un risultato simile:

#/bin/sh if whiptail --fb --yesno " Ti piace Whiptail? " 0 0 then echo "Ottimo!" else echo "Peccato :-)" fi

dialog --title "Domanda" --yesno "Ti piace dialog?" 0 0

Questo comando rappresenta solo una variante dell'esempio precedente (a parte il fatto che manca il contorno dello script) e si vede l'aggiunta dell'indicazione di un titolo della finestra.

#!/bin/sh RISULTATO=`tempfile` dialog --title "Menù" \ --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`

In questo script viene mostrata la finestra di dialogo che si vede nella figura 63.2 e, in base alla scelta del colore, si ottiene il numero corrispondente.

Figura 63.2. Esempio del funzionamento della finestra di dialogo ottenuta con l'opzione --menu. .------------- Menù --------------. | 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> | `---------------------------------'

#!/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`

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

Figura 63.3. 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> | `--------------------------------'

Appunti di informatica libera 2003.06.29 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org

1) util-linux: getopt   UCB BSD

2) Dialog   GNU GPL

3) Whiptail   GNU LGPL

4) Ncurses   software libero con licenza speciale FSF

5) Newt   GNU LGPL

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

[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico]