6 Grundlagen der Skripterstellung

6.1 Motivation

Eine Kernaufgabe im IT-Alltag ist die Fähigkeit, Prozesse zu automatisieren und komplexe Aufgaben zu vereinfachen. Nachdem wir uns im ersten Kapitel mit den fundamentalen Konzepten der Shell und ihrer Funktionsweise vertraut gemacht haben, widmen wir uns nun dem Herzstück effektiver Systemadministration und Entwicklung: der strukturierten Erstellung von Shell-Skripten.

Shell-Skripte bilden das Bindeglied zwischen einfachen Kommandozeilenbefehlen und ausgereiften Automatisierungslösungen. Sie ermöglichen es uns, eine Abfolge von Befehlen in einer Datei zu bündeln, die dann als Einheit ausgeführt werden kann. Dies mag auf den ersten Blick trivial erscheinen, doch die Kraft dieser Methodik entfaltet sich in ihrer vollen Tragweite erst im professionellen Umfeld, wo Konsistenz, Wiederholbarkeit und Effizienz entscheidende Faktoren sind.

6.1.1 Vom Kommandozeilenbefehl zum strukturierten Skript

Der Übergang von einzelnen Kommandos zu durchdachten Skripten markiert einen entscheidenden Entwicklungsschritt für jeden IT-Fachmann. Während ein einzelner Befehl wie ls -la lediglich eine momentane Aufgabe erfüllt, kann ein gut gestaltetes Skript komplexe Workflows abbilden, Fehler abfangen und auf unterschiedliche Situationen reagieren.

Professionelle Shell-Skripte zeichnen sich durch mehrere Qualitätsmerkmale aus:

• Strukturierte Organisation: Logische Gruppierung von Befehlen und Funktionen
• Nachvollziehbare Dokumentation: Aussagekräftige Kommentare und eine klare Kodierungskonvention
• Robuste Fehlerbehandlung: Antizipation von Problemfällen und elegante Lösungsstrategien
• Modularer Aufbau: Wiederverwendbare Komponenten, die in verschiedenen Kontexten einsetzbar sind

In diesem Kapitel werden wir diese Grundsätze Schritt für Schritt erarbeiten und anwenden, um den Grundstein für Ihre Fähigkeiten im Shell-Scripting zu legen.

6.1.2 Die Bedeutung fundierter Grundkenntnisse

Wie bei jeder technischen Disziplin ist das Beherrschen der Grundlagen im Shell-Scripting entscheidend für den langfristigen Erfolg. Ein solides Fundament ermöglicht es Ihnen:

• Komplexe Probleme in überschaubare Teilaufgaben zu zerlegen
• Effizienten und wartbaren Code zu schreiben
• Die Leistungsfähigkeit der Shell voll auszuschöpfen
• Fehler schneller zu identifizieren und zu beheben
• Mit fortgeschrittenen Konzepten souverän umzugehen

Die in diesem Kapitel vermittelten Fähigkeiten bilden das Rückgrat Ihrer zukünftigen Expertise. Ähnlich wie ein Gebäude nur so stabil sein kann wie sein Fundament, bestimmt die Qualität Ihrer grundlegenden Skriptierungstechniken maßgeblich Ihre Effektivität bei komplexeren Aufgaben.

6.1.3 Was Sie in diesem Kapitel lernen werden

Nach Abschluss dieses Kapitels werden Sie in der Lage sein:

• Shell-Skripte zu erstellen und mit korrekten Berechtigungen auszuführen
• Die Shebang-Zeile zu verstehen und richtig einzusetzen
• Variablen sinnvoll zu definieren und zu verwenden
• Skripte durch aussagekräftige Kommentare nachvollziehbar zu gestalten
• Die verschiedenen Ausführungsmodi von Skripten zu verstehen
• Grundlegende Debugging-Techniken anzuwenden
• Einfache, aber leistungsfähige Skripte für alltägliche Aufgaben zu entwickeln

6.1.4 Vom Wissen zur Praxis

Die wahre Stärke des Shell-Scriptings liegt nicht in der theoretischen Kenntnis seiner Syntax, sondern in der praktischen Anwendung zur Lösung realer Probleme. Daher werden wir in diesem Kapitel besonderes Augenmerk auf praxisnahe Beispiele und Übungen legen, die direkt aus dem Alltag von Systemadministratoren und Entwicklern stammen.

Während Sie diese Grundlagen erlernen, werden Sie feststellen, dass selbst einfache Skripte Ihnen erhebliche Zeitersparnis und Konsistenz in Ihrer täglichen Arbeit bieten können. Ein fünfzeiliges Skript, das eine wiederkehrende Aufgabe automatisiert, kann über ein Jahr hinweg leicht hunderte Arbeitsstunden einsparen und gleichzeitig die Fehleranfälligkeit manueller Prozesse eliminieren.

6.1.5 Der Weg zum effektiven Shell-Scripting

Beim Erlernen des Shell-Scriptings geht es nicht darum, möglichst viele Befehle auswendig zu kennen, sondern vielmehr darum, ein Verständnis für die Konzepte und Denkweisen zu entwickeln, die effektive Skripte auszeichnen. Diese konzeptionelle Herangehensweise wird uns durch das gesamte Kapitel begleiten und Ihnen helfen, nicht nur bestehende Skripte zu verstehen, sondern auch eigene, innovative Lösungen zu entwickeln.

Lassen Sie uns nun gemeinsam in die Welt der Shell-Skripterstellung eintauchen und die Grundlagen legen, die Ihnen den Weg zu fortgeschrittenen Techniken ebnen werden.

6.2 Aufbau eines Bash-Skripts: Shebang, Kommentare, Befehle

Die Entwicklung effektiver Shell-Skripte beginnt mit dem Verständnis ihrer grundlegenden Struktur. Ein gut aufgebautes Bash-Skript folgt bestimmten Konventionen, die nicht nur die Lesbarkeit verbessern, sondern auch die Zuverlässigkeit und Wartbarkeit des Codes erhöhen. In diesem Abschnitt untersuchen wir die wichtigsten Bestandteile eines Bash-Skripts: die Shebang-Zeile, Kommentare und die eigentlichen Befehle.

6.2.1 Die Shebang-Zeile: Das Fundament jedes Skripts

Die erste Zeile eines Bash-Skripts beginnt typischerweise mit einem sogenannten “Shebang” oder “Hashbang”. Diese spezielle Zeile ist kein gewöhnlicher Kommentar, sondern eine Anweisung an das Betriebssystem, welcher Interpreter für die Ausführung des Skripts verwendet werden soll.

Die Syntax der Shebang-Zeile ist:

#!/pfad/zum/interpreter

Für Bash-Skripte wird üblicherweise einer der folgenden Shebangs verwendet:

#!/bin/bash

oder

#!/usr/bin/env bash

6.2.1.1 Unterschiede und Verwendungszwecke

Die Variante #!/bin/bash gibt einen festen Pfad zur Bash an. Sie funktioniert zuverlässig, solange die Bash tatsächlich unter /bin/bash installiert ist, was auf den meisten Linux-Systemen der Fall ist. Auf einigen BSD-Varianten oder exotischen Systemen könnte sie jedoch an einem anderen Ort installiert sein.

Die Variante #!/usr/bin/env bash ist flexibler. Sie verwendet das env-Programm, um die Bash in der Umgebung des Benutzers zu finden, unabhängig davon, wo sie installiert ist. Dies macht das Skript portabler zwischen verschiedenen Unix-artigen Betriebssystemen.

6.2.1.2 Best Practice für die Shebang-Zeile

Als Best Practice empfiehlt sich für die meisten Anwendungsfälle:

#!/usr/bin/env bash

Diese Variante bietet die beste Portabilität und funktioniert auf nahezu allen Unix-Systemen, solange Bash installiert ist.

6.2.1.3 Shebang-Optionen für spezifische Anforderungen

In einigen Fällen möchten Sie möglicherweise spezielle Optionen an die Bash übergeben. Dies ist ebenfalls über die Shebang-Zeile möglich:

#!/bin/bash -e

Die Option -e bewirkt beispielsweise, dass das Skript sofort beendet wird, wenn ein Befehl mit einem Fehler endet. Dies kann für kritische Skripte sinnvoll sein, um Folgefehler zu vermeiden.

Eine weitere nützliche Option ist -x, die jede Befehlszeile vor der Ausführung anzeigt:

#!/bin/bash -x

Dies ist besonders hilfreich beim Debugging von Skripten.

6.2.2 Kommentare: Die Dokumentation des Codes

Kommentare sind für Menschen, nicht für Computer geschrieben. Sie erklären, was der Code tut, warum er es tut und wie er es tut. In Bash gibt es zwei Arten von Kommentaren:

6.2.2.1 Einzeilige Kommentare

Einzeilige Kommentare beginnen mit dem Symbol # und erstrecken sich bis zum Ende der Zeile:

# Dies ist ein einzeiliger Kommentar
echo "Hello World"  # Dies ist ein Kommentar am Ende einer Befehlszeile

6.2.2.2 Mehrzeilige Kommentare

Bash unterstützt keine nativen mehrzeiligen Kommentarblöcke wie etwa C oder Java mit /* ... */. Es gibt jedoch einige Möglichkeiten, mehrzeilige Kommentare zu simulieren:

# Dies ist ein 
# mehrzeiliger Kommentar
# mit mehreren Zeilen

: '
Dies ist eine alternative Methode
für mehrzeilige Kommentare in Bash.
Der Doppelpunkt gefolgt von einem String wird evaluiert,
aber nicht ausgegeben.
'

Die zweite Methode mit dem Doppelpunkt ist weniger verbreitet, kann aber nützlich sein, wenn Sie viele Zeilen kommentieren möchten, ohne jeder Zeile ein # voranzustellen.

6.2.2.3 Strukturierte Kommentierung: Ein Schlüssel zur Codequalität

Für professionelle Skripte empfiehlt sich eine strukturierte Dokumentation, besonders am Anfang des Skripts. Hier ein Beispiel für einen gut dokumentierten Skriptkopf:

#!/usr/bin/env bash
#
# Dateiname: backup_system.sh
# Beschreibung: Erstellt ein inkrementelles Backup wichtiger Systemdateien
# Autor: Max Mustermann (max.mustermann@example.com)
# Erstellt am: 2023-04-15
# Letzte Änderung: 2023-04-20
# Version: 1.2
#
# Verwendung: ./backup_system.sh [Zielverzeichnis]
# Beispiel: ./backup_system.sh /mnt/backup
#
# Hinweise:
# - Benötigt Root-Rechte für den Zugriff auf Systemdateien
# - Verwendet rsync für die Erstellung inkrementeller Backups
# - Logdateien werden in /var/log/backups gespeichert

Diese Art der Dokumentation hilft nicht nur anderen Entwicklern, sondern auch Ihnen selbst, wenn Sie nach Monaten zu Ihrem eigenen Code zurückkehren.

6.2.3 Befehle: Das Herzstück des Skripts

Nach der Shebang-Zeile und den einleitenden Kommentaren folgt der eigentliche Code des Skripts. Dieser besteht aus einer Abfolge von Befehlen, die sequenziell, von oben nach unten, ausgeführt werden.

6.2.3.1 Grundlegende Befehlsausführung

In Bash wird jede Zeile als separater Befehl interpretiert und ausgeführt:

echo "Schritt 1: Verzeichnis erstellen"
mkdir -p /tmp/beispiel
cd /tmp/beispiel
echo "Aktuelles Verzeichnis: $(pwd)"

6.2.3.2 Befehlstrennung

Mehrere Befehle können auf verschiedene Weisen kombiniert werden:

1. Sequentielle Ausführung (;): Befehle werden nacheinander ausgeführt, unabhängig vom Erfolg des vorherigen Befehls.

   echo "Erster Befehl"; echo "Zweiter Befehl"; echo "Dritter Befehl"

2. Bedingte Ausführung (&& und ||): Befehle werden nur ausgeführt, wenn der vorherige Befehl erfolgreich war (&&) oder fehlgeschlagen ist (||).

   mkdir /tmp/test && echo "Verzeichnis wurde erstellt" || echo "Fehler beim Erstellen des Verzeichnisses"

3. Gruppierung von Befehlen ({ ... } und ( ... )): Mehrere Befehle können zu einer logischen Einheit gruppiert werden.

   # Ausführung in der aktuellen Shell
   { echo "In geschweiften Klammern"; pwd; }
   
   # Ausführung in einer Subshell
   ( echo "In Klammern"; cd /tmp; pwd )
   echo "Aktuelles Verzeichnis ist immer noch: $(pwd)"

Der Unterschied zwischen geschweiften Klammern und runden Klammern liegt darin, dass Befehle in runden Klammern in einer Subshell ausgeführt werden, während Befehle in geschweiften Klammern in der aktuellen Shell laufen.

6.2.4 Vollständige Beispiele

Um die besprochenen Konzepte zu veranschaulichen, betrachten wir nun drei vollständige Beispiele für gut strukturierte Bash-Skripte.

