Come posso analizzare argomenti opzionali in uno script bash se non viene dato alcun ordine?

Sono confuso su come includere argomenti / flag opzionali quando si scrive uno script bash per il seguente programma:

Il programma richiede due argomenti:

run_program --flag1 <value> --flag2 <value>

Tuttavia, ci sono diversi flag opzionali:

run_program --flag1 <value> --flag2 <value> --optflag1 <value> --optflag2 <value> --optflag3 <value> --optflag4 <value> --optflag5 <value> 

Vorrei eseguire lo script bash in modo tale da accettare gli argomenti dell'utente. Se gli utenti inseriscono solo due argomenti in ordine, allora sarebbe:

#!/bin/sh

run_program --flag1 $1 --flag2 $2

E se fosse incluso uno degli argomenti opzionali? Penserei che sarebbe

if [ --optflag1 "$3" ]; then
    run_program --flag1 $1 --flag2 $2 --optflag1 $3
fi

Ma cosa succede se vengono dati $ 4 ma non $ 3?

Questo articolo mostra due modi diversi - shifte getopts(e discute i vantaggi e gli svantaggi dei due approcci).

Con il shifttuo script guarda $1, decide quale azione intraprendere, quindi esegue shift, passa $2a $1, $3a $2, ecc.

Per esempio:

while :; do
    case $1 in
        -a|--flag1) flag1="SET"            
        ;;
        -b|--flag2) flag2="SET"            
        ;;
        -c|--optflag1) optflag1="SET"            
        ;;
        -d|--optflag2) optflag2="SET"            
        ;;
        -e|--optflag3) optflag3="SET"            
        ;;
        *) break
    esac
    shift
done

Con getoptste definisci le opzioni (brevi) whilenell'espressione:

while getopts abcde opt; do
    case $opt in
        a) flag1="SET"
        ;;
        b) flag2="SET"
        ;;
        c) optflag1="SET"
        ;;
        d) optflag2="SET"
        ;;
        e) optflag3="SET"
        ;;
    esac
done

Ovviamente, questi sono solo frammenti di codice e ho tralasciato la convalida - controllando che siano impostati gli arg1 obbligatori flag1 e flag2, ecc.

L'approccio che usi è in una certa misura una questione di gusti: quanto portatile vuoi che sia il tuo script, se puoi vivere solo con opzioni brevi (POSIX) o se vuoi opzioni lunghe (GNU), ecc.

usa un array.

#!/bin/bash

args=( --flag1 "$1" --flag2 "$2" )
[  "x$3" = xFALSE ] ||  args+=( --optflag1 "$3" )
[  "x$4" = xFALSE ] ||  args+=( --optflag2 "$4" )
[  "x$5" = xFALSE ] ||  args+=( --optflag3 "$5" )
[  "x$6" = xFALSE ] ||  args+=( --optflag4 "$6" )
[  "x$7" = xFALSE ] ||  args+=( --optflag5 "$7" )

program_name "${args[@]}"

questo gestirà correttamente gli argomenti con spazi.

[modifica] Stavo usando la sintassi approssimativamente eqivalente args=( "${args[@]}" --optflag1 "$3" )ma G-Man mi ha suggerito un modo migliore.

In uno script shell, gli argomenti sono "$ 1", "$ 2", "$ 3", ecc. Il numero di argomenti è $ #.
Se il tuo script non riconosce le opzioni, puoi tralasciare il rilevamento delle opzioni e trattare tutti gli argomenti come operandi.
Per riconoscere le opzioni usa il getopts incorporato

Se le opzioni di input sono posizionali (sai in quali luoghi si trovano) e non specificate con flag, allora quello che vuoi è solo costruire la riga di comando. Basta preparare gli argomenti del comando per tutti loro:

FLAG1="--flag1 $1"
FLAG2="--flag2 $2"
OPTFLAG1=""
OPTFLAG2=""
OPTFLAG3=""
if [ xFALSE != x"$3" ]; then
   OPTFLAG1="--optflag1 $3"
fi
if [ xFALSE != x"$4" ]; then
   OPTFLAG2="--optflag2 $4"
fi
#the same for other flags

#now just run the program
runprogram $FLAG1 $FLAG2 $OPTFLAG1 $OPTFLAG2 $OPTFLAG3

Se i parametri non vengono specificati, le stringhe corrispondenti sono vuote e non si espandono in nulla. Nota che nell'ultima riga non ci sono virgolette. Questo perché vuoi che la shell divida i parametri in parole (per dare --flag1e $1come argomenti separati al tuo programma). Naturalmente, questo andrà storto se i parametri originali contengono spazi. Se sei quello che esegue questo, allora puoi lasciarlo, ma se si tratta di uno script generale, può avere un comportamento imprevisto se l'utente immette qualcosa con spazi. Per gestirlo, dovrai rendere il codice un po 'più brutto.

Il xprefisso nel []test è presente nel caso $3o $4è vuoto. In tal caso, bash si espanderebbe [ FALSE != $3 ]in [ FALSE != ]quale è un errore di sintassi, quindi un altro personaggio arbitrario è lì per proteggerlo. Questo è un modo molto comune, lo vedrai in molti script.

Ho impostato OPTFLAG1e il resto su ""all'inizio solo per essere sicuri (nel caso in cui fossero stati impostati su qualcosa prima), ma se non sono stati effettivamente dichiarati nell'ambiente, non è necessario farlo rigorosamente.

Un paio di osservazioni aggiuntive:

• In realtà potresti semplicemente ricevere i parametri allo stesso modo di runprogram: con i flag. Ecco di cosa John Nsta parlando. Ecco dove getoptsdiventa utile.
• L'uso di FALSE a tale scopo è un po 'fuori standard e piuttosto lungo. Di solito, si usa un singolo carattere (possibilmente -) per segnalare un valore vuoto, o semplicemente si passa una stringa vuota, come ""se non fosse altrimenti un valore valido del parametro. La stringa vuota rende anche il test più breve, basta usare if [ -n "$3" ].
• Se esiste un solo flag opzionale o se sono dipendenti, quindi non puoi mai avere OPTFLAG2, ma non OPTFLAG1, puoi semplicemente saltare quelli che non vuoi impostare. Se lo usi ""per parametri vuoti, come suggerito sopra, puoi comunque saltare tutti gli svuotamenti finali.

Questo metodo è praticamente il modo in cui le opzioni vengono passate ai compilatori in Makefile.

E ancora: se gli input possono contenere spazi, diventa brutto.