init at home

2026-03-27 12:41:00 +01:00
commit 352c352056
58 changed files with 13083 additions and 0 deletions
@@ -0,0 +1,243 @@
+## 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