Optionen für Shellscripte

Das Kommando ls beispiel.txt würde den Dateinamen einfach anzeigen, sofern die Datei beispiel.txt vorhanden ist; wovon wir mal ausgehen.

Bei ls -l beispiel.txt zeigt uns ls mehr Informationen zur Datei an.

Im ersten Fall kommt der Dateiname gleich nach ls, im zweiten Fall kommt der Dateiname erst an dritter Stelle auf der Kommandozeile. Da außerdem viel mehr Optionen zugleich angegeben werden dürfen, ist ls also in der Lage, die Optionen vom Dateinamen zu unterscheiden, egal wie weit hinten der Dateiname steht.

Diese Fähigkeit haben fast alle Kommandos. Mit dem Shell-Builtin getopts können auch Shellscripts dieses Feature erhalten.

Kurz: Um ein Shellscript mal schnell mit einigen Optionen in Kurzschreibweise zu versehen
und von anderen Argumenten zu unterscheiden, ist getopts gut geeignet.

Zuerst muss ein OptString definert werden. Das ist eine frei benennbare Shellvariable, deren Wert alle gewünschten Optionen enthält, zum Beispiel:

OPTSTR=':ab:c'

Ein OptString beginnt immer mit einem Doppelpunkt (:). Im Beispiel werden die Optionen -a, -b und -c erwartet.
Der Doppelpunkt hinter b bedeutet, dass b einen Wert erwartet.

Nun muss man noch wissen, dass getopts die Shellvariablen OPTIND und OPTARG anlegt und beschreibt
sowie eine bereitgestellte, frei benennbare Variable, wir nennen sie MYOPT.

#
# getoptstest.sh
#

OPTSTR=':ab:c'

getopts $OPTSTR MYOPT
echo "$?", "$MYOPT", "$OPTIND", "$OPTARG"

Wir erhalten die Ausgabe:

$ getoptstest.sh -ack -b Hallo
0, a, 1,

So, eine Option wurde erkannt - und die anderen?

Die weiteren Optionen werden erkannt, wenn man getopts in gleicher Weise mehrmals aufruft - darauf muss man erst mal kommen. Wir erweitern das Beispielscript:

OPTSTR=':ab:c'

getopts $OPTSTR MYOPT
echo "$?", "$MYOPT", "$OPTIND", "$OPTARG"

getopts $OPTSTR MYOPT
echo "$?", "$MYOPT", "$OPTIND", "$OPTARG"

getopts $OPTSTR MYOPT
echo "$?", "$MYOPT", "$OPTIND", "$OPTARG"

getopts $OPTSTR MYOPT
echo "$?", "$MYOPT", "$OPTIND", "$OPTARG"

Aufruf des Scripts mit derselben Kommandozeile wie zuvor ergibt:

$ getoptstest.sh -ack -b Hallo
0, a, 1,
0, c, 1,
0, ?, 2, k
0, b, 4, Hallo

Die Werte von MYOPT lassen erkennen, dass die Optionen in gleicher Reihenfolge erkannt werden wie auf der Kommandozeile notiert.

Allerdings ist -k eine Option, die wir im OptString nicht definiert haben. Daher kennt getopts diese Option auch nicht, schreibt in MYOPT ein Fragezeichen ein und die Option selbst in OPTARG.

Bei letztem getopts-Aufruf wird -b erkannt, und sein Wert landet in OPTARG.

$ getoptstest.sh -ac
0, a, 1,
0, c, 2,
1, ?, 2,
1, ?, 2,

Wird getopts nach der letzten Option aufgerufen, signalisiert der Rückgabewert ungleich 0 das Ende des Einlesens der Optionen.

Eine Rückgabe von 0 wird in der Shellprogrammierung als logisch true interpretiert, ungleich 0, uninteressant welche Zahl, als logisch false.

$ getoptsbsp.sh -ac -ac
0, a, 1,
0, c, 2,
0, a, 2,
0, c, 3,

Werden Optionen mehrfach angegeben, dann werden sie auch mehrfach gelesen.

$ getoptstest.sh -ac X -ac
0, a, 1,
0, c, 2,
1, ?, 2,
1, ?, 2,