6.2.4.1 Beispiel 1: Einfaches Backup-Skript

#!/usr/bin/env bash
#
# Dateiname: simple_backup.sh
# Beschreibung: Erstellt ein Backup eines Verzeichnisses mit Zeitstempel
# Autor: Max Mustermann
# Version: 1.0
#
# Verwendung: ./simple_backup.sh [Quellverzeichnis] [Zielverzeichnis]
#

# Fehlermeldung ausgeben und Skript beenden
function error_exit {
    echo "FEHLER: $1" >&2
    exit 1
}

# Prüfen, ob die erforderlichen Parameter übergeben wurden
if [ $# -ne 2 ]; then
    error_exit "Es werden genau zwei Parameter benötigt: Quell- und Zielverzeichnis"
fi

# Parameter in sprechende Variablen speichern
SOURCE_DIR="$1"
TARGET_DIR="$2"

# Prüfen, ob das Quellverzeichnis existiert
if [ ! -d "$SOURCE_DIR" ]; then
    error_exit "Das Quellverzeichnis '$SOURCE_DIR' existiert nicht"
fi

# Prüfen, ob das Zielverzeichnis existiert, wenn nicht, erstellen
if [ ! -d "$TARGET_DIR" ]; then
    mkdir -p "$TARGET_DIR" || error_exit "Konnte Zielverzeichnis '$TARGET_DIR' nicht erstellen"
    echo "Zielverzeichnis '$TARGET_DIR' wurde erstellt"
fi

# Zeitstempel für den Backup-Namen generieren
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
BACKUP_NAME="backup_${TIMESTAMP}.tar.gz"
BACKUP_PATH="${TARGET_DIR}/${BACKUP_NAME}"

# Backup erstellen
echo "Erstelle Backup von '$SOURCE_DIR' nach '$BACKUP_PATH'..."
tar -czf "$BACKUP_PATH" -C "$(dirname "$SOURCE_DIR")" "$(basename "$SOURCE_DIR")" || \
    error_exit "Backup konnte nicht erstellt werden"

echo "Backup erfolgreich erstellt: $BACKUP_PATH"
exit 0

Dieses Skript demonstriert: - Eine klare Shebang-Zeile - Einen ausführlichen Dokumentationsheader - Die Verwendung von Funktionen für wiederholte Aufgaben - Fehlerprüfung und -behandlung - Sprechende Variablennamen - Sinnvolle Kommentare zur Erklärung der Logik

6.2.4.2 Beispiel 2: Systemüberwachungsskript

#!/usr/bin/env bash
#
# Dateiname: system_monitor.sh
# Beschreibung: Überwacht wichtige Systemressourcen und sendet Warnungen
# Autor: Erika Musterfrau
# Version: 1.1
#
# Verwendung: ./system_monitor.sh [Schwellenwert in Prozent]
#

# Standardwerte setzen
THRESHOLD=${1:-90}  # Standardwert 90%, wenn kein Parameter übergeben wurde
LOG_FILE="/var/log/system_monitor.log"
EMAIL="admin@example.com"

# Funktion zur Protokollierung
log_message() {
    local message="[$(date '+%Y-%m-%d %H:%M:%S')] $1"
    echo "$message" | tee -a "$LOG_FILE"
}

# Funktion zur Benachrichtigung
send_alert() {
    local subject="WARNUNG: Hohe Systemauslastung"
    local message="$1"
    
    # In einer echten Umgebung würde hier ein E-Mail-Versand stehen
    log_message "ALERT: $message"
    echo "To: $EMAIL"
    echo "Subject: $subject"
    echo "Message: $message"
}

# Überprüfen der CPU-Auslastung
check_cpu() {
    # CPU-Last der letzten Minute ermitteln
    local cpu_load=$(uptime | awk '{print $10}' | tr -d ',')
    local cpu_cores=$(nproc)
    local cpu_percent=$(echo "scale=2; $cpu_load * 100 / $cpu_cores" | bc)
    
    log_message "CPU-Auslastung: ${cpu_percent}%"
    
    # Warnung ausgeben, wenn Schwellenwert überschritten
    if (( $(echo "$cpu_percent > $THRESHOLD" | bc -l) )); then
        send_alert "CPU-Auslastung bei ${cpu_percent}% (Schwellenwert: ${THRESHOLD}%)"
    fi
}

# Überprüfen der Speicherauslastung
check_memory() {
    # Freien und gesamten Speicher ermitteln
    local mem_info=$(free | grep Mem)
    local total_mem=$(echo "$mem_info" | awk '{print $2}')
    local used_mem=$(echo "$mem_info" | awk '{print $3}')
    local mem_percent=$(echo "scale=2; $used_mem * 100 / $total_mem" | bc)
    
    log_message "Speicherauslastung: ${mem_percent}%"
    
    # Warnung ausgeben, wenn Schwellenwert überschritten
    if (( $(echo "$mem_percent > $THRESHOLD" | bc -l) )); then
        send_alert "Speicherauslastung bei ${mem_percent}% (Schwellenwert: ${THRESHOLD}%)"
    fi
}

# Überprüfen der Festplattenauslastung
check_disk() {
    # Alle gemounteten Dateisysteme prüfen
    while read -r filesystem size used avail use_percent mountpoint; do
        # Prozentzeichen entfernen
        use_percent=${use_percent/\%/}
        
        log_message "Festplattenauslastung $mountpoint: ${use_percent}%"
        
        # Warnung ausgeben, wenn Schwellenwert überschritten
        if [ "$use_percent" -gt "$THRESHOLD" ]; then
            send_alert "Festplattenauslastung von $mountpoint bei ${use_percent}% (Schwellenwert: ${THRESHOLD}%)"
        fi
    done < <(df -h | grep -v "Filesystem" | awk '{print $1, $2, $3, $4, $5, $6}')
}

# Hauptteil des Skripts
log_message "Systemüberwachung gestartet (Schwellenwert: ${THRESHOLD}%)"

# Systemressourcen prüfen
check_cpu
check_memory
check_disk

log_message "Systemüberwachung abgeschlossen"
exit 0

Dieses Beispiel zeigt: - Die Verwendung von Standardwerten für Parameter - Die Definition und Nutzung von Funktionen für modularen Code - Die strukturierte Protokollierung - Fortgeschrittene Befehls-Verkettung und -Substitution - Die Verwendung von Unterkommandos für komplexere Aufgaben

6.2.4.3 Beispiel 3: Interaktives Menüskript

#!/usr/bin/env bash
#
# Dateiname: interactive_menu.sh
# Beschreibung: Zeigt ein interaktives Menü für häufige Administrationstasks
# Autor: Sven Schmidt
# Version: 0.9 (Beta)
#
# Verwendung: ./interactive_menu.sh
#

# Farbdefinitionen für die Ausgabe
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Funktion zum Anzeigen formatierter Nachrichten
print_message() {
    local type=$1
    local message=$2
    
    case $type in
        "info")
            echo -e "${BLUE}[INFO]${NC} $message"
            ;;
        "success")
            echo -e "${GREEN}[ERFOLG]${NC} $message"
            ;;
        "warning")
            echo -e "${YELLOW}[WARNUNG]${NC} $message"
            ;;
        "error")
            echo -e "${RED}[FEHLER]${NC} $message"
            ;;
        *)
            echo "$message"
            ;;
    esac
}

# Funktion zur Bestätigung einer Aktion
confirm_action() {
    local prompt=$1
    local response
    
    echo -e "${YELLOW}$prompt (j/n)${NC}"
    read -r response
    
    case $response in
        [jJ][aA]|[jJ])
            return 0
            ;;
        *)
            return 1
            ;;
    esac
}

# Funktion zum Anzeigen des Hauptmenüs
show_menu() {
    clear
    echo "=========================================="
    echo "           ADMINISTRATIONS-MENÜ           "
    echo "=========================================="
    echo "1. Systemstatus anzeigen"
    echo "2. Benutzerverwaltung"
    echo "3. Dateioperationen"
    echo "4. Netzwerkdiagnose"
    echo "5. Beenden"
    echo "=========================================="
    echo -n "Bitte wählen Sie eine Option (1-5): "
}

# Funktion zur Anzeige des Systemstatus
show_system_status() {
    print_message "info" "Systemstatus wird abgerufen..."
    echo "----------------------------------------"
    echo "CPU-Auslastung:"
    top -bn1 | grep "Cpu(s)" | awk '{print $2 + $4 "% genutzt"}'
    
    echo "----------------------------------------"
    echo "Speicherauslastung:"
    free -h | grep "Mem:" | awk '{print $3 " von " $2 " genutzt (" $3/$2*100 "%)"}'
    
    echo "----------------------------------------"
    echo "Festplattenauslastung:"
    df -h | grep -v "tmpfs" | grep -v "Filesystem"
    
    echo "----------------------------------------"
    echo "Systemlaufzeit:"
    uptime
    echo "----------------------------------------"
    
    read -p "Drücken Sie Enter, um fortzufahren..."
}

# Hauptlogik des Skripts
while true; do
    show_menu
    read -r choice
    
    case $choice in
        1)
            show_system_status
            ;;
        2)
            # Hier würde die Implementierung für Benutzerverwaltung folgen
            print_message "info" "Benutzerverwaltung ausgewählt (noch nicht implementiert)"
            sleep 2
            ;;
        3)
            # Hier würde die Implementierung für Dateioperationen folgen
            print_message "info" "Dateioperationen ausgewählt (noch nicht implementiert)"
            sleep 2
            ;;
        4)
            # Hier würde die Implementierung für Netzwerkdiagnose folgen
            print_message "info" "Netzwerkdiagnose ausgewählt (noch nicht implementiert)"
            sleep 2
            ;;
        5)
            if confirm_action "Möchten Sie das Programm wirklich beenden?"; then
                print_message "success" "Programm wird beendet. Auf Wiedersehen!"
                exit 0
            fi
            ;;
        *)
            print_message "error" "Ungültige Auswahl. Bitte wählen Sie eine Option zwischen 1 und 5."
            sleep 2
            ;;
    esac
done

Dieses Beispiel zeigt: - Die Verwendung von ANSI-Farbcodes für formatierte Ausgaben - Ein interaktives Benutzermenü - Nutzereingaben und deren Verarbeitung - Eine Schleifenstruktur für ein kontinuierliches Menü - Strukturierte Funktionen für verschiedene Funktionalitäten

6.2.5 Best Practices für den Skriptaufbau

Basierend auf den vorgestellten Beispielen lassen sich folgende Best Practices für den Aufbau von Bash-Skripten ableiten:

1. Beginnen Sie immer mit einer korrekten Shebang-Zeile
   • Verwenden Sie #!/usr/bin/env bash für maximale Portabilität
2. Dokumentieren Sie Ihr Skript ausführlich
   • Fügen Sie einen Dokumentationsheader am Anfang des Skripts ein
   • Dokumentieren Sie alle Funktionen und komplexen Abschnitte
   • Erklären Sie den Zweck, nicht nur die Aktion eines Befehls
3. Verwenden Sie sprechende Variablennamen
   • MAX_RETRY_COUNT ist besser als mrc
   • Verwenden Sie Großbuchstaben für Konstanten und globale Variablen
4. Strukturieren Sie Ihren Code in Funktionen
   • Jede Funktion sollte eine spezifische Aufgabe erfüllen
   • Definieren Sie Funktionen am Anfang des Skripts, vor ihrer Verwendung
   • Geben Sie Funktionen sinnvolle, handlungsorientierte Namen
5. Implementieren Sie eine robuste Fehlerbehandlung
   • Prüfen Sie Rückgabewerte von kritischen Befehlen
   • Verwenden Sie set -e, um das Skript bei Fehlern zu beenden
   • Implementieren Sie sinnvolle Fehlermeldungen
6. Organisieren Sie Ihren Code logisch
   • Variablendefinitionen
   • Funktionsdefinitionen
   • Initialisierungslogik
   • Hauptlogik
   • Aufräumarbeiten
7. Schreiben Sie portablen Code
   • Vermeiden Sie systemspezifische Befehle oder prüfen Sie deren Verfügbarkeit
   • Berücksichtigen Sie verschiedene Shell-Versionen
8. Seien Sie konsistent in Stil und Formatierung
   • Verwenden Sie durchgängig die gleiche Einrückung (z.B. 2 oder 4 Spaces)
   • Folgen Sie einer konsistenten Namenskonvention
9. Kommentieren Sie Ihren Code, aber nicht übermäßig
   • Ein guter Kommentar erklärt das Warum, nicht das Was
   • Vermeiden Sie offensichtliche Kommentare, die nur den Code wiederholen
10. Fügen Sie Hilfetexte und Nutzungshinweise hinzu
    • Implementieren Sie eine -h oder --help-Option
    • Dokumentieren Sie die erwarteten Parameter und ihre Bedeutung

Durch die Einhaltung dieser Praktiken werden Ihre Skripte nicht nur besser lesbar und wartbar, sondern auch zuverlässiger und flexibler.

6.3 Variablen: Deklaration, Verwendung und Scoping

