## Grundlegendes Vorgehen

Ein BASH Skript, das Argumente verarbeitet und weiterleitet, folgt diesem Muster:

```bash
#!/bin/bash

# Standardwerte definieren
DEFAULT_VALUE="standard"
VERBOSE=false
TARGET_SCRIPT="./target-script.sh"

# Argumente parsen
while [[ $# -gt 0 ]]; do
    case $1 in
        -v|--verbose)
            VERBOSE=true
            shift
            ;;
        -f|--file)
            FILE="$2"
            shift 2
            ;;
        -o|--output)
            OUTPUT="${2:-$DEFAULT_VALUE}"
            shift 2
            ;;
        -h|--help)
            show_help
            exit 0
            ;;
        *)
            # Unbekannte Argumente sammeln
            UNKNOWN_ARGS+=("$1")
            shift
            ;;
    esac
done

# Alle Argumente an Zielskript weiterleiten
"$TARGET_SCRIPT" "${UNKNOWN_ARGS[@]}"
```

## Verschiedene Weiterleitungsstrategien

### 1. Alle Argumente 1:1 weiterleiten
```bash
#!/bin/bash
./target-script.sh "$@"
```

### 2. Selektive Weiterleitung
```bash
#!/bin/bash

# Lokale Verarbeitung
WRAPPER_OPTION=""
TARGET_ARGS=()

while [[ $# -gt 0 ]]; do
    case $1 in
        --wrapper-only)
            WRAPPER_OPTION="$2"
            shift 2
            ;;
        *)
            TARGET_ARGS+=("$1")
            shift
            ;;
    esac
done

# Nur relevante Argumente weiterleiten
./target-script.sh "${TARGET_ARGS[@]}"
```

### 3. Argumente transformieren
```bash
#!/bin/bash

TRANSFORMED_ARGS=()

for arg in "$@"; do
    case $arg in
        --old-format)
            TRANSFORMED_ARGS+=("--new-format")
            ;;
        *)
            TRANSFORMED_ARGS+=("$arg")
            ;;
    esac
done

./target-script.sh "${TRANSFORMED_ARGS[@]}"
```

## Erweiterte Techniken

### Standardwerte und Validierung
```bash
#!/bin/bash

# Standardwerte
CONFIG_FILE="${CONFIG_FILE:-/etc/default/myapp}"
LOG_LEVEL="${LOG_LEVEL:-INFO}"
DRY_RUN=false

# Hilfsfunktion
show_help() {
    cat << EOF
Usage: $0 [OPTIONS] -- [TARGET_ARGS]

OPTIONS:
    -c, --config FILE    Konfigurationsdatei (default: $CONFIG_FILE)
    -l, --log-level LVL  Log Level (default: $LOG_LEVEL)
    -n, --dry-run        Nur Simulation
    -h, --help           Diese Hilfe

Alle Argumente nach -- werden an das Zielskript weitergegeben.
EOF
}

# Parsing mit -- Separator
TARGET_ARGS=()
PARSE_TARGET=false

while [[ $# -gt 0 ]]; do
    if [[ "$PARSE_TARGET" == true ]]; then
        TARGET_ARGS+=("$1")
        shift
        continue
    fi
    
    case $1 in
        -c|--config)
            CONFIG_FILE="$2"
            shift 2
            ;;
        -l|--log-level)
            LOG_LEVEL="$2"
            shift 2
            ;;
        -n|--dry-run)
            DRY_RUN=true
            shift
            ;;
        -h|--help)
            show_help
            exit 0
            ;;
        --)
            PARSE_TARGET=true
            shift
            ;;
        *)
            echo "Unbekannte Option: $1" >&2
            show_help
            exit 1
            ;;
    esac
done

# Validierung
if [[ ! -f "$CONFIG_FILE" ]]; then
    echo "Konfigurationsdatei nicht gefunden: $CONFIG_FILE" >&2
    exit 1
fi

# Ausführung
if [[ "$DRY_RUN" == true ]]; then
    echo "DRY RUN: ./target-script.sh ${TARGET_ARGS[*]}"
else
    ./target-script.sh "${TARGET_ARGS[@]}"
fi
```

## Best Practices

### 1. Sichere Argumentbehandlung
```bash
# Verwende Arrays für Argumente
ARGS=()
while IFS= read -r -d '' arg; do
    ARGS+=("$arg")
done < <(printf '%s\0' "$@")

# Sichere Weiterleitung
./target-script.sh "${ARGS[@]}"
```

### 2. Logging und Debugging
```bash
#!/bin/bash

DEBUG=${DEBUG:-false}

debug_log() {
    if [[ "$DEBUG" == true ]]; then
        echo "DEBUG: $*" >&2
    fi
}

debug_log "Received arguments: $*"
debug_log "Passing to target: ${TARGET_ARGS[*]}"
```

### 3. Fehlerbehandlung
```bash
#!/bin/bash

set -euo pipefail  # Strict mode

# Trap für Cleanup
cleanup() {
    debug_log "Cleaning up..."
}
trap cleanup EXIT

# Prüfe ob Zielskript existiert
if [[ ! -x "$TARGET_SCRIPT" ]]; then
    echo "Fehler: Zielskript '$TARGET_SCRIPT' nicht gefunden oder nicht ausführbar" >&2
    exit 1
fi

# Führe aus und fange Exit-Code ab
if "$TARGET_SCRIPT" "$@"; then
    debug_log "Zielskript erfolgreich ausgeführt"
else
    exit_code=$?
    echo "Zielskript fehlgeschlagen mit Exit-Code: $exit_code" >&2
    exit $exit_code
fi
```

## Verwandte Konzepte

- [[Shell Scripting Best Practices]]
- [[BASH Argument Parsing]]
- [[Environment Variables in Shell Scripts]]

---

**Tags**: #bash #scripting #arguments #shell #automation