Eine separat notierte Zeichenkette, die nicht mit Minuszeichen beginnt (oder auch nur ein einzelnes Zeichen) wird richtigerweise nicht als Optionsangabe erkannt, sondern als Argument. Das Lesen von Optionen ist damit beendet. Da Optionen grundsätzlich vor Argumenten anzugeben sind, haben nachfolgende Optionsangaben auch keinen Zweck.

$ getoptstest.sh -ac -- -ac
0, a, 1,
0, c, 2,
1, ?, 3,
0, a, 3,

Das Lesen der alleinstehenden Angabe -- bewirkt ebenfalls einen Rückgabwert ungleich 0. Zwar würden danach noch Optionen erkannt werden, aber davon wird kein Gebrauch gemacht. Die Angabe wird als Optionsende-Kennzeichen verwendet. Das heißt, alles, was danach kommt, egal wie geschrieben, sind Argumente.

Entsprechend der Definition im OptString erwartet die Option b einen Wert. Wir lassen ihn mal weg.

$ getoptstest.sh -ack -b
0, a, 1,
0, c, 1,
0, ?, 2, k
0, :, 3, b

Bei fehlendem Options-Wert landet in MYOPT ein Doppelpunkt und die Option selbst wird in OPTARG abgelegt;
soweit so gut.

$ getoptsbsp.sh -abc
0, a, 1,
0, b, 2, c
1, ?, 2,
1, ?, 2,

Auch hier fehlt der Option ihr Wert. Allerdings wird die nächstbeste Zeichenkette als Wert verwendet, in diesem Fall das c. Ist c als Wert gewollt, oder nicht? Mit einer formalen Logik kaum für jede denkbare Situation aufzulösen.

Schaut man sich die Manualseiten einschlägiger Kommandos an, so fällt auf, dass Optionen in Kurzschreibweise i.d.R. keinen Wert erwarten. Für Optionenwerte gibt es die Langschreibweise, die aber von getopts nicht unterstützt wird.

Testet man den Rückgabewert von getopts ergibt sich die Möglichkeit, getopts-Aufrufe in eine Schleife einzubauen. Solange die Rückgabe 0 ist (also logisch true), soll die Schleife laufen. Unser Beispielscript wird nun sehr kurz:

OPTSTR=':ab:c'

while getopts $OPTSTR MYOPT
do
  echo "$?", "$MYOPT", "$OPTIND", "$OPTARG"
done

Gut als Testscript geeignet, um alle möglichen Szenarien durchzuspielen.

Das folgende Script unterscheidet die weiter oben demonstrierten Fälle. Die farbig hervorgehobenen Kommentare kennzeichnen, welche Auswertung an der betreffenden Stelle möglich ist. Stellvertretend dafür stehen echo-Kommandos.

#
# basisscript-getopts.sh
#

OPTSTR=':ab:c'

while getopts $OPTSTR MYOPT
do

  if [ "$MYOPT" == "?" ] && [ -n "$OPTARG" ]
  then
    # Reaktion auf unerwartete Option
    echo "Option $OPTARG wurde nicht erwartet."

  elif [ "$MYOPT" == ":" ] && [ -n "$OPTARG" ]
  then
    # Reaktion auf fehlendes Optionsargument
    echo "Der Option $OPTARG fehlt der Wert ."

  else
    # Reaktion auf reguläre Option
    echo -n "Option $MYOPT wurde erkannt"

    if [ -n "$OPTARG" ]
    then
      # Reaktion auf Wert zur Option
      echo -n " mit Wert $OPTARG"
     fi

    echo "."
  fi

done

# Zugriff auf Argumente nach dem Lesen aller Optionen
shift $((OPTIND - 1))

if [ -n "$1" ]
then
  # Argumente auswerten
  echo "Argumente: $@"
fi

Die Auswertung von Argumenten ist nach der Schleife möglich. In den Stellungsparametern jedoch stehen die Optionen und Argumente unverändert wie beim Aufruf drin. Mit shift kann man die Werte der Stellungsparameter nach links wegschieben. Am besten soweit, dass das erste Argument im Parameter $1 zu stehen kommt.