Variablen sind das Rückgrat jeder Programmiersprache und stellen benannte Speicherorte dar, die Daten enthalten können. In Shell-Skripten ermöglichen Variablen die Speicherung von Werten, die später im Skript verwendet werden können, was den Code lesbarer, wartbarer und dynamischer macht. In diesem Abschnitt werden wir die Grundlagen der Variablendeklaration und -verwendung in Bash-Skripten behandeln sowie fortgeschrittene Konzepte wie Scoping und Datentypen erläutern.

6.3.1 Deklaration und Initialisierung von Variablen

In Bash erfolgt die Deklaration einer Variable durch einfache Zuweisung eines Wertes. Die Syntax ist dabei unkompliziert:

variable_name=wert

Hierbei sind folgende Punkte zu beachten:

• Es dürfen keine Leerzeichen vor oder nach dem Gleichheitszeichen stehen
• Der Variablenname steht links vom Gleichheitszeichen, der Wert rechts
• Anführungszeichen sind nur erforderlich, wenn der Wert Leerzeichen oder Sonderzeichen enthält

Beispiele für korrekte Variablendeklarationen:

name="Max Mustermann"     # String mit Leerzeichen, Anführungszeichen notwendig
alter=42                  # Zahl, keine Anführungszeichen nötig
datei="/etc/hosts"        # Pfad, Anführungszeichen optional
ist_aktiv=true            # Boolescher Wert (in Bash als String gespeichert)

Beispiele für häufige Fehler bei der Variablendeklaration:

name = "Max Mustermann"   # Falsch: Leerzeichen um das Gleichheitszeichen
42alter=42                # Falsch: Variablenname beginnt mit einer Ziffer
user-name="max"           # Falsch: Bindestrich im Variablennamen

6.3.1.1 Namenskonventionen für Variablen

Für Variablennamen in Bash gelten folgende Regeln:

1. Variablennamen dürfen nur Buchstaben (a-z, A-Z), Ziffern (0-9) und Unterstriche (_) enthalten
2. Der erste Zeichen darf keine Ziffer sein
3. Bash unterscheidet zwischen Groß- und Kleinschreibung (name und NAME sind unterschiedliche Variablen)
4. Reservierte Wörter (wie if, then, else) dürfen nicht als Variablennamen verwendet werden

Als bewährte Praxis haben sich folgende Konventionen etabliert:

• Lokale Variablen: Verwendung von Kleinbuchstaben, bei mehreren Wörtern durch Unterstriche getrennt (z.B. user_name)
• Globale/Konstante Variablen: Verwendung von Großbuchstaben, bei mehreren Wörtern durch Unterstriche getrennt (z.B. MAX_CONNECTIONS)
• Interne/temporäre Variablen: Oft mit Unterstrich beginnend (z.B. _temp_file)

6.3.2 Zugriff auf Variablenwerte

Um auf den Wert einer Variable zuzugreifen, setzen Sie ein Dollarzeichen ($) vor den Variablennamen:

name="Max"
echo "Hallo, $name!"  # Ausgabe: Hallo, Max!

Die Verwendung von geschweiften Klammern um den Variablennamen ist optional, wird aber empfohlen, um Mehrdeutigkeiten zu vermeiden:

name="Max"
echo "Hallo, ${name}!"  # Empfohlen: Klare Abgrenzung des Variablennamens

Die geschweiften Klammern sind besonders wichtig, wenn der Variablenname direkt von anderen Zeichen gefolgt wird:

name="Max"
echo "Hallo, ${name}imus!"  # Ausgabe: Hallo, Maximus!
echo "Hallo, $nameimus!"    # Fehler oder leere Ausgabe, da $nameimus als Variable interpretiert wird

6.3.2.1 Variablensubstitution und -modifikation

Bash bietet verschiedene Möglichkeiten zur Modifikation von Variablenwerten während des Zugriffs:

# Standardwert festlegen, falls Variable nicht gesetzt oder leer ist
echo "Hallo, ${name:-Gast}!"  # Wenn $name leer ist: "Hallo, Gast!"

# Standardwert festlegen und Variable setzen
echo "Hallo, ${name:=Gast}!"  # Setzt $name auf "Gast", wenn es leer ist

# Alternativwert ausgeben, wenn Variable gesetzt und nicht leer ist
echo "Status: ${error:+Es ist ein Fehler aufgetreten}"

# Fehlermeldung ausgeben, wenn Variable nicht gesetzt oder leer ist
echo "Benutzer: ${username:?Benutzername nicht angegeben}"

# Substring extrahieren (ab Position 0, 3 Zeichen)
echo "${name:0:3}"  # Gibt die ersten 3 Zeichen von $name aus

Diese Substitutionsmechanismen sind besonders nützlich für die robuste Fehlerbehandlung und die Verarbeitung von Benutzereingaben.

6.3.3 Typen von Variablen in Bash

Obwohl Bash grundsätzlich eine typlose Sprache ist (alle Variablen werden intern als Strings gespeichert), unterstützt sie die Arbeit mit verschiedenen Datentypen:

6.3.3.1 Strings (Zeichenketten)

Strings sind der häufigste Variablentyp in Bash-Skripten:

name="Max Mustermann"
greeting="Hallo, $name"
echo "$greeting"  # Ausgabe: Hallo, Max Mustermann

# Mehrere Strings verbinden (Konkatenation)
first_name="Max"
last_name="Mustermann"
full_name="$first_name $last_name"
echo "$full_name"  # Ausgabe: Max Mustermann

# Länge eines Strings ermitteln
echo "${#name}"  # Ausgabe: 14

Für die Arbeit mit Strings bietet Bash verschiedene Operationen zur String-Manipulation:

text="Bash-Scripting ist mächtig"

# Ersetzen des ersten Vorkommens
echo "${text/mächtig/leistungsstark}"  # Ausgabe: Bash-Scripting ist leistungsstark

# Ersetzen aller Vorkommen
echo "${text//i/I}"  # Ersetzt alle 'i' durch 'I'

# Löschen vom Anfang (kürzeste Übereinstimmung)
echo "${text#Bash-}"  # Ausgabe: Scripting ist mächtig

# Löschen vom Anfang (längste Übereinstimmung)
echo "${text##*ist }"  # Ausgabe: mächtig

# Löschen vom Ende (kürzeste Übereinstimmung)
echo "${text%mächtig}"  # Ausgabe: Bash-Scripting ist 

# Löschen vom Ende (längste Übereinstimmung)
echo "${text%%ist*}"  # Ausgabe: Bash-Scripting 

# Groß-/Kleinschreibung ändern
echo "${text^^}"  # Alles in Großbuchstaben
echo "${text,,}"  # Alles in Kleinbuchstaben

6.3.3.2 Zahlen und arithmetische Operationen

Obwohl Bash keine nativen numerischen Typen hat, können arithmetische Operationen durchgeführt werden:

# Arithmetische Expansion
a=5
b=3
sum=$((a + b))
echo "$sum"  # Ausgabe: 8

# Alternative Syntax
let "product = a * b"
echo "$product"  # Ausgabe: 15

# Inkrement/Dekrement
((a++))
echo "$a"  # Ausgabe: 6

# Komplexere Ausdrücke
result=$(( (a + b) * 2 ))
echo "$result"  # Ausgabe: 18

Für komplexere mathematische Operationen oder Fließkommazahlen kann das Kommandozeilenprogramm bc verwendet werden:

# Berechnung mit Fließkommazahlen
pi=$(echo "scale=10; 4*a(1)" | bc -l)
echo "Pi ≈ $pi"

# Division mit Fließkommazahlen
result=$(echo "scale=2; 5/3" | bc)
echo "$result"  # Ausgabe: 1.66

6.3.3.3 Arrays

Bash unterstützt indizierte Arrays und, ab Bash 4.0, assoziative Arrays (Dictionaries):

Indizierte Arrays (nullbasierter Index):

# Deklaration und Initialisierung
farben=("Rot" "Grün" "Blau")

# Alternative Deklaration
declare -a zahlen
zahlen[0]=1
zahlen[1]=2
zahlen[2]=3

# Zugriff auf Elemente
echo "${farben[0]}"  # Ausgabe: Rot

# Alle Elemente ausgeben
echo "${farben[@]}"  # Ausgabe: Rot Grün Blau

# Anzahl der Elemente
echo "${#farben[@]}"  # Ausgabe: 3

# Element hinzufügen
farben+=("Gelb")

# Indizes auflisten
echo "${!farben[@]}"  # Ausgabe: 0 1 2 3

# Element entfernen
unset farben[1]  # Entfernt "Grün"
echo "${farben[@]}"  # Ausgabe: Rot Blau Gelb

Assoziative Arrays (Schlüssel-Wert-Paare, ab Bash 4.0):

# Deklaration und Initialisierung
declare -A benutzer
benutzer["name"]="Max"
benutzer["alter"]=30
benutzer["beruf"]="Entwickler"

# Alternative Deklaration
declare -A hauptstaedte=( ["Deutschland"]="Berlin" ["Frankreich"]="Paris" ["Italien"]="Rom" )

# Zugriff auf Elemente
echo "${benutzer["name"]}"  # Ausgabe: Max

# Alle Werte ausgeben
echo "${benutzer[@]}"  # Ausgabe: Max 30 Entwickler

# Alle Schlüssel ausgeben
echo "${!benutzer[@]}"  # Ausgabe: name alter beruf

# Element hinzufügen
benutzer["adresse"]="Musterstraße 1"

# Element entfernen
unset benutzer["beruf"]

6.3.4 Variable Scoping: Lokale und globale Variablen

Im Kontext der Bash-Shell gibt es zwei Hauptebenen für Variablen: globale und lokale Variablen.

6.3.4.1 Globale Variablen

Globale Variablen sind innerhalb des gesamten Skripts und in allen Funktionen sichtbar. Standardmäßig sind alle in einem Skript deklarierten Variablen global:

#!/usr/bin/env bash

# Globale Variable
global_var="Ich bin global"

function beispiel_funktion() {
    echo "In der Funktion: $global_var"
    
    # Änderung der globalen Variable
    global_var="Geändert in der Funktion"
}

echo "Vor dem Funktionsaufruf: $global_var"
beispiel_funktion
echo "Nach dem Funktionsaufruf: $global_var"

Ausgabe:

Vor dem Funktionsaufruf: Ich bin global
In der Funktion: Ich bin global
Nach dem Funktionsaufruf: Geändert in der Funktion

6.3.4.2 Lokale Variablen

Lokale Variablen sind nur innerhalb der Funktion sichtbar, in der sie deklariert wurden. Sie werden mit dem Schlüsselwort local deklariert:

#!/usr/bin/env bash

function beispiel_funktion() {
    # Lokale Variable
    local lokale_var="Ich bin lokal"
    echo "In der Funktion: $lokale_var"
}

beispiel_funktion
echo "Nach dem Funktionsaufruf: $lokale_var"  # $lokale_var ist hier nicht definiert

Ausgabe:

In der Funktion: Ich bin lokal
Nach dem Funktionsaufruf: 

Die Verwendung lokaler Variablen in Funktionen ist eine wichtige Best Practice, um unbeabsichtigte Seiteneffekte zu vermeiden und die Wartbarkeit des Codes zu verbessern.

6.3.4.3 Verschachtelung und Scoping-Regeln

Bei der Verschachtelung von Funktionen gelten folgende Regeln:

#!/usr/bin/env bash

global_var="Global"

function aussere_funktion() {
    local aussen_var="Außen"
    echo "In äußerer Funktion - global_var: $global_var, aussen_var: $aussen_var, innen_var: $innen_var"
    
    function innere_funktion() {
        local innen_var="Innen"
        echo "In innerer Funktion - global_var: $global_var, aussen_var: $aussen_var, innen_var: $innen_var"
    }
    
    innere_funktion
    echo "Nach innerer Funktion - global_var: $global_var, aussen_var: $aussen_var, innen_var: $innen_var"
}

aussere_funktion

Ausgabe:

In äußerer Funktion - global_var: Global, aussen_var: Außen, innen_var: 
In innerer Funktion - global_var: Global, aussen_var: Außen, innen_var: Innen
Nach innerer Funktion - global_var: Global, aussen_var: Außen, innen_var: 

Hier sehen wir, dass: - Die globale Variable überall sichtbar ist - Die Variable der äußeren Funktion in der inneren Funktion sichtbar ist - Die Variable der inneren Funktion nur in der inneren Funktion sichtbar ist

6.3.5 Konstanten in Bash

Bash unterstützt die Deklaration von Konstanten mit dem Befehl declare und der Option -r (readonly):

# Konstante deklarieren
declare -r PI=3.14159
declare -r MAX_VERSUCHE=3

# Versuch, eine Konstante zu ändern
PI=3.14  # Führt zu einem Fehler: "PI: readonly variable"

Für Skripts, die viele Konstanten verwenden, ist es eine gute Praxis, diese am Anfang des Skripts zu deklarieren und in Großbuchstaben zu schreiben, um sie von regulären Variablen zu unterscheiden.

6.3.6 Häufige Fallstricke bei der Verwendung von Variablen

Beim Arbeiten mit Variablen in Bash gibt es einige häufige Fallstricke, die zu schwer zu findenden Fehlern führen können:

1. Leerzeichen um das Gleichheitszeichen:

   name = "Max"  # Falsch: Bash interpretiert 'name' als Befehl
   name="Max"    # Korrekt

2. Fehlende Anführungszeichen bei Werten mit Leerzeichen:

   name=Max Mustermann  # Falsch: Bash interpretiert 'Mustermann' als separaten Befehl
   name="Max Mustermann"  # Korrekt

3. Fehlende geschweifte Klammern bei Variablenerweiterung:

   echo "Hallo $nameErweiterung"  # Falsch: Bash sucht nach der Variable $nameErweiterung
   echo "Hallo ${name}Erweiterung"  # Korrekt

4. Vergleich von Zahlen mit Zeichenkettenoperatoren:

   if [ $zahl = 5 ]; then  # Führt zu Fehlern, wenn $zahl leer ist oder Leerzeichen enthält
   if [ "$zahl" = 5 ]; then  # Besser: Variablenwert in Anführungszeichen
   if [ "$zahl" -eq 5 ]; then  # Korrekt für numerische Vergleiche

5. Unbeabsichtigte Globbing-Expansion:

   file="*.txt"
   echo $file  # Gibt alle .txt-Dateien im aktuellen Verzeichnis aus
   echo "$file"  # Korrekt: Gibt literal "*.txt" aus

6. Vergessen, den Rückgabewert eines Befehls zu überprüfen:

   ergebnis=$(befehl_der_fehlschlagen_kann)
   echo "$ergebnis"  # Möglicherweise leer bei Fehler
   
   # Besser:
   if ! ergebnis=$(befehl_der_fehlschlagen_kann); then
       echo "Fehler bei der Befehlsausführung"
       exit 1
   fi
   echo "$ergebnis"

7. Versehentliches Überschreiben wichtiger Variablen:

   PATH="mein/pfad"  # Überschreibt die wichtige Umgebungsvariable PATH
   my_path="mein/pfad"  # Besser: Eindeutiger Name

6.3.7 Best Practices für die Verwendung von Variablen

Um robuste und wartbare Skripte zu schreiben, sollten Sie diese Best Practices befolgen:

1. Immer aussagekräftige Variablennamen verwenden:

   # Schlecht
   x=5
   
   # Gut
   max_retries=5

2. Konsistenten Stil für Variablennamen verwenden:

   # Wählen Sie einen Stil und bleiben Sie dabei
   user_name="Max"  # snake_case
   maxRetries=5     # camelCase

3. Variablen immer in doppelte Anführungszeichen setzen, wenn sie verwendet werden:

   echo "$variable"  # Verhindert Probleme mit Leerzeichen und Sonderzeichen

4. Lokale Variablen in Funktionen verwenden:

   function process_file() {
       local file="$1"  # lokale Variable
       # ...
   }

5. Standardwerte für Variablen definieren:

   name="${1:-Gast}"  # Setzt $name auf "Gast", wenn kein Parameter übergeben wird

6. Validierung von Variablenwerten:

   if [[ ! "$zahl" =~ ^[0-9]+$ ]]; then
       echo "Fehler: $zahl ist keine Zahl"
       exit 1
   fi

7. Konstanten für unveränderliche Werte verwenden:

   declare -r CONFIG_FILE="/etc/myapp.conf"

8. Verschachtelte Variablenexpansion vorsichtig verwenden:

   # Komplex und fehleranfällig
   eval "echo \${${prefix}_var}"
   
   # Besser: Assoziatives Array verwenden
   declare -A vars
   vars["prefix_var"]="Wert"
   echo "${vars["${prefix}_var"]}"

6.4 Umgebungsvariablen und ihre Bedeutung

Umgebungsvariablen sind ein zentraler Bestandteil des Unix/Linux-Betriebssystems und spielen eine wichtige Rolle in der Shell-Programmierung. Sie dienen als globale Einstellungen, die das Verhalten von Programmen und des Systems selbst beeinflussen können. In diesem Abschnitt werden wir uns mit der Bedeutung von Umgebungsvariablen, ihrer Verwendung und den wichtigsten vordefinierten Umgebungsvariablen beschäftigen.

6.4.1 Was sind Umgebungsvariablen?

Umgebungsvariablen sind spezielle Variablen, die von der Shell verwaltet werden und an alle Prozesse weitergegeben werden, die von dieser Shell gestartet werden. Sie dienen zur Konfiguration der Systemumgebung und zur Kommunikation zwischen Prozessen.

Im Gegensatz zu regulären Shell-Variablen, die nur innerhalb der aktuellen Shell-Instanz zugänglich sind, werden Umgebungsvariablen an Kindprozesse vererbt. Dies macht sie zu einem mächtigen Werkzeug für die Konfiguration von Anwendungen und Diensten.

6.4.2 Anzeigen und Manipulieren von Umgebungsvariablen

6.4.2.1 Anzeigen von Umgebungsvariablen

Um alle Umgebungsvariablen anzuzeigen, können Sie den Befehl env oder printenv verwenden:

env          # Zeigt alle Umgebungsvariablen an
printenv     # Alternative zu env

printenv PATH  # Zeigt nur den Wert der PATH-Variable an
echo "$PATH"   # Alternative Methode

6.4.2.2 Setzen von Umgebungsvariablen

Umgebungsvariablen können auf verschiedene Weise gesetzt werden:

1. Temporär für einen einzelnen Befehl:

   DEBUG=1 ./mein_skript.sh  # Setzt die Umgebungsvariable DEBUG nur für diesen Befehl

2. Temporär für die aktuelle Shell-Sitzung:

   export DEBUG=1            # Setzt und exportiert die Variable
   ./mein_skript.sh          # Das Skript kann nun auf $DEBUG zugreifen

3. Dauerhaft für einen Benutzer (durch Eintrag in die Shell-Initialisierungsdateien):

   # In ~/.bashrc oder ~/.bash_profile hinzufügen:
   export EDITOR=vim

4. Dauerhaft für alle Benutzer (systemweit):

   # In /etc/profile oder eine Datei in /etc/profile.d/ hinzufügen:
   export JAVA_HOME=/usr/lib/jvm/default-java

6.4.2.3 Unterschied zwischen export und einfacher Zuweisung

Es ist wichtig, den Unterschied zwischen einer einfachen Variablenzuweisung und dem Export einer Variable zu verstehen:

# Nur eine Shell-Variable, nicht an Kindprozesse vererbt
MY_VAR="Wert"

# Eine Umgebungsvariable, wird an Kindprozesse vererbt
export MY_ENV_VAR="Wert"

Um zu überprüfen, ob eine Variable exportiert wurde:

declare -p MY_VAR      # Zeigt Variablendeklaration an, mit oder ohne 'export'-Attribut

6.4.3 Wichtige vordefinierte Umgebungsvariablen

Das Linux/Unix-System und die Bash stellen zahlreiche vordefinierte Umgebungsvariablen bereit:

6.4.3.1 Systempfade und Verzeichnisse

# Suchpfade für ausführbare Dateien (durch Doppelpunkt getrennt)
echo "$PATH"

# Aktuelles Arbeitsverzeichnis
echo "$PWD"

# Home-Verzeichnis des aktuellen Benutzers
echo "$HOME"

# Temporäres Verzeichnis
echo "$TMPDIR"  # Falls nicht gesetzt, wird standardmäßig /tmp verwendet

6.4.3.2 Benutzerinformationen

# Aktueller Benutzername
echo "$USER" 
echo "$LOGNAME"  # Alternative zu USER

# Aktueller Host-Name
echo "$HOSTNAME"

6.4.3.3 Shell-Konfiguration

# Shell-Typ
echo "$SHELL"  # z.B. /bin/bash

# Bash-Version
echo "$BASH_VERSION"

# Umgebungsvariable für die Anzeige des Shell-Prompts
echo "$PS1"

# Standardeditor
echo "$EDITOR"

6.4.3.4 Lokalisierung und Sprache

# Spracheinstellungen (bestimmt Ausgabesprache vieler Programme)
echo "$LANG"
echo "$LC_ALL"  # Überschreibt alle LC_* Variablen

# Zeichensatzeinstellung
echo "$LC_CTYPE"

6.4.3.5 Prozess- und Skript-Informationen

# Process-ID des aktuellen Shell-Prozesses
echo "$$"

# Process-ID des letzten im Hintergrund gestarteten Prozesses
echo "$!"

# Exit-Status des letzten Befehls
echo "$?"

# Skriptname (in einem Skript)
echo "$0"

# Anzahl der übergebenen Argumente (in einem Skript)
echo "$#"

# Alle übergebenen Argumente (in einem Skript)
echo "$@"

6.4.4 Verwendung von Umgebungsvariablen in Skripten

Umgebungsvariablen werden häufig verwendet, um das Verhalten von Skripten und Programmen zu steuern. Hier sind einige typische Anwendungsfälle:

6.4.4.1 Konfiguration von Pfaden und Dateispeicherorten

#!/usr/bin/env bash

# Verwendung des Home-Verzeichnisses für Konfigurationsdateien
CONFIG_DIR="${HOME}/.myapp"
CONFIG_FILE="${CONFIG_DIR}/config.ini"

# Temporäre Dateien im System-Temp-Verzeichnis
TEMP_DIR="${TMPDIR:-/tmp}"
TEMP_FILE="${TEMP_DIR}/myapp-$$.tmp"

# Erstellen des Konfigurationsverzeichnisses, falls es nicht existiert
mkdir -p "$CONFIG_DIR"

6.4.4.2 Anpassung des Verhaltens basierend auf der Umgebung

#!/usr/bin/env bash

# Debug-Modus aktivieren, wenn DEBUG gesetzt ist
if [ -n "$DEBUG" ]; then
    echo "Debug-Modus aktiviert"
    set -x  # Gibt jeden Befehl vor der Ausführung aus
fi

# Unterschiedliches Verhalten je nach Umgebung
case "${ENVIRONMENT:-production}" in
    development)
        echo "Entwicklungsumgebung - Verwende lokale Konfiguration"
        CONFIG_FILE="./config.dev.ini"
        ;;
    testing)
        echo "Testumgebung - Verwende Test-Konfiguration"
        CONFIG_FILE="/etc/myapp/config.test.ini"
        ;;
    production)
        echo "Produktionsumgebung - Verwende Produktionskonfiguration"
        CONFIG_FILE="/etc/myapp/config.prod.ini"
        ;;
esac

6.4.4.3 Steuerung der Ausgabeformatierung

#!/usr/bin/env bash

# Prüfen, ob das Terminal Farben unterstützt
if [ -t 1 ] && [ -n "$TERM" ] && [ "$TERM" != "dumb" ]; then
    # Terminal unterstützt Farben
    RED='\033[0;31m'
    GREEN='\033[0;32m'
    YELLOW='\033[0;33m'
    NC='\033[0m' # No Color
else
    # Keine Farbunterstützung
    RED=""
    GREEN=""
    YELLOW=""
    NC=""
fi

# Farbige Ausgabe
echo -e "${GREEN}Erfolg:${NC} Operation abgeschlossen"
echo -e "${YELLOW}Warnung:${NC} Datei existiert bereits"
echo -e "${RED}Fehler:${NC} Datei nicht gefunden"

# Keine Farben, wenn NO_COLOR gesetzt ist (wird von einigen Tools unterstützt)
if [ -n "$NO_COLOR" ]; then
    RED=""
    GREEN=""
    YELLOW=""
    NC=""
fi

6.4.5 Setzen und Modifizieren von Umgebungsvariablen

6.4.5.1 Modifizieren von PATH

Eine der häufigsten Modifikationen ist das Hinzufügen von Verzeichnissen zum PATH:

#!/usr/bin/env bash

# Neues Verzeichnis am Anfang des PATH hinzufügen (höhere Priorität)
export PATH="/usr/local/bin:$PATH"

# Neues Verzeichnis am Ende des PATH hinzufügen (niedrigere Priorität)
export PATH="$PATH:/home/user/bin"

# Mehrere Verzeichnisse hinzufügen
export PATH="/opt/tools/bin:/opt/tools/scripts:$PATH"

# Überpüfung, ob ein Verzeichnis bereits im PATH ist, bevor es hinzugefügt wird
if [[ ":$PATH:" != *":/home/user/bin:"* ]]; then
    export PATH="$PATH:/home/user/bin"
fi

6.4.5.2 Temporäre Umgebungsänderungen

Manchmal möchten Sie eine Umgebungsvariable nur temporär ändern, ohne die ursprüngliche Einstellung zu verlieren:

#!/usr/bin/env bash

# Originalen PATH speichern
OLD_PATH="$PATH"

# PATH temporär ändern
export PATH="/spezial/bin:$PATH"

# Befehle ausführen mit dem modifizierten PATH
special_command

# Ursprünglichen PATH wiederherstellen
export PATH="$OLD_PATH"

6.4.5.3 Umgebungsvariablen für Unterprozesse setzen

Sie können die Umgebung für einen Unterprozess ändern, ohne die aktuelle Shell zu beeinflussen:

# Nur für diesen Befehl
LANG=de_DE.UTF-8 date

# Für eine Gruppe von Befehlen
(
    export LC_ALL=fr_FR.UTF-8
    export TZ="Europe/Paris"
    date
    cal
)

# Die Hauptshell bleibt unverändert
date

6.4.6 Persistenz von Umgebungsvariablen

Umgebungsvariablen, die in der Shell gesetzt werden, existieren nur während der aktuellen Shell-Sitzung. Um Umgebungsvariablen dauerhaft zu speichern, müssen sie in entsprechenden Konfigurationsdateien gesetzt werden. Die genaue Methode hängt von der verwendeten Shell und dem gewünschten Gültigkeitsbereich ab.

6.4.6.1 Shell-Initialisierungsdateien für Bash

Für die Bash-Shell können folgende Dateien verwendet werden:

1. Nur für den aktuellen Benutzer:

   • ~/.bashrc: Wird geladen für interaktive Non-Login-Shells (z.B. bei Öffnen eines neuen Terminal-Fensters)
   • ~/.bash_profile, ~/.profile oder ~/.bash_login: Wird geladen für Login-Shells (z.B. bei der Anmeldung am System)

   Beispiel für einen Eintrag in ~/.bashrc:

   # Eigene Binärdateien zum PATH hinzufügen
   export PATH="$HOME/bin:$PATH"
   
   # Editor für verschiedene Programme festlegen
   export EDITOR="vim"
   
   # Eigene Alias-Definitionen
   export JAVA_HOME="/usr/lib/jvm/java-11-openjdk"

2. Systemweit für alle Benutzer:

   • /etc/profile: Wird für alle Benutzer bei Login-Shells geladen
   • /etc/bash.bashrc oder /etc/bashrc: Wird für alle Benutzer bei interaktiven Shells geladen
   • Dateien im Verzeichnis /etc/profile.d/: Werden automatisch von /etc/profile eingebunden

   Beispiel für einen Eintrag in /etc/profile.d/java.sh:

   # Systemweite Java-Einstellungen
   export JAVA_HOME=/usr/lib/jvm/default-java
   export PATH="$JAVA_HOME/bin:$PATH"

6.4.6.2 Best Practices für persistente Umgebungsvariablen

1. Organisieren Sie Ihre Umgebungsvariablen thematisch:

   # In ~/.bashrc oder separaten Dateien in ~/.bashrc.d/
   
   # Java-Entwicklungsumgebung
   export JAVA_HOME="/usr/lib/jvm/java-11"
   export MAVEN_HOME="/opt/maven"
   
   # Python-Entwicklungsumgebung
   export PYTHONPATH="$HOME/lib/python"
   export VIRTUAL_ENV_DISABLE_PROMPT=1

2. Verwenden Sie bedingte Einstellungen:

   # Nur hinzufügen, wenn das Verzeichnis existiert
   if [ -d "$HOME/bin" ]; then
       export PATH="$HOME/bin:$PATH"
   fi
   
   # Bevorzugten Editor setzen
   if command -v nvim &> /dev/null; then
       export EDITOR="nvim"
   elif command -v vim &> /dev/null; then
       export EDITOR="vim"
   else
       export EDITOR="nano"
   fi

3. Vermeiden Sie doppelte Einträge im PATH:

   # Funktion zum sicheren Hinzufügen zum PATH
   add_to_path() {
       if [[ ":$PATH:" != *":$1:"* ]]; then
           export PATH="$1:$PATH"
       fi
   }
   
   # Anwendung
   add_to_path "$HOME/bin"
   add_to_path "/usr/local/go/bin"

6.4.7 Umgebungsvariablen in Skripten vs. interaktiven Shells

Es ist wichtig, die Unterschiede in der Behandlung von Umgebungsvariablen zwischen interaktiven Shells und Shell-Skripten zu verstehen:

6.4.7.1 In interaktiven Shells:

• Umgebungsvariablen werden beim Starten der Shell aus den Initialisierungsdateien geladen
• Manuell gesetzte Umgebungsvariablen bleiben während der gesamten Shell-Sitzung erhalten
• Sie können leicht durch nachfolgende Befehle geändert werden

6.4.7.2 In Shell-Skripten:

• Skripte erben die Umgebungsvariablen von der aufrufenden Shell
• In Skripten definierte Umgebungsvariablen haben keine Auswirkung auf die aufrufende Shell
• Die Lebensdauer ist auf die Ausführungsdauer des Skripts beschränkt

Um dies zu verdeutlichen, betrachten wir folgendes Beispiel:

#!/usr/bin/env bash
# Dateiname: set_vars.sh

# Reguläre Variable
MY_VAR="im Skript definiert"

# Umgebungsvariable
export MY_ENV_VAR="im Skript exportiert"

echo "Im Skript: MY_VAR = $MY_VAR"
echo "Im Skript: MY_ENV_VAR = $MY_ENV_VAR"

Wenn dieses Skript ausgeführt wird:

$ ./set_vars.sh
Im Skript: MY_VAR = im Skript definiert
Im Skript: MY_ENV_VAR = im Skript exportiert

$ echo $MY_VAR
# Keine Ausgabe, da die Variable nicht exportiert wurde

$ echo $MY_ENV_VAR
# Keine Ausgabe, da die Umgebungsvariable nur im Skript existierte

Um Umgebungsvariablen von einem Skript an die aufrufende Shell zu übergeben, gibt es zwei Hauptmethoden:

1. Skript mit source oder . ausführen:

   $ source ./set_vars.sh
   # oder
   $ . ./set_vars.sh
   
   $ echo $MY_VAR
   im Skript definiert
   
   $ echo $MY_ENV_VAR
   im Skript exportiert

2. Ausgabe des Skripts in eval auswerten:

   # Ein Skript, das Shell-Befehle ausgibt
   $ cat export_vars.sh
   #!/usr/bin/env bash
   echo "export RESULT_VAR='Berechnetes Ergebnis'"
   
   # Ausführen und Auswerten
   $ eval $(./export_vars.sh)
   
   $ echo $RESULT_VAR
   Berechnetes Ergebnis

6.4.8 Sicherheitsaspekte bei der Verwendung von Umgebungsvariablen

Umgebungsvariablen können Sicherheitsrisiken darstellen, wenn sie für sensible Daten verwendet werden:

1. Sichtbarkeit für alle Prozesse:
   • Umgebungsvariablen sind für alle Prozesse des Benutzers sichtbar
   • Jedes Tool oder Skript kann auf sie zugreifen
   • Sie erscheinen in Prozesslisten und Debugging-Tools
2. Persistenz in Logs:
   • Umgebungsvariablen können versehentlich in Logdateien landen
   • Häufig werden sie bei Fehlerberichten ausgegeben
3. Alternativen für sensible Daten:
   • Verwenden Sie Dateien mit eingeschränkten Berechtigungen für Passwörter und API-Schlüssel
   • Nutzen Sie spezielle Tools wie keyring, pass oder vault für Anmeldedaten
   • Bei Container-Anwendungen können Secrets-Management-Systeme eingesetzt werden

Beispiel für sicherere Alternativen:

#!/usr/bin/env bash

# Unsicher: Passwort in Umgebungsvariable
export DB_PASSWORD="geheim123"

# Besser: Aus Datei mit beschränkten Berechtigungen lesen
DB_PASSWORD=$(cat ~/.secrets/db_password)

# Noch besser: Tool wie 'pass' verwenden
DB_PASSWORD=$(pass database/production)

# Anschließend Passwort nur kurzzeitig im Speicher halten und nicht exportieren
mysql -u admin -p"$DB_PASSWORD" database
DB_PASSWORD=""  # Variable leeren nach Verwendung

6.4.9 Debugging von Umgebungsvariablen

Bei Problemen mit Umgebungsvariablen können folgende Techniken helfen:

1. Anzeigen aller Umgebungsvariablen:

   env | sort
   printenv | sort

2. Überprüfen einer bestimmten Variable:

   echo "$PATH"
   echo "${#PATH}"  # Länge der Variable (nützlich bei sehr langen Werten)

3. Prüfen, ob eine Variable exportiert wurde:

   declare -p PATH  # Zeigt Variablentyp und -wert an

4. Verfolgen der Shell-Initialisierung:

   # Bash mit Debugging-Option starten
   bash -x
   
   # Oder bestimmte Initialisierungsdatei mit Debugging ausführen
   bash -x ~/.bashrc

5. Temporäre Shell mit sauberer Umgebung:

   # Startet eine neue Bash ohne Umgebungsvariablen zu erben
   env -i bash --noprofile --norc

6.4.10 Umgebungsvariablen vs. Shell-Variablen

Zum Abschluss eine Gegenüberstellung der wichtigsten Eigenschaften:

Die richtige Verwendung von Shell-Variablen und Umgebungsvariablen ist ein wesentlicher Bestandteil effektiver Shell-Skripte. Durch das Verständnis ihrer Unterschiede und Einsatzbereiche können Sie robustere und wartbarere Skripte erstellen, die harmonisch mit der Shell-Umgebung und anderen Programmen interagieren.

6.5 Eingebaute Variablen in der Bash-Shell

Die Bash-Shell und andere Unix-Shells stellen eine Reihe von speziellen eingebauten Variablen bereit, die den Zugriff auf wichtige Informationen über die aktuelle Shell-Umgebung, den Ausführungskontext und die übergebenen Parameter ermöglichen. Diese Variablen sind leistungsstarke Werkzeuge für Shell-Skriptentwickler, da sie den Zugriff auf Laufzeitinformationen, die Steuerung des Programmflusses und die Implementierung von robusten Fehlerbehandlungsroutinen erleichtern.

6.5.1 Positionsparameter

Positionsparameter sind Variablen, die die an ein Skript oder eine Funktion übergebenen Argumente enthalten.

6.5.1.1 $0 - Skriptname

Die Variable $0 enthält den Namen des Skripts oder der Shell, wie es in der Befehlszeile aufgerufen wurde:

#!/usr/bin/env bash
echo "Dieses Skript heißt: $0"

Ausgabe:

Dieses Skript heißt: ./mein_skript.sh

Im Kontext einer Funktion enthält $0 weiterhin den Skriptnamen, nicht den Funktionsnamen.

6.5.1.2 $1, $2, $3, … - Positionsparameter

Diese Variablen enthalten die einzelnen Argumente, die dem Skript oder der Funktion übergeben wurden:

#!/usr/bin/env bash
echo "Erstes Argument: $1"
echo "Zweites Argument: $2"
echo "Drittes Argument: $3"

Ausgabe bei Aufruf mit ./mein_skript.sh datei.txt 42 "Hallo Welt":

Erstes Argument: datei.txt
Zweites Argument: 42
Drittes Argument: Hallo Welt

Im Kontext einer Funktion beziehen sich diese Variablen auf die Argumente der Funktion, nicht auf die des Skripts.

6.5.1.3 $# - Anzahl der Argumente

Diese Variable enthält die Anzahl der an das Skript oder die Funktion übergebenen Argumente:

#!/usr/bin/env bash
echo "Anzahl der Argumente: $#"

function beispiel() {
    echo "Anzahl der Funktionsargumente: $#"
}

beispiel 1 2 3 4

Ausgabe bei Aufruf mit ./mein_skript.sh a b c:

Anzahl der Argumente: 3
Anzahl der Funktionsargumente: 4

6.5.1.4 $@ - Alle Argumente als separate Strings

Diese spezielle Variable repräsentiert alle übergebenen Argumente, wobei jedes Argument als separater String behandelt wird. Dies ist besonders nützlich, wenn Argumente mit Leerzeichen korrekt verarbeitet werden sollen:

#!/usr/bin/env bash
echo "Alle Argumente: $@"

# Iteration über alle Argumente
for arg in "$@"; do
    echo "Argument: $arg"
done

Ausgabe bei Aufruf mit ./mein_skript.sh "Erster Eintrag" Zweiter "Dritter Eintrag":

Alle Argumente: Erster Eintrag Zweiter Dritter Eintrag
Argument: Erster Eintrag
Argument: Zweiter
Argument: Dritter Eintrag

Die Anführungszeichen um "$@" sind entscheidend, um Argumente mit Leerzeichen korrekt zu behandeln.

6.5.1.5 $* - Alle Argumente als ein String

Ähnlich wie $@, aber behandelt alle Argumente als einen einzelnen String, getrennt durch das erste Zeichen der Umgebungsvariable IFS (standardmäßig ein Leerzeichen):

#!/usr/bin/env bash
echo "Alle Argumente als ein String: $*"

# Iteration über alle Wörter in $*
for word in $*; do
    echo "Wort: $word"
done

# Mit Anführungszeichen
for item in "$*"; do
    echo "Item: $item"
done

Ausgabe bei Aufruf mit ./mein_skript.sh "Erster Eintrag" Zweiter "Dritter Eintrag":

Alle Argumente als ein String: Erster Eintrag Zweiter Dritter Eintrag
Wort: Erster
Wort: Eintrag
Wort: Zweiter
Wort: Dritter
Wort: Eintrag
Item: Erster Eintrag Zweiter Dritter Eintrag

Die Unterschiede zwischen $@ und $* sind subtil, aber wichtig: - "$@" expandiert zu "$1" "$2" "$3" ... (jedes Argument wird als separater String behandelt) - "$*" expandiert zu "$1 $2 $3 ..." (alle Argumente als ein einzelner String, getrennt durch das erste Zeichen in IFS)

6.5.2 Status- und Prozessvariablen

6.5.2.1 $? - Exit-Status des letzten Befehls

Die Variable $? enthält den Exit-Status des zuletzt ausgeführten Befehls oder der zuletzt ausgeführten Funktion. Ein Wert von 0 bedeutet normalerweise Erfolg, während Werte ungleich 0 auf Fehler hindeuten:

#!/usr/bin/env bash
grep "muster" datei.txt
if [ $? -eq 0 ]; then
    echo "Muster gefunden"
else
    echo "Muster nicht gefunden"
fi

# Besser: Direkte Verwendung im if-Statement
if grep "muster" datei.txt; then
    echo "Muster gefunden"
else
    echo "Muster nicht gefunden"
fi

Die direkte Verwendung im if-Statement ist zu bevorzugen, da sie kürzer und weniger fehleranfällig ist.

6.5.2.2 $$ - Process ID der aktuellen Shell

Die Variable $$ enthält die Prozess-ID (PID) der aktuellen Shell-Instanz oder des Skripts:

#!/usr/bin/env bash
echo "Die PID dieses Skripts ist: $$"

# Nützlich für temporäre Dateien
TEMP_FILE="/tmp/temp_$$.txt"
echo "Temporäre Datei: $TEMP_FILE"

Diese Variable wird häufig verwendet, um eindeutige temporäre Dateinamen zu erstellen und so Konflikte zu vermeiden.

6.5.2.3 $! - Process ID des zuletzt gestarteten Hintergrundprozesses

Die Variable $! enthält die PID des zuletzt in den Hintergrund gestarteten Prozesses:

#!/usr/bin/env bash
# Starten eines Hintergrundprozesses
sleep 100 &
echo "Die PID des Hintergrundprozesses ist: $!"

# Warten auf den Hintergrundprozess
SLEEP_PID=$!
echo "Warte auf Prozess $SLEEP_PID..."
wait $SLEEP_PID
echo "Prozess $SLEEP_PID beendet"

Diese Variable ist besonders nützlich für die Überwachung und Steuerung von Hintergrundprozessen.

6.5.2.4 $- - Aktuelle Shell-Optionen

Die Variable $- enthält die aktuell aktivierten Shell-Optionen:

#!/usr/bin/env bash
echo "Aktive Shell-Optionen: $-"

# Prüfen, ob die Shell im interaktiven Modus läuft
if [[ $- == *i* ]]; then
    echo "Interaktive Shell"
else
    echo "Nicht-interaktive Shell"
fi

Die Shell-Optionen sind einzelne Buchstaben, die verschiedene Modi repräsentieren, wie z.B. i für interaktiven Modus oder x für den Debug-Modus (set -x).

6.5.2.5 $_ - Letztes Argument des letzten Befehls

Die Variable $_ enthält das letzte Argument des zuletzt ausgeführten Befehls:

#!/usr/bin/env bash
echo "Hallo Welt"
echo "Das letzte Argument war: $_"  # Ausgabe: Das letzte Argument war: Welt

mkdir -p /tmp/test/dir
cd "$_"  # Wechselt in den gerade erstellten Ordner
pwd      # Ausgabe: /tmp/test/dir

Diese Variable kann in interaktiven Shells nützlich sein, um schnell auf das letzte verwendete Argument zuzugreifen.

6.5.3 Spezielle Variablen für die Fehlerbehandlung

6.5.3.1 LINENO - Aktuelle Zeilennummer

Die Variable LINENO enthält die aktuelle Zeilennummer im Skript:

#!/usr/bin/env bash
echo "Dies ist Zeile $LINENO"

function fehler_anzeigen() {
    echo "Fehler in Zeile $LINENO"
}

fehler_anzeigen

Ausgabe:

Dies ist Zeile 2
Fehler in Zeile 5

6.5.3.2 FUNCNAME - Name der aktuellen Funktion

Die Variable FUNCNAME ist ein Array, das die aktuellen Funktionsnamen in der Aufrufhierarchie enthält:

#!/usr/bin/env bash
function c() {
    echo "In Funktion ${FUNCNAME[0]}, aufgerufen von ${FUNCNAME[1]}"
}

function b() {
    c
}

function a() {
    b
}

a
echo "Hauptskript: ${FUNCNAME[0]}"

Ausgabe:

In Funktion c, aufgerufen von b
Hauptskript: 

6.5.3.3 BASH_SOURCE - Skriptdateipfad

Die Variable BASH_SOURCE ist ein Array, das den Pfad zur Quelldatei in der Aufrufhierarchie enthält:

#!/usr/bin/env bash
echo "Dieses Skript: ${BASH_SOURCE[0]}"

function get_script_dir() {
    # Absoluter Pfad zum Skriptverzeichnis
    echo "$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
}

SCRIPT_DIR=$(get_script_dir)
echo "Skriptverzeichnis: $SCRIPT_DIR"

Diese Variable ist besonders nützlich, um den absoluten Pfad eines Skripts zu ermitteln, unabhängig davon, von wo es aufgerufen wurde.

6.5.3.4 BASH_LINENO - Zeilennummern der Aufrufhierarchie

Die Variable BASH_LINENO ist ein Array, das die Zeilennummern in der Aufrufhierarchie enthält:

#!/usr/bin/env bash
function trace() {
    echo "Aufgerufen von Zeile ${BASH_LINENO[0]} in ${BASH_SOURCE[1]}"
}

function foo() {
    trace
}

# Zeile 10
foo

Ausgabe:

Aufgerufen von Zeile 10 in ./mein_skript.sh

6.5.4 Kombination für verbesserte Fehlerdiagnose

Die obigen Variablen können kombiniert werden, um robuste Fehlerdiagnose-Funktionen zu implementieren:

#!/usr/bin/env bash

# Funktion zur Fehlerbehandlung
error_handler() {
    local line=$1
    local command=$2
    local code=$3
    local source_file=${BASH_SOURCE[1]}
    
    echo "Fehler in $source_file, Zeile $line" >&2
    echo "Befehl: $command" >&2
    echo "Exit-Status: $code" >&2
    exit $code
}

# Trap für ERROR-Ereignis, ruft error_handler mit Zeilennummer, Befehl und Exit-Status auf
trap 'error_handler ${LINENO} "$BASH_COMMAND" $?' ERR

# Fehlerbehandlung aktivieren
set -e

# Beispiel für einen fehlerhaften Befehl
echo "Vor dem Fehler"
cat /nicht/existierende/datei
echo "Nach dem Fehler (wird nie erreicht)"

Ausgabe:

Vor dem Fehler
cat: /nicht/existierende/datei: No such file or directory
Fehler in ./mein_skript.sh, Zeile 19
Befehl: cat /nicht/existierende/datei
Exit-Status: 1

6.5.5 Verwendung in Funktionsaufrufen

Die speziellen Parameter-Variablen verhalten sich unterschiedlich in Funktionen und im Hauptskript:

#!/usr/bin/env bash

# Funktion, die ihre Argumente und die Skriptargumente anzeigt
function zeige_argumente() {
    echo "--- Funktion: $FUNCNAME ---"
    echo "Funktionsargumente ($#): $@"
    echo "Erstes Funktionsargument: $1"
    echo "Skriptname: $0"
    
    # Um auf die Skriptargumente zuzugreifen, müssen diese separat übergeben werden
}

# Hauptteil des Skripts
echo "--- Hauptskript ---"
echo "Skriptargumente ($#): $@"
echo "Erstes Skriptargument: $1"
echo "Skriptname: $0"

# Funktion mit eigenen Argumenten aufrufen
zeige_argumente "Eins" "Zwei" "Drei"

Ausgabe bei Aufruf mit ./mein_skript.sh A B C:

--- Hauptskript ---
Skriptargumente (3): A B C
Erstes Skriptargument: A
Skriptname: ./mein_skript.sh
--- Funktion: zeige_argumente ---
Funktionsargumente (3): Eins Zwei Drei
Erstes Funktionsargument: Eins
Skriptname: ./mein_skript.sh

6.5.6 Manipulation von Positionsparametern

Die Positionsparameter können mit dem shift-Befehl manipuliert werden:

#!/usr/bin/env bash
echo "Alle Argumente: $@"
echo "Anzahl der Argumente: $#"
echo "Erstes Argument: $1"

# Entfernt das erste Argument und verschiebt alle anderen nach links
shift
echo "Nach shift: $@"
echo "Anzahl der Argumente: $#"
echo "Neues erstes Argument: $1"

# Mehrere Positionen auf einmal verschieben
shift 2
echo "Nach shift 2: $@"
echo "Anzahl der Argumente: $#"
echo "Neues erstes Argument: $1"

Ausgabe bei Aufruf mit ./mein_skript.sh A B C D E:

Alle Argumente: A B C D E
Anzahl der Argumente: 5
Erstes Argument: A
Nach shift: B C D E
Anzahl der Argumente: 4
Neues erstes Argument: B
Nach shift 2: D E
Anzahl der Argumente: 2
Neues erstes Argument: D

Die shift-Operation ist besonders nützlich für die Verarbeitung von Argumenten in einer Schleife oder für die Implementierung einfacher Befehlszeilenparameter.

6.5.7 Setzen von Positionsparametern

Die Positionsparameter können auch mit dem set-Befehl gesetzt oder geändert werden:

#!/usr/bin/env bash
# Aktuelle Argumente anzeigen
echo "Ursprüngliche Argumente: $@"

# Neue Positionsparameter setzen
set -- "Neu1" "Neu2" "Neu3"
echo "Neue Argumente: $@"

# Vorsicht: set ohne -- setzt Shell-Optionen
set -x  # Aktiviert Debug-Ausgabe
echo "Debug-Modus aktiviert"
set +x  # Deaktiviert Debug-Ausgabe

Das Doppel-Minuszeichen (--) trennt Optionen von Positionsparametern für den set-Befehl.

6.5.8 Praktische Anwendungsbeispiele

6.5.8.1 Robuste Fehlerbehandlung

#!/usr/bin/env bash
# Beenden bei Fehlern
set -e

# Fehlerbehandlungsfunktion
error_exit() {
    echo "Fehler: $1" >&2
    exit 1
}

# Anwendung
command_that_might_fail || error_exit "Befehl ist fehlgeschlagen in Zeile $LINENO"

# Rückgabewerte prüfen
if [ $? -ne 0 ]; then
    error_exit "Vorangegangener Befehl fehlgeschlagen"
fi

6.5.8.2 Temporäre Dateien mit eindeutigen Namen

#!/usr/bin/env bash
# Eindeutigen Dateinamen erstellen
TEMP_FILE="/tmp/tmp_$$.txt"
echo "Verwende temporäre Datei: $TEMP_FILE"

# Sicherstellen, dass die temporäre Datei gelöscht wird
trap "rm -f $TEMP_FILE" EXIT

# Datei verwenden
echo "Temporärer Inhalt" > "$TEMP_FILE"
cat "$TEMP_FILE"

Die Verwendung von $$ stellt sicher, dass der Dateiname für jede Skriptausführung eindeutig ist, und der trap-Befehl sorgt dafür, dass die temporäre Datei beim Beenden des Skripts gelöscht wird.

6.5.8.3 Verarbeitung aller Argumente

#!/usr/bin/env bash
# Werte summieren
sum=0
for num in "$@"; do
    if [[ "$num" =~ ^[0-9]+$ ]]; then
        sum=$((sum + num))
    else
        echo "Warnung: '$num' ist keine Zahl" >&2
    fi
done

echo "Summe aller Zahlen: $sum"

6.5.8.4 Überwachung von Hintergrundprozessen

#!/usr/bin/env bash
# Starten mehrerer Hintergrundprozesse
echo "Starte Hintergrundprozesse..."
sleep 10 &
PID1=$!
sleep 15 &
PID2=$!

echo "Gestartet: PID $PID1 und $PID2"

# Warten auf den ersten Prozess
echo "Warte auf Prozess $PID1..."
wait $PID1
echo "Prozess $PID1 beendet."

# Überprüfen, ob der zweite Prozess noch läuft
if kill -0 $PID2 2>/dev/null; then
    echo "Prozess $PID2 läuft noch. Beende ihn..."
    kill $PID2
else
    echo "Prozess $PID2 bereits beendet."
fi

6.5.8.5 Self-Logging-Skript

#!/usr/bin/env bash
# Funktion für Logging mit Zeilennummer
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [Zeile ${BASH_LINENO[0]}] $1"
}

# Anwendung
log "Skript gestartet"
echo "Führe Aufgabe aus..."
log "Aufgabe abgeschlossen"

function complex_task() {
    log "Komplexe Aufgabe gestartet"
    # Aufgabenlogik hier
    log "Komplexe Aufgabe beendet"
}

complex_task
log "Skript beendet"

6.5.9 Abschließende Überlegungen und Best Practices

Bei der Verwendung eingebauter Variablen in Shell-Skripten sollten folgende Punkte beachtet werden:

1. Zitierung beachten: Verwenden Sie immer Anführungszeichen um Variablen, um Probleme mit Leerzeichen und Sonderzeichen zu vermeiden:

   # Gut
   echo "Argumente: $@"
   for arg in "$@"; do echo "$arg"; done
   
   # Schlecht (kann bei Leerzeichen in Argumenten Probleme verursachen)
   echo Argumente: $@
   for arg in $@; do echo $arg; done

2. Exit-Status sofort prüfen: Die Variable $? enthält nur den Status des unmittelbar vorhergehenden Befehls:

   # Riskant, $? kann durch echo überschrieben werden
   grep "muster" datei.txt
   echo "Suche beendet"
   if [ $? -ne 0 ]; then echo "Fehler"; fi
   
   # Besser
   if grep "muster" datei.txt; then
       echo "Muster gefunden"
   else
       echo "Muster nicht gefunden"
   fi

3. Zustand der Positionsparameter bewahren: Wenn Sie shift verwenden oder Positionsparameter ändern, sichern Sie vorher den ursprünglichen Zustand, falls Sie ihn später benötigen:

   # Original-Argumente sichern
   original_args=("$@")
   
   # Argumente verarbeiten
   while [ $# -gt 0 ]; do
       # Verarbeitung...
       shift
   done
   
   # Original-Argumente wiederherstellen
   set -- "${original_args[@]}"

4. Portable Skripts: Für maximale Portabilität zwischen verschiedenen Shell-Implementierungen sollten Sie sich auf die POSIX-standardisierten Variablen beschränken und Shell-spezifische Funktionen vermeiden oder durch Alternativen absichern.

6.5.10 Tabelle der wichtigsten eingebauten Variablen

Die eingebauten Variablen der Bash und anderer Unix-Shells sind mächtige Werkzeuge, die den Zugriff auf wichtige Laufzeitinformationen, Kontextdaten und Parameter ermöglichen. Sie sind unerlässlich für die Entwicklung robuster und flexibler Shell-Skripte.

Die wichtigsten eingebauten Variablen im Überblick:

Die effektive Nutzung dieser Variablen verbessert die Funktionalität, Wartbarkeit und Robustheit Ihrer Shell-Skripte erheblich und sollte Teil des Standardrepertoires jedes Shell-Skriptentwicklers sein.

6.6 Effiziente Befehlsausführung mit xargs

Das Dienstprogramm xargs ist ein leistungsstarkes Werkzeug in der Unix/Linux-Umgebung, das die Ausführung von Befehlen mit Argumenten aus der Standardeingabe ermöglicht. Es dient als Brücke zwischen Befehlen und ist besonders nützlich für die Verarbeitung großer Datenmengen oder wenn die Anzahl der zu verarbeitenden Elemente die Befehlszeilenlimit überschreiten würde.

6.6.1 Grundlegendes Konzept und Funktionsweise

xargs nimmt die Ausgabe eines Befehls aus der Standardeingabe entgegen, teilt sie in einzelne Argumente auf und verwendet diese als Parameter für einen anderen Befehl. Die grundlegende Syntax lautet:

befehl1 | xargs [optionen] befehl2

Hierbei: - befehl1 erzeugt eine Ausgabe, die an xargs weitergeleitet wird - xargs konvertiert diese Ausgabe in Befehlszeilenargumente - befehl2 wird mit diesen Argumenten ausgeführt

6.6.2 Einfache Beispiele

6.6.2.1 Dateien basierend auf Suchergebnissen löschen

Ein klassischer Anwendungsfall ist das Löschen von Dateien, die bestimmten Kriterien entsprechen:

# Alle temporären Dateien älter als 7 Tage finden und löschen
find /tmp -type f -mtime +7 | xargs rm -f

6.6.2.2 Dateien mit langen Zeilenlisten verarbeiten

# Alle .txt Dateien nach einem bestimmten Muster durchsuchen
cat filelist.txt | xargs grep "Muster"

6.6.3 Wichtige Optionen von xargs

xargs bietet verschiedene Optionen, um sein Verhalten anzupassen:

6.6.3.1 -n: Begrenzung der Anzahl der Argumente pro Befehlsaufruf

# Jede Datei einzeln verarbeiten (ein Argument pro Befehlsaufruf)
ls *.txt | xargs -n 1 wc -l

# Je zwei Dateien zusammen verarbeiten
ls *.txt | xargs -n 2 diff

6.6.3.2 -p: Interaktiver Modus mit Bestätigung

# Bestätigung vor jeder Befehlsausführung anfordern
find . -name "*.tmp" | xargs -p rm

6.6.3.3 -I: Platzhalter für Argumenteinfügung definieren

Diese Option ist besonders nützlich, um Argumente an bestimmten Stellen des Befehls einzufügen:

# Alle .jpg Dateien in einen anderen Ordner kopieren und umbenennen
find . -name "*.jpg" | xargs -I{} cp {} /zielpfad/{}_backup.jpg

# Für jede gefundene Datei eine individuelle Aktion ausführen
cat urls.txt | xargs -I{} curl -o {}.html {}

6.6.3.4 -0 oder --null: Nullbyte als Trennzeichen verwenden

Diese Option ist wichtig für die sichere Verarbeitung von Dateinamen mit Leerzeichen oder Sonderzeichen:

# Sicherere Methode zum Löschen von Dateien mit Sonderzeichen im Namen
find . -name "*.log" -print0 | xargs -0 rm

6.6.4 Parallele Verarbeitung mit xargs

Eine der stärksten Funktionen von xargs ist die Fähigkeit, Befehle parallel auszuführen:

# Bis zu 4 Befehle gleichzeitig ausführen
find . -name "*.png" | xargs -P 4 -I{} convert {} {}.jpg

# Große Dateien parallel komprimieren
find . -size +10M | xargs -P $(nproc) -I{} gzip {}

Die Option -P gefolgt von einer Zahl gibt die maximale Anzahl paralleler Prozesse an. Mit $(nproc) kann die Anzahl der verfügbaren Prozessorkerne automatisch ermittelt werden.

6.6.5 Fortgeschrittene Anwendungsfälle

6.6.5.1 Kombination mit anderen Befehlen

xargs lässt sich effektiv mit anderen Unix-Werkzeugen kombinieren:

# Alle .md Dateien finden, die das Wort "TODO" enthalten
find . -name "*.md" | xargs grep -l "TODO"

# Alle Prozesse eines bestimmten Benutzers beenden
ps -u username | grep processname | awk '{print $1}' | xargs kill

6.6.5.2 Befehle mit komplexen Argumentstrukturen

# Dateien basierend auf ihrem Inhalt in verschiedene Ordner verschieben
find . -name "*.log" | xargs -I{} sh -c 'grep -q "ERROR" {} && mv {} ./errors/ || mv {} ./success/'

6.6.5.3 Verarbeitung von Ausgaben mit mehreren Spalten

# Benutzer mit Heimatverzeichnissen auflisten und verarbeiten
cat /etc/passwd | cut -d: -f1,6 | xargs -L 1 echo "User:"

Die Option -L 1 verarbeitet jeweils eine Zeile als Argument, unabhängig von Leerzeichen.

6.6.6 Einschränkungen und Fallstricke

Beim Einsatz von xargs sind einige Aspekte zu beachten:

1. Sonderzeichen in Dateinamen: Ohne die -0-Option können Dateinamen mit Leerzeichen, Zeilenumbrüchen oder anderen Sonderzeichen zu Problemen führen.

   # Richtig (sicher):
   find . -name "*.txt" -print0 | xargs -0 rm
   
   # Potenziell gefährlich:
   find . -name "*.txt" | xargs rm

2. Befehlszeilenlimit: Obwohl xargs entwickelt wurde, um das Argument-Limit der Shell zu umgehen, haben Befehle immer noch ein maximales Limit für die Befehlszeilenlänge.

3. Exit-Status: xargs gibt den Exit-Status des letzten ausgeführten Befehls zurück, was bei der Fehlerbehandlung zu beachten ist.

6.6.7 Best Practices für die Verwendung von xargs

1. Verwenden Sie -print0 und -0 für sichere Dateinamenverarbeitung:

   find . -type f -name "*.tmp" -print0 | xargs -0 rm

2. Prüfen Sie gefährliche Operationen im Voraus mit -p:

   find /pfad -name "alte_dateien*" | xargs -p rm

3. Nutzen Sie -I{} für lesbaren und flexiblen Code:

   find . -name "*.jpg" | xargs -I{} sh -c 'echo "Verarbeite {}"; convert {} {}.png'

4. Begrenzen Sie die Argumentanzahl bei ressourcenintensiven Befehlen:

   find . -name "*.mp4" | xargs -n 5 ffmpeg-convert

5. Nutzen Sie parallele Verarbeitung für Performance-Gewinn:

   find . -name "*.csv" | xargs -P 8 -I{} python process_data.py {}

6.6.8 Integration in Shell-Skripte

xargs lässt sich nahtlos in Shell-Skripte integrieren, um wiederkehrende Aufgaben zu automatisieren:

#!/usr/bin/env bash
# Skript zum Batch-Verarbeiten von Bildern

usage() {
    echo "Usage: $0 [-r] [-s size] [directory]"
    echo "  -r          Rekursive Verarbeitung"
    echo "  -s size     Zielgröße (z.B. 800x600)"
    exit 1
}

size="800x600"
recursive=""

while getopts "rs:" opt; do
    case $opt in
        r) recursive="-r" ;;
        s) size="$OPTARG" ;;
        *) usage ;;
    esac
done
shift $((OPTIND-1))

directory="${1:-.}"  # Standardmäßig aktuelles Verzeichnis, wenn nicht angegeben

# Bilder finden und mit bis zu 4 parallelen Prozessen verarbeiten
find "$directory" $recursive -type f -name "*.jpg" -print0 | \
    xargs -0 -P 4 -I{} sh -c 'echo "Verarbeite {}"; convert {} -resize '"$size"' {}.resized.jpg'

echo "Verarbeitung abgeschlossen."

6.6.9 xargs vs. Befehlssubstitution

Es ist wichtig, den Unterschied zwischen xargs und Befehlssubstitution ($() oder Backticks) zu verstehen:

# Befehlssubstitution: Gesamte Ausgabe wird als ein String behandelt
rm $(find . -name "*.tmp")

# xargs: Kann die Ausgabe in mehrere Aufrufe aufteilen
find . -name "*.tmp" | xargs rm

Die Befehlssubstitution funktioniert gut für kleine Datenmengen, kann aber bei vielen Argumenten das Befehlszeilenlimit überschreiten. xargs umgeht dieses Problem, indem es den Befehl bei Bedarf mehrmals mit Teilmengen der Argumente ausführt.

6.7 Befehlszeilenargumente mit getopt verarbeiten

Die Verarbeitung von Befehlszeilenargumenten ist ein zentraler Aspekt professioneller Shell-Skripte. Mit zunehmendem Funktionsumfang eines Skripts wächst oft auch die Komplexität der Befehlszeilenschnittstelle. Das getopt-Werkzeug bietet einen robusten Mechanismus zur Verarbeitung von Befehlszeilenoptionen und Argumenten, der weit über die einfachen eingebauten Möglichkeiten der Bash hinausgeht.

6.7.1 Grundlegendes Konzept von getopt

getopt ist ein externes Kommandozeilenprogramm, das Befehlszeilenargumente nach dem POSIX-Standard analysiert und neu formatiert. Es stellt eine zuverlässige und standardisierte Methode zur Verfügung, um:

• Kurze Optionen (einzelne Buchstaben mit einem vorangestellten Bindestrich, z.B. -a)
• Lange Optionen (Wörter mit zwei vorangestellten Bindestrichen, z.B. --all)
• Optionen mit Argumenten (z.B. -f datei.txt oder --file=datei.txt)
• Gruppierte kurze Optionen (z.B. -abc statt -a -b -c)

zu verarbeiten.

6.7.2 Unterschied zwischen getopts und getopt

Es ist wichtig, zwischen dem Shell-eigenen getopts-Befehl und dem externen getopt-Werkzeug zu unterscheiden:

In diesem Abschnitt konzentrieren wir uns auf das externe getopt-Werkzeug, da es umfangreichere Funktionen bietet, insbesondere für komplexere Skripte.

6.7.3 Grundlegende Verwendung von getopt

Die allgemeine Syntax für die Verwendung von getopt in Skripten ist:

OPTIONS=$(getopt -o kurze_optionen -l lange_optionen -- "$@")

Wobei: - -o kurze_optionen die unterstützten kurzen Optionen angibt - -l lange_optionen die unterstützten langen Optionen angibt - -- signalisiert das Ende der Optionen für getopt selbst - "$@" alle Befehlszeilenargumente übergibt, die an das Skript übergeben wurden

Ein einfaches Beispiel:

#!/usr/bin/env bash

# Überprüfen, ob die erweiterte getopt-Version verfügbar ist
if ! getopt --test > /dev/null; then
    echo "Erweiterte getopt-Version wird benötigt"
    exit 1
fi

# Optionen definieren
OPTIONS=v,h,f:,d::
LONGOPTIONS=verbose,help,file:,debug::

# Optionen analysieren
PARSED=$(getopt --options=$OPTIONS --longoptions=$LONGOPTIONS --name "$0" -- "$@")

# Fehlerbehandlung für ungültige Optionen
if [[ $? -ne 0 ]]; then
    # getopt hat einen Fehler gemeldet
    exit 2
fi

# Analysierte Optionen in die Positionsparameter einsetzen
eval set -- "$PARSED"

# Standardwerte setzen
VERBOSE=false
FILE=""
DEBUG=0

# Optionen verarbeiten
while true; do
    case "$1" in
        -v|--verbose)
            VERBOSE=true
            shift
            ;;
        -h|--help)
            echo "Verwendung: $0 [Optionen]"
            echo "Optionen:"
            echo "  -v, --verbose     Ausführliche Ausgabe aktivieren"
            echo "  -h, --help        Diese Hilfe anzeigen"
            echo "  -f, --file=DATEI  Zu verarbeitende Datei angeben"
            echo "  -d, --debug[=LVL] Debug-Modus aktivieren (optional mit Level)"
            exit 0
            ;;
        -f|--file)
            FILE="$2"
            shift 2
            ;;
        -d|--debug)
            case "$2" in
                "")
                    DEBUG=1
                    shift 2
                    ;;
                *)
                    DEBUG="$2"
                    shift 2
                    ;;
            esac
            ;;
        --)
            shift
            break
            ;;
        *)
            echo "Programmierungsfehler"
            exit 3
            ;;
    esac
done

# Verarbeitung der verbleibenden positionale Parameter
echo "Verbose-Modus: $VERBOSE"
echo "Datei: $FILE"
echo "Debug-Level: $DEBUG"
echo "Übrige Parameter: $@"

6.7.4 Syntax und Optionsformate

Die Syntax für die Definition von Optionen in getopt folgt bestimmten Konventionen:

6.7.4.1 Kurze Optionen (-o)

o    # Option -o ohne Argument
o:   # Option -o mit erforderlichem Argument
o::  # Option -o mit optionalem Argument

6.7.4.2 Lange Optionen (-l)

option        # Option --option ohne Argument
option:       # Option --option mit erforderlichem Argument
option::      # Option --option mit optionalem Argument

Beispiel für eine Definition:

OPTIONEN="hvo:f:"
LANGOPTIONEN="help,verbose,output:,file:"

Diese Definition unterstützt: - -h oder --help (kein Argument) - -v oder --verbose (kein Argument) - -o argument oder --output argument oder --output=argument (erforderliches Argument) - -f datei oder --file datei oder --file=datei (erforderliches Argument)

6.7.5 Fortgeschrittene Techniken

6.7.5.1 Umgang mit optionalen Argumenten

Optionale Argumente (mit :: gekennzeichnet) werden unterschiedlich gehandhabt, je nachdem ob kurze oder lange Optionen verwendet werden:

• Für kurze Optionen: -d5 (Argument direkt nach der Option, ohne Leerzeichen)
• Für lange Optionen: --debug=5 (Argument mit Gleichheitszeichen verbunden)

Beispiel:

#!/usr/bin/env bash

OPTIONS=d::,v
LONGOPTIONS=debug::,verbose

PARSED=$(getopt --options=$OPTIONS --longoptions=$LONGOPTIONS --name "$0" -- "$@")
eval set -- "$PARSED"

DEBUG=0
VERBOSE=false

while true; do
    case "$1" in
        -d|--debug)
            case "$2" in
                "")
                    DEBUG=1  # Standardwert, wenn kein Argument angegeben
                    shift 2
                    ;;
                *)
                    DEBUG="$2"
                    shift 2
                    ;;
            esac
            ;;
        -v|--verbose)
            VERBOSE=true
            shift
            ;;
        --)
            shift
            break
            ;;
    esac
done

echo "Debug-Level: $DEBUG"
echo "Verbose: $VERBOSE"

6.7.5.2 Verarbeitung von Optionen mit mehreren Werten

Manchmal möchten Sie eine Option mehrmals angeben, um mehrere Werte zu sammeln (z.B. -i datei1 -i datei2). Dafür können Arrays verwendet werden:

#!/usr/bin/env bash

OPTIONS=i:,o:
LONGOPTIONS=input:,output:

PARSED=$(getopt --options=$OPTIONS --longoptions=$LONGOPTIONS --name "$0" -- "$@")
eval set -- "$PARSED"

# Arrays für mehrere Eingabe- und Ausgabedateien
INPUT_FILES=()
OUTPUT_FILE=""

while true; do
    case "$1" in
        -i|--input)
            INPUT_FILES+=("$2")
            shift 2
            ;;
        -o|--output)
            OUTPUT_FILE="$2"
            shift 2
            ;;
        --)
            shift
            break
            ;;
    esac
done

echo "Eingabedateien: ${INPUT_FILES[*]}"
echo "Ausgabedatei: $OUTPUT_FILE"

Aufruf:

./script.sh -i datei1.txt -i datei2.txt -o ausgabe.txt

6.7.5.3 Validierung und Fehlerbehandlung

Robuste Skripte sollten die übergebenen Argumente validieren, um Laufzeitfehler zu vermeiden:

#!/usr/bin/env bash

OPTIONS=f:,n:
LONGOPTIONS=file:,number:

PARSED=$(getopt --options=$OPTIONS --longoptions=$LONGOPTIONS --name "$0" -- "$@")
eval set -- "$PARSED"

FILE=""
NUMBER=0

while true; do
    case "$1" in
        -f|--file)
            FILE="$2"
            # Prüfen, ob die Datei existiert und lesbar ist
            if [[ ! -r "$FILE" ]]; then
                echo "Fehler: Datei '$FILE' existiert nicht oder ist nicht lesbar." >&2
                exit 1
            fi
            shift 2
            ;;
        -n|--number)
            NUMBER="$2"
            # Prüfen, ob es sich um eine ganze Zahl handelt
            if ! [[ "$NUMBER" =~ ^[0-9]+$ ]]; then
                echo "Fehler: '$NUMBER' ist keine gültige Zahl." >&2
                exit 1
            fi
            shift 2
            ;;
        --)
            shift
            break
            ;;
    esac
done

echo "Datei: $FILE"
echo "Zahl: $NUMBER"

6.7.6 Unterkommandos verarbeiten

Viele moderne Kommandozeilenprogramme verwenden ein Unterkommando-Muster (wie bei git, docker usw.). Mit getopt können Sie dieses Muster implementieren:

#!/usr/bin/env bash

# Globale Optionen
GLOBAL_OPTIONS=v,h
GLOBAL_LONGOPTIONS=verbose,help

# Standardwerte
VERBOSE=false

# Funktion für die Hilfe
show_help() {
    cat << EOF
Verwendung: $0 [globale_optionen] <befehl> [befehl_optionen]

Globale Optionen:
  -v, --verbose     Ausführliche Ausgabe aktivieren
  -h, --help        Diese Hilfe anzeigen

Befehle:
  create            Erstellt eine neue Ressource
  delete            Löscht eine Ressource
  list              Listet alle Ressourcen auf

Für Hilfe zu bestimmten Befehlen: $0 <befehl> --help
EOF
    exit 0
}

# Funktion für create-Befehl
cmd_create() {
    local OPTIONS=n:,t:,h
    local LONGOPTIONS=name:,type:,help
    
    local PARSED=$(getopt --options=$OPTIONS --longoptions=$LONGOPTIONS --name "$0 create" -- "$@")
    eval set -- "$PARSED"
    
    local NAME=""
    local TYPE="default"
    
    while true; do
        case "$1" in
            -n|--name)
                NAME="$2"
                shift 2
                ;;
            -t|--type)
                TYPE="$2"
                shift 2
                ;;
            -h|--help)
                echo "Verwendung: $0 create [optionen]"
                echo "Optionen:"
                echo "  -n, --name=NAME    Name der zu erstellenden Ressource"
                echo "  -t, --type=TYPE    Typ der Ressource (Standard: default)"
                echo "  -h, --help         Diese Hilfe anzeigen"
                exit 0
                ;;
            --)
                shift
                break
                ;;
        esac
    done
    
    if [[ -z "$NAME" ]]; then
        echo "Fehler: Name muss angegeben werden" >&2
        exit 1
    fi
    
    [[ "$VERBOSE" == true ]] && echo "Erstelle Ressource vom Typ '$TYPE'..."
    echo "Ressource '$NAME' wurde erstellt."
}

# Funktion für delete-Befehl
cmd_delete() {
    local OPTIONS=i:,f,h
    local LONGOPTIONS=id:,force,help
    
    local PARSED=$(getopt --options=$OPTIONS --longoptions=$LONGOPTIONS --name "$0 delete" -- "$@")
    eval set -- "$PARSED"
    
    local ID=""
    local FORCE=false
    
    while true; do
        case "$1" in
            -i|--id)
                ID="$2"
                shift 2
                ;;
            -f|--force)
                FORCE=true
                shift
                ;;
            -h|--help)
                echo "Verwendung: $0 delete [optionen]"
                echo "Optionen:"
                echo "  -i, --id=ID        ID der zu löschenden Ressource"
                echo "  -f, --force        Ohne Bestätigung löschen"
                echo "  -h, --help         Diese Hilfe anzeigen"
                exit 0
                ;;
            --)
                shift
                break
                ;;
        esac
    done
    
    if [[ -z "$ID" ]]; then
        echo "Fehler: ID muss angegeben werden" >&2
        exit 1
    fi
    
    if [[ "$FORCE" != true ]]; then
        read -p "Möchten Sie die Ressource '$ID' wirklich löschen? [j/N] " CONFIRM
        if [[ ! "$CONFIRM" =~ ^[jJ]$ ]]; then
            echo "Löschvorgang abgebrochen."
            exit 0
        fi
    fi
    
    [[ "$VERBOSE" == true ]] && echo "Lösche Ressource..."
    echo "Ressource '$ID' wurde gelöscht."
}

# Funktion für list-Befehl
cmd_list() {
    local OPTIONS=t:,l,h
    local LONGOPTIONS=type:,long,help
    
    local PARSED=$(getopt --options=$OPTIONS --longoptions=$LONGOPTIONS --name "$0 list" -- "$@")
    eval set -- "$PARSED"
    
    local TYPE=""
    local LONG=false
    
    while true; do
        case "$1" in
            -t|--type)
                TYPE="$2"
                shift 2
                ;;
            -l|--long)
                LONG=true
                shift
                ;;
            -h|--help)
                echo "Verwendung: $0 list [optionen]"
                echo "Optionen:"
                echo "  -t, --type=TYPE    Nur Ressourcen dieses Typs anzeigen"
                echo "  -l, --long         Ausführliches Format verwenden"
                echo "  -h, --help         Diese Hilfe anzeigen"
                exit 0
                ;;
            --)
                shift
                break
                ;;
        esac
    done
    
    [[ "$VERBOSE" == true ]] && echo "Ressourcen werden abgerufen..."
    
    if [[ "$LONG" == true ]]; then
        echo "ID          | Name        | Typ         | Erstelldatum"
        echo "------------|-------------|-------------|-------------"
        echo "res-001     | Beispiel 1  | Standard    | 2023-05-01"
        echo "res-002     | Beispiel 2  | Premium     | 2023-05-02"
    else
        echo "res-001  Beispiel 1"
        echo "res-002  Beispiel 2"
    fi
}

# Globale Optionen verarbeiten
PARSED=$(getopt --options=$GLOBAL_OPTIONS --longoptions=$GLOBAL_LONGOPTIONS --name "$0" -- "$@")

if [[ $? -ne 0 ]]; then
    exit 1
fi

eval set -- "$PARSED"

while true; do
    case "$1" in
        -v|--verbose)
            VERBOSE=true
            shift
            ;;
        -h|--help)
            show_help
            ;;
        --)
            shift
            break
            ;;
    esac
done

# Unterkommando verarbeiten
COMMAND="$1"
shift

case "$COMMAND" in
    create)
        cmd_create "$@"
        ;;
    delete)
        cmd_delete "$@"
        ;;
    list)
        cmd_list "$@"
        ;;
    "")
        echo "Fehler: Kein Befehl angegeben" >&2
        show_help
        ;;
    *)
        echo "Fehler: Unbekannter Befehl '$COMMAND'" >&2
        show_help
        ;;
esac