Linux Command Line & Bash Scripting Mastery · Lektion

Flags und Argumente mit getopts parsen

Implementieren Sie professionelle Kommandozeilenschnittstellen mit getopts für Kurzoptionen, erforderliche Argumente und Usage-Meldungen.

Flags und Argumente mit getopts parsen ist eine kostenlose Linux Command Line & Bash Scripting Mastery-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Linux Command Line & Bash Scripting Mastery-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Linux Command Line & Bash Scripting Mastery-Kurs umfasst insgesamt 4 Lektionen.

Warum getopts existiert

Jedes praxisnahe Skript muss irgendwann Optionen wie -v, -o output.txt oder -n 5 akzeptieren. Wenn Sie diese von Hand mit $1, $2 … auswerten, wird der Code schnell fehleranfällig.

getopts ist der POSIX-standardisierte integrierte Mechanismus, der kurze Optionen (-a, -b) zuverlässig verarbeitet, einschließlich Optionen, die ein Argument erwarten. Er ist in jeder POSIX-Shell integriert, sodass keine Abhängigkeiten erforderlich sind.

Verarbeitet kombinierte Schalter: -vn 5 = -v -n 5
Meldet unbekannte Optionen ordnungsgemäß
Setzt die Standardvariablen OPTIND und OPTARG automatisch

In dieser Lektion erstellen Sie von Grund auf eine vollständige, professionelle CLI mit getopts.

Die Syntax von getopts

Die grundlegende Syntax besteht aus einer while-Schleife, die bei jeder Iteration getopts aufruft:

while getopts "optstring" varname; do
  case "$varname" in
    ...
  esac
done

optstring — eine Zeichenkette, in der jeder akzeptierte Optionsbuchstabe aufgeführt ist. Ein Doppelpunkt nach einem Buchstaben bedeutet, dass diese Option ein Argument erwartet.
varname — erhält bei jeder Iteration den aktuellen Optionsbuchstaben.
OPTARG — wird automatisch auf den Argumentwert gesetzt, wenn auf den Buchstaben ein Doppelpunkt folgt.
OPTIND — Index des nächsten zu verarbeitenden Arguments; verwenden Sie nach der Schleife shift $((OPTIND - 1)), um die verbleibenden Positionsparameter verfügbar zu machen.

#!/usr/bin/env bash
# Minimal skeleton — shows the loop structure
while getopts 'vn:' opt; do
  case "$opt" in
    v) echo "Verbose mode on" ;;
    n) echo "Count = $OPTARG" ;;
    ?) echo "Unknown option: -$OPTARG" >&2; exit 1 ;;
  esac
done

Ein optstring definieren

Der optstring ist eine kompakte Deklaration des CLI-Vertrags. Jedes Zeichen steht für einen akzeptierten Schalter.

'abc' — akzeptiert -a, -b, -c (ohne Argumente)
'a:bc' — -a erfordert ein Argument; -b und -c nicht
':abc' — ein führender Doppelpunkt aktiviert den stillen Fehlermodus (Ihr Skript behandelt ungültige Optionen, anstatt dass die Shell eine Meldung ausgibt)

Der stille Modus wird in Produktivskripten bevorzugt, da Sie dadurch die vollständige Kontrolle über Fehlermeldungen und Exit-Codes erhalten.

#!/usr/bin/env bash
# optstring ':o:vq'
# -o  requires an argument (output file)
# -v  verbose flag (no argument)
# -q  quiet flag  (no argument)
# Leading ':' = silent error mode

while getopts ':o:vq' opt; do
  case "$opt" in
    o) OUTPUT="$OPTARG" ;;
    v) VERBOSE=1 ;;
    q) QUIET=1 ;;
    :) echo "Error: -$OPTARG requires an argument" >&2; exit 1 ;;
    \?) echo "Error: unknown option -$OPTARG" >&2; exit 1 ;;
  esac
done
echo "OUTPUT=$OUTPUT  VERBOSE=$VERBOSE  QUIET=$QUIET"

OPTARG und erforderliche Argumente

Wenn im optstring auf einen Schalter ein Doppelpunkt folgt, speichert getopts dessen Wert in OPTARG. Das Argument kann mit oder ohne Leerzeichen angegeben werden:

-o report.txt
-oreport.txt

Beide Formen werden identisch ausgewertet. Das ist einer der entscheidenden Vorteile gegenüber der manuellen Auswertung mit $1/shift.

Im stillen Modus (ein führender ':' im optstring) setzt getopts bei einem fehlenden Argument varname auf : und OPTARG auf den Optionsbuchstaben — ideal für eine gezielte Fehlermeldung.

#!/usr/bin/env bash
# Demonstrate OPTARG with a file-processing script