Dabei hilft uns die Shellvariable OPTIND. Nach allen gelesenen Optionen steht darin der Index des ersten Arguments. Da wir dieses Argument nicht mit herausschieben wollen, müssen wir um 1 weniger schieben als OPTIND ausweist. Die Berechnung erledigt der Ausdruck $((OPTIND - 1)), und shift erhält die richtige Anzahl Schubschritte.

Wenn keine Argumente angegeben wären, dann wären $1 (und die folgenden Stellungsparameter) leer. Wenn jedoch etwas drin ist, genau das testet die letzte if-Anweisung, dann findet man die Argumente in den Stellungsparametern ab $1.

Zum Abschluss noch ein Test, um zu zeigen, wie das Basisscript funktioniert.

$ basisscript-getopts.sh -ack -b 25 Hallo, Welt
Option a wurde erkannt.
Option c wurde erkannt.
Option k wurde nicht erwartet.
Option b wurde erkannt mit Wert 25.
Argumente: Hallo, Welt

Man findet Tutorials und funktionierende Beispiele im Internet. Wer sie zu ersten Mal sieht, stellt wahrscheinlich genau diese Frage. Das wollen wir jetzt ergründen.

Im Manual finden wir die Syntax, hier reduziert auf das Wichtigste:

getopt -o optstring -- parameters

Mit optstring ist dasselbe gemeint wie der OptString bei getopts, nämlich eine Angabe, welche Optionen vorkommen sollen. Das kann eine Folge von Zeichenketten sein, daher zeigt -- das Ende an.

Hinter parameters verbirgt sich die Folge von Optionen und Argumenten, die man beim Kommandoaufruf angibt. Also:

• Wir definieren die Optionen -a, -b und -c. Das notieren wir als OptString: -o abc.
• Hinter dem (angenommenen) Kommando notieren wir: -a -bc Hallo Welt

So, und damit rufen wir jetzt getopt auf der Kommandozeile auf:

$ getopt -o abc -- -a -bc Hallo Welt
 -a -b -c -- 'Hallo' 'Welt'

Wir sehen, dass getopt ein Ergebnis ausgibt. Sieht im ersten Moment genau so aus wie die Angaben hinter getopt, es gibt auch -- als Trennung. Unterschiede: Vor der Trennung wurden die Optionen einzeln ausgegeben. Danach sehen wir alle anderen Argumente, schön einzeln gequotet.

Das nächste Beispiel zeigt mehr.

$ getopt -o abc -- -a Hallo -b Welt -c
 -a -b -c -- 'Hallo' 'Welt'

Es erscheint dasselbe Ergebnis; getopt kann sortieren: die erkannten Optionen linksseitig von --, alle anderen Argumente rechtsseitig. Das heißt, wir haben die Freiheit, Optionen auch hinter Argumenten notieren zu können.

Bevor wir weiter testen, bauen wir mal getopt in ein ganz einfaches Testscript ein, etwa so:

#
# first-getopt-script.sh
#

getopt -o abc -- $@ 

Der Shellparameter $@ enthält die komplette Kommandozeile des Scriptaufrufs, sodass alle Optionen und Argumente an dieser Stelle landen. Wir wiederholen den letzten Test, jetzt aber mit dem Script:

$ first-getopt-script.sh -a Hallo -b Welt -c
 -a -b -c -- 'Hallo' 'Welt'

Na bitte, die Optionen und Argumente vom Scriptaufruf werden genauso erkannt wie zuvor bei unserer Direkteingabe.

Zu einer Option kann ein Wert gehören. Das gibt man im OptString mit einem Doppelpunkt hinter der Option an. Wir wollen der Option -a einen Wert zuordnen und ändern im Script den OptString ...

getopt -o a:bc -- $@

... und testen gleich mal:

$ first-getopt-script.sh -a 25 Hallo -b Welt -c
 -a '25' -b -c -- 'Hallo' 'Welt'

Der Wert erscheint als Zeichenkette direkt hinter der Option -a

Was passiert, wenn wir vergessen, den Wert auf der Kommandozeile anzugeben?

$ first-getopt-script.sh -a Hallo -b Welt -c
 -a 'Hallo' -b -c -- 'Welt'

Klar, es wird die nächstbeste Angabe als Wert genommen, das kennen wir schon von getopts.

Mit optionalen Werten hat getopt noch ein echtes Ass im Ärmel.
Dafür werden hinter die betreffende Option im OptString zwei Doppelpunkte notiert.

getopt -o a::bc -- $@

Wir wiederholen den letzten Test:

$ first-getopt-script.sh -a Hallo -b Welt -c
 -a '' -b -c -- 'Hallo' 'Welt'

Nun erscheint als Wert eine leere Zeichenkette hinter der Option, denn wir haben ja kein Argument angegeben. Das holen wir nach:

$ first-getopt-script.sh -a 25 Hallo -b Welt -c
 -a '' -b -c -- '25' 'Hallo' 'Welt'

Nanu, der Wert erscheint auf der Seite der Argumente und hinter -a steht die leere Zeichenkette.

Es klappt schon, aber wir müssen den Wert direkt an die Option heran setzen:

$ first-getopt-script.sh -a25 Hallo -b Welt -c
 -a '25' -b -c -- 'Hallo' 'Welt'

Was macht getopt, wenn eine Option vorkommt, die nicht im Optstring definiert wurde?

$ first-getopt-script.sh -kbc Hallo Welt
getopt: unknown option -- k
 -b -c -- 'Hallo' 'Welt'

Es erscheint eine Fehlermeldung.

Leiten wir die Standardfehlerausgabe in eine Datei um (im Beispiel getopt.log)

$ first-getopt-script.sh -kbc Hallo Welt 2> getopt.log
 -b -c -- 'Hallo' 'Welt'

dann sehen wir, dass die Fehlermeldung nicht im Ergebnis (Standardausgabe) landet,

$ cat getopt.log
getopt: unknown option -- k

sondern jetzt in der Datei.

Dazu greift man gern auf folgende Methode zurück:

1. Zurückschreiben der von getopt sortieren Optionen und Argumente in die Stellungsparameter.
2. Durchlaufen der Stellungsparameter mit einer Schleife.
3. Ein case-Konstrukt in der Schleife zum Erkennen der Optionen.

Demonstrieren wir den 1. Schritt mit diesem Script:

#
# second-getopt-script.sh
#

echo $@
set -- $(getopt -o a::bc -- $@)
echo $@

Die echo-Anweisungen zeigen alle Stellungsparameter an, vor und nach dem set-Kommando.

Das Shell-Builtin set belegt die Stellungsparameter $1, $2 ,$3 usw., mit den angegebenen Zeichenketten, und zwar mit den Ergebnis-Zeichenketten von getopt. Da set selbst Optionen kennt, wird zuerst das Optionenendezeichen -- notiert, damit set nicht fälschlicherweise Teile des getopt-Ergebnisses als Optionen für sich interpretiert.

$ second-getopt-script.sh -a Hallo Welt -bc
-a Hallo Welt -bc
-a '' -b -c -- 'Hallo' 'Welt'

Das erste echo zeigt die Parameter in der Reihenfolge an, die unserer Eingabe entspricht, das zweite echo zeigt die Belegung der Parameter nach dem set-Kommando.

Wir entfernen die echo-Kommandos und durchlaufen die Stellungsparameter mit einer while-Schleife.

set -- $(getopt -o a::bc -- $@)

while [ -n "$1" ]
do
  echo "$1"; shift
done

Dabei wird nur der Parameter $1 gelesen, danach aber sofort die Parameter mit shift nach links verschoben, sodass der nächste Parameterwert in $1 landet und für den Folgedurchlauf zur Verfügung steht.

$ second-getopt-script.sh -a Hallo Welt -bc
-a
''
-b
-c
--
'Hallo'
'Welt'

Die Optionen und Argumente werden so einzeln durchlaufen, bis kein Wert mehr kommt und $1 leer bleibt.