while getopts ':i:o:' opt; do
  case "$opt" in
    i) INPUT="$OPTARG" ;;
    o) OUTPUT="$OPTARG" ;;
    :) echo "Error: option -$OPTARG needs a value" >&2; exit 1 ;;
    \?) echo "Error: unknown flag -$OPTARG" >&2; exit 1 ;;
  esac
done

echo "Input  : ${INPUT:-<not set>}"
echo "Output : ${OUTPUT:-<not set>}"

Optionen mit OPTIND überspringen

Nach Abschluss von getopts enthält OPTIND den Index des ersten Arguments, das keine Option ist. Verwenden Sie shift, um alle verarbeiteten Optionen zu entfernen, sodass sich $1, $2 … auf die verbleibenden Positionsparameter (z. B. Dateinamen) beziehen.

Das entsprechende Idiom lautet immer:

shift $((OPTIND - 1))

Nach dem Verschieben enthält $@ nur noch die Argumente, die keine Schalter waren — die Operanden Ihres Befehls.

#!/usr/bin/env bash
# Shows OPTIND shift and leftover positional args

VERBOSE=0
while getopts ':vn:' opt; do
  case "$opt" in
    v) VERBOSE=1 ;;
    n) COUNT="$OPTARG" ;;
    :) echo "Error: -$OPTARG requires an argument" >&2; exit 1 ;;
    \?) echo "Error: unknown option -$OPTARG" >&2; exit 1 ;;
  esac
done
shift $((OPTIND - 1))

echo "VERBOSE=$VERBOSE  COUNT=${COUNT:-1}"
echo "Remaining args: $*"

Eine Usage-Funktion schreiben

Ein professionelles Skript stellt immer eine Funktion usage() bereit, die eine Hilfenachricht ausgibt und das Skript beendet. Üblich ist:

Auf stderr (Dateideskriptor 2) ausgeben, damit die Ausgabe von Pipes nicht verunreinigt wird
Bei -h / --help mit Code 0 beenden, bei ungültiger Verwendung mit Code 1
In Fehlerpfaden usage 1 und im Handler für -h usage 0 aufrufen

#!/usr/bin/env bash

usage() {
  cat >&2 <<EOF
Usage: $(basename "$0") [-v] [-n COUNT] [-o FILE] [FILE...]

Options:
  -v          Verbose output
  -n COUNT    Repeat COUNT times (default: 1)
  -o FILE     Write output to FILE
  -h          Show this help
EOF
  exit "${1:-0}"
}

while getopts ':vn:o:h' opt; do
  case "$opt" in
    v) VERBOSE=1 ;;
    n) COUNT="$OPTARG" ;;
    o) OUTFILE="$OPTARG" ;;
    h) usage 0 ;;
    :) echo "Error: -$OPTARG requires a value" >&2; usage 1 ;;
    \?) echo "Error: unknown option -$OPTARG" >&2; usage 1 ;;
  esac
done
shift $((OPTIND - 1))
echo "Parsed OK — verbose=${VERBOSE:-0} count=${COUNT:-1} out=${OUTFILE:--}"

Standardwerte und Validierung

Validieren Sie nach der Auswertung die Eingaben und setzen Sie Standardwerte, bevor Sie mit der eigentlichen Arbeit beginnen. Halten Sie die Auswertungsphase (die Schleife) von der Logikphase getrennt. Dadurch lassen sich beide Abschnitte leichter lesen und testen.

Verwenden Sie ${VAR:-default} für Inline-Standardwerte
Validieren Sie numerische Argumente mit einem regulären Ausdruck oder einer arithmetischen Prüfung
Prüfen Sie, ob erforderliche Optionen tatsächlich angegeben wurden

#!/usr/bin/env bash

usage() { echo "Usage: $(basename "$0") -n COUNT [-v]" >&2; exit 1; }

VERBOSE=0
COUNT=''

while getopts ':n:v' opt; do
  case "$opt" in
    n) COUNT="$OPTARG" ;;
    v) VERBOSE=1 ;;
    :) echo "Error: -$OPTARG needs a value" >&2; usage ;;
    \?) echo "Error: -$OPTARG unknown" >&2; usage ;;
  esac
done
shift $((OPTIND - 1))

# Validation phase
[[ -z "$COUNT" ]] && { echo "Error: -n COUNT is required" >&2; usage; }
[[ "$COUNT" =~ ^[0-9]+$ ]] || { echo "Error: COUNT must be a positive integer" >&2; usage; }

for (( i=1; i<=COUNT; i++ )); do
  [[ $VERBOSE -eq 1 ]] && echo "Iteration $i of $COUNT"
  echo "Hello, world!"
done

Schalter in der Kommandozeile kombinieren

getopts verarbeitet automatisch kombinierte kurze Schalter, die ohne Leerzeichen geschrieben werden — das entspricht der üblichen Unix-Konvention:

-v -q ist gleichbedeutend mit -vq
-n 5 -v ist gleichbedeutend mit -n5 -v oder -vn5

Sie müssen keinen zusätzlichen Code schreiben, um dies zu unterstützen — getopts durchläuft automatisch jedes Zeichen einer kombinierten Optionszeichenkette. Das ist ein weiterer wichtiger Grund, getopts statt einer manuellen Auswertung zu verwenden.

#!/usr/bin/env bash
# Test combined flag parsing
# Run as:  bash script.sh -vq -n3

VERBOSE=0; QUIET=0; COUNT=1

while getopts ':vqn:' opt; do
  case "$opt" in
    v) VERBOSE=1 ;;
    q) QUIET=1 ;;
    n) COUNT="$OPTARG" ;;
    :) echo "Error: -$OPTARG needs value" >&2; exit 1 ;;
    \?) echo "Error: unknown -$OPTARG" >&2; exit 1 ;;
  esac
done
shift $((OPTIND - 1))

echo "verbose=$VERBOSE quiet=$QUIET count=$COUNT"

Den Doppelstrich als Trennzeichen behandeln

Unix-Befehle akzeptieren -- (Doppelstrich) als ausdrückliches Signal, dass die Optionsverarbeitung beendet werden soll. Alles nach -- wird als Positionsargument behandelt, selbst wenn es wie ein Schalter aussieht.

getopts beendet die Verarbeitung automatisch, wenn es auf -- trifft. Nach shift $((OPTIND - 1)) ist der Doppelstrich entfernt und $@ enthält nur noch die Operanden.

Das ist wichtig für Skripte, die Dateinamen verarbeiten, die mit einem Bindestrich beginnen können, zum Beispiel:

myscript.sh -v -- -strangefile.txt

#!/usr/bin/env bash
# Demonstrate -- separator
# Run as:  bash script.sh -v -- file1.txt -oddname.txt

VERBOSE=0
while getopts ':v' opt; do
  case "$opt" in
    v) VERBOSE=1 ;;
    \?) echo "Unknown option -$OPTARG" >&2; exit 1 ;;
  esac
done
shift $((OPTIND - 1))   # removes -v and the '--' separator

echo "Verbose: $VERBOSE"
echo "Files to process:"
for f in "$@"; do
  echo "  -> $f"
done

getopts in eine Bibliotheksfunktion kapseln

In modularen Skripten können Sie getopts in einer Funktion parse_args() kapseln, die globale Variablen (oder Namensreferenzen) setzt. Dadurch bleibt main() übersichtlich und der Parser kann aus anderen Skripten eingebunden werden.

Wichtige Regeln für dieses Muster:

Deklarieren Sie die Optionsvariablen, bevor Sie die Funktion aufrufen
Verwenden Sie global-Variablen oder übergeben Sie Werte über eine Namensreferenz (declare -n)
Geben Sie bei ungültigen Eingaben einen Exit-Code ungleich null zurück, damit main reagieren kann

#!/usr/bin/env bash

# Global option variables
VERBOSE=0; OUTPUT=''; COUNT=1

parse_args() {
  local opt
  while getopts ':vn:o:h' opt; do
    case "$opt" in
      v) VERBOSE=1 ;;
      n) COUNT="$OPTARG" ;;
      o) OUTPUT="$OPTARG" ;;
      h) echo "Usage: $(basename "$0") [-v] [-n N] [-o FILE]"; exit 0 ;;
      :) echo "Error: -$OPTARG needs a value" >&2; return 1 ;;
      \?) echo "Error: unknown option -$OPTARG" >&2; return 1 ;;
    esac
  done
  shift $((OPTIND - 1))
  ARGS=("$@")   # leftover positional args stored in array
}

main() {
  parse_args "$@" || exit 1
  echo "verbose=$VERBOSE count=$COUNT output=${OUTPUT:--} args=${ARGS[*]}"
}

main "$@"

Vollständiges Praxisbeispiel: Ein Log-Archivierungsprogramm

Hier sehen Sie ein vollständiges, praxisnahes Skript, das alles aus dieser Lektion verwendet: optstring mit erforderlichen Argumenten, stillen Fehlermodus, eine Usage-Funktion, Standardwerte, Validierung und das Verschieben mit OPTIND.

Studieren Sie die Struktur — sie dient als Vorlage für jedes Skript mit CLI-Schnittstelle, das Sie schreiben.

#!/usr/bin/env bash
# archive_logs.sh — compress and move logs older than N days

set -euo pipefail

DESTDIR='/tmp/log_archive'
DAYS=30
VERBOSE=0

usage() {
  cat >&2 <<EOF
Usage: $(basename "$0") [-v] [-d DAYS] [-o DIR] SOURCE_DIR

  -d DAYS   Archive logs older than DAYS (default: 30)
  -o DIR    Destination directory (default: /tmp/log_archive)
  -v        Verbose output
  -h        Show this help
EOF
  exit "${1:-0}"
}

while getopts ':d:o:vh' opt; do
  case "$opt" in
    d) DAYS="$OPTARG" ;;
    o) DESTDIR="$OPTARG" ;;
    v) VERBOSE=1 ;;
    h) usage 0 ;;
    :) echo "Error: -$OPTARG requires a value" >&2; usage 1 ;;
    \?) echo "Error: unknown option -$OPTARG" >&2; usage 1 ;;
  esac
done
shift $((OPTIND - 1))

# Validation
[[ $# -lt 1 ]] && { echo "Error: SOURCE_DIR is required" >&2; usage 1; }
[[ "$DAYS" =~ ^[0-9]+$ ]] || { echo "Error: DAYS must be numeric" >&2; exit 1; }
SOURCE="$1"
[[ -d "$SOURCE" ]] || { echo "Error: '$SOURCE' is not a directory" >&2; exit 1; }

mkdir -p "$DESTDIR"
[[ $VERBOSE -eq 1 ]] && echo "Archiving logs older than $DAYS days from $SOURCE to $DESTDIR"

find "$SOURCE" -name '*.log' -mtime "+$DAYS" -print | while read -r f; do
  gzip -c "$f" > "$DESTDIR/$(basename "$f").gz"
  [[ $VERBOSE -eq 1 ]] && echo "  archived: $f"
done

echo "Done."

Kurze Prüfung: optstring von getopts

Lesen Sie den folgenden getopts-Aufruf und wählen Sie die korrekte Beschreibung seines Verhaltens:

while getopts ':f:vq' opt; do

Lektionszusammenfassung: getopts sicher beherrschen

Sie haben gelernt, wie Sie mit getopts professionelle Kommandozeilenschnittstellen in Bash erstellen. Hier ist eine Zusammenfassung der wichtigsten Punkte:

Syntax des optstring — Buchstaben ohne Doppelpunkt sind boolesche Schalter; ein Doppelpunkt nach einem Buchstaben bedeutet, dass dieser ein Argument erwartet; ein führender Doppelpunkt aktiviert den stillen Fehlermodus.
OPTARG — enthält automatisch den Argumentwert für Optionen, die ein Argument erwarten.
OPTIND — verwenden Sie nach der Schleife shift $((OPTIND - 1)), um die verbleibenden Positionsparameter in $@ verfügbar zu machen.
Stiller Fehlermodus — in Produktivumgebungen bevorzugt; behandeln Sie die Fälle : (fehlendes Argument) und \? (unbekannte Option) selbst, um die vollständige Kontrolle zu behalten.
Funktion usage() — schreiben Sie immer eine solche Funktion; geben Sie nach stderr aus und beenden Sie bei -h mit 0, bei Fehlern mit 1.
Kombinierte Schalter — getopts verarbeitet -vq und -n5 automatisch und ohne zusätzlichen Code.
Modulares Muster — kapseln Sie getopts in einer Funktion parse_args(), um übersichtliche, wiederverwendbare Skripte zu erstellen.

Wenn Sie getopts sicher beherrschen, werden aus Ihren Skripten zuverlässige, benutzerfreundliche CLI-Programme, die Unix-Konventionen folgen, statt einfache Werkzeuge für nur einen Zweck zu bleiben.

Häufig gestellte Fragen

Ist die Lektion „Flags und Argumente mit getopts parsen“ kostenlos?

Ja — der vollständige Text von „Flags und Argumente mit getopts parsen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Linux Command Line & Bash Scripting Mastery-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Linux Command Line & Bash Scripting Mastery-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Flags und Argumente mit getopts parsen“?

Implementieren Sie professionelle Kommandozeilenschnittstellen mit getopts für Kurzoptionen, erforderliche Argumente und Usage-Meldungen. Du übst Linux Command Line & Bash Scripting Mastery mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Linux Command Line & Bash Scripting Mastery zu starten?

Keine Vorkenntnisse erforderlich. Linux Command Line & Bash Scripting Mastery auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Flags und Argumente mit getopts parsen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Linux Command Line & Bash Scripting Mastery-Lektion Code schreiben und ausführen?

Ja. Jede Linux Command Line & Bash Scripting Mastery-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Funktionen mit lokalem Gültigkeitsbereich und Rückgabecodes entwerfen
Wiederverwendbare Bash-Bibliotheken erstellen und sourcen
Flags und Argumente mit getopts parsen
Arrays und assoziative Maps zwischen Funktionen übergeben

← Zurück zu Linux Command Line & Bash Scripting Mastery