Nun kann man in der Schleife mit Hilfe von case die einzelnen Angaben finden und auswerten. Im Beispiel wurden alle erwarteten Optionen und Werte Shellvariablen zugewiesen, sodass eine Reaktion auf die Optionen nach der Schleife erfolgen kann, hier nur mit einfachen echo-Ausgaben demonstriert.

set -- $(getopt -o a::bc -- $@)
while [ -n "$1" ]
do
  case "$1" in
    -a) # Option -a erkannt
        A="$1";  shift
        AW="$1"; shift
        ;;
    -b) # Option -b erkannt
        B="$1";  shift
        ;;
    -c) # Option -c erkannt
        C="$1";  shift
        ;;
    --) # Ende der Optionen
        shift; break
        ;;
  esac
done

echo "Erkannte Optionen:"
echo "$A mit Wert $AW"
echo "$B"
echo "$C"

echo "Auswertung der Argumente:"
echo "$@"

Das Muster --) in case erkennt das von getopt gelieferte Optionen-Endekennzeichen
und bricht die Schleife mit break ab.

So werden alle Optionen erkannt, die Argumente verbleiben in den Stellungsparametern
und können wie üblich verwendet werden.

$ second-getopt-script.sh -a25 -b Hallo Welt
Erkannte Optionen:
-a mit Wert '25'
-b

Auswertung der Argumente:
'Hallo' 'Welt'

Durch -o OptString haben wir getopt mitgeteilt, welche Optionen in Kurzschreibweise erkannt werden sollen. Optionen in Langschreibweise werden so definiert:

-l Optionsname,Optionsname,...

Die Schreibweise

--longoptions Optionsname,Optionsname,...

erfüllt den gleichen Zweck. Nicht im Manual angegeben, aber in Beispielen aus dem Internet findet man

--long Optionsname,Optionsname,...

was auch funktioniert.

Wie im OptString gilt auch hier: Ein Doppelpunkt nach der Option erwartet einen Wert, zwei Doppelpunkte einen optionalen Wert.

Wichtig: Die Optionsnamen werden zwar mit Komma getrennt, aber alle Namen müssen eine Zeichenkette bilden. Möchte man Leerzeichen dazwischen notieren, dann die Optionsliste in DoubleQuotes setzen.

#
# third-getopt-script.sh
#

set -- $(getopt -o ab:: -l size::,help -- $@)
echo $@

Das Script entspricht den Beispielen zuvor, hier aber erweitert um die Long-Options size und help.

Erster Versuch auf der Komandozeile:

$ third-getopt-script.sh -b Hallo --help Welt -a --size
-b '' --help -a --size '' -- 'Hallo' 'Welt'

So unmöglich verteilt wird man Optionen und Argumente nicht angeben, aber getopt sortiert alles prima, links des Optionsstoppzeichens -- die Optionen, rechts davon die Argumente.

Auch gut zu sehen, dass optionale Argumente bei -b und bei --size erwartet werden. Da stehen jetzt leere Werte als Platzhalter.

Einen Wert einer Langoption zuzuordnen, sollte nun kein Problem sein. Wir machen es so, wie wir es bei Kurzoptionen gelernt haben; also Wert direkt an die Option setzen.

$ third-getopt-script.sh -b25 --size88
getopt: unknown option -- size88
-b '25' --

Da spielt getopt jedoch nicht mit. Der Wert zur Kurzoption kommt einwandfrei an, aber --size88 wird als unbekannte Option interpretiert.

Okay, dann schreiben wir den Wert mit Leerzeichen getrennt dahinter.

$ third-getopt-script.sh -b25 --size 88
-b '25' --size '' -- '88'

Auch kein Erfolg, jetzt wird die 88 als Argument verstanden, und --size steht immer noch ein leerer Wert.

Wir werden denn die Werte für Langoptionen bei regulären Kommandos geschrieben? Richtig, mit einem Gleichheitszeichen dazwischen uns sonst kein anderes Trennzeichen.

$ third-getopt-script.sh -b25 --size=88
-b '25' --size '88' --

Und jetzt klappt es tadellos, --size hat den Wert erhalten.

Wenn wir keine kurzen Optionen definieren wollen, dann lassen wir sie doch einfach weg.

set -- $(getopt -l size::,help -- $@) # funktioniert nicht!
echo $@

Ein Testaufruf zeigt jedoch Unmögliches:

$ third-getopt-script.sh --size=88 --help Hallo Welt
--help 'Hallo' 'Welt' --

So ziemlich alles wird als Option interpretiert, und von --size ist gar nichts zu sehen.

Ein Blick in das Manual (Kommando man getopt) zeigt drei mögliche Syntaxschreibweisen:

getopt optstring parameters

getopt [options] [--] optstring parameters

getopt [options] -o|--options optstring [options] [--] parameters

Es fällt auf, dass optstring in allen drei Schreibweisen vorkommt. Mit optstring ist die Angabe der gewünschten Kurzoptionen gemeint. Nun ja, in unserem Beispiel wollten wir ja keine Kurzoptionen haben ...

Aber vielleicht müssen wir -o optstring angeben? Probieren wir es mit einem leeren optstring:

set -- $(getopt -o '' -l size::,help -- $@)
echo $@

Ein Test zeigt, das ist die Lösung!

$ third-getopt-script.sh --size=88 --help Hallo Welt
--size '88' --help -- 'Hallo' 'Welt'

Es sind keine Kurzoptionen definiert, alle Langoptionen und Argumente werden erkannt, korrekt sortiert, und auch der Wert für --size ist da.

Kurze Optionen sind historisch älter als lange Optionen, die in späteren Kommandoversionen quasi nachgerüstet wurden. Daher ist es nicht selten, dass für denselben Zweck eine kurze und alternativ eine lange Option vorhanden ist. Manche Kommandos geben bei -h eine Hilfe aus, aber auch bei --help.

Das abschließende Beispiel erwartet bei -s und alternativ bei --size einen Wert, und gibt eine Hilfe bei -h oder --help aus.

#
# fourth-getopt-script.sh
#

usage()
{
  echo -e "\n"'Anwendung:
  Das ist ein Demo des Kommandos "getopt"

Aufruf:
  fourth-getopt-script.sh [Optionen]

Optionen:
  -h|--help : gibt diese Hilfe aus
  -s|--size : Ausgabe der Wertvorgabe

  -sWert|--size=Wert : setzt den Wert
'"\n"; exit 0
}

# Wertvorgabe
SIZE=100

set -- $(getopt -o hs:: -l help,size:: -- $@)

while [ -n "$1" ]
do
  case "$1" in
    -h|--help)
        shift; usage; break;
        ;;
    -s|--size)
        shift ; SW=$1 ; shift
        if [ "$SW" == "''" ]
        then
          # Ausgabe der Wertvorgabe
          echo "Vorgabe: $SIZE"
        else
          SIZE=$SW
          # Auswertung des neuen Wert
          echo "Wert ist jetzt $SIZE"
        fi
        ;;
    --) # Ende der Optionen
        shift; break
        ;;
  esac
done

  echo "Ende des Scripts"

In diesem Beispiel sollen -h und --help denselben Zweck erfüllen, nämlich eine Hife ausgeben. Der Hilfetext steht in der Shellfunktion usage().

Im case-Konstrukt sind daher beide Optionen im ersten Zweig angegeben, getrennt mit |:

    -h|--help) # reagiert sowohl auf -h als auch auf --help
        shift; usage; break;
        ;;

Dieses Zeichen ist ein ODER-Operator, je nachdem, welche der beiden Optionen eintritt, erfolgt die geplante Reaktion.

Mit shift werden zuerst die Parameter geschoben, und usage, einfach so notiert, ist der Aufruf der Shellfunktion. Nun kann man überlegen, ob nach Ausgabe der Hilfe das Script weiterlaufen soll oder nicht. Im Beispiel wurde ein break gesetzt, damit die while-Schleife verlassen und das Script endet.

Auch -s und --size sollen Gleiches bewirken. Hier wurde die Ausgabe eines vorgegebenen Wertes programmiert, wenn die Optionen keinen Wert erhalten. Andernfalls wird der Wert ausgegeben.