merging and cleaning up

2026-03-27 13:14:52 +01:00
parent 4eb84a28af
commit 82d7e0e888
62 changed files with 6 additions and 386 deletions
@@ -0,0 +1,693 @@
+# BASH Funktionen# BASH FunktionenIn **[[Bash]]** kannst du wiederverwendbare **Funktionen** definieren, um Code übersichtlicher und modularer zu gestalten.  
+
+
+
+In BASH kannst du wiederverwendbare Funktionen definieren, um Code übersichtlicher und modularer zu gestalten.Hier ist eine kurze Einführung mit Beispielen 👇
+
+
+
+## GrundsyntaxIn BASH kannst du wiederverwendbare Funktionen definieren, um Code übersichtlicher und modularer zu gestalten.
+
+
+
+```bash---
+
+meine_funktion() {
+
+    echo "Das ist eine wiederverwendbare Funktion!"## Grundsyntax
+
+}
+
+```### 🔹 **Grundsyntax einer Funktion**
+
+
+
+Alternative Syntax (weniger üblich):```bash
+
+
+
+```bashmeine_funktion() {```bash
+
+function meine_funktion {
+
+    echo "Das ist eine wiederverwendbare Funktion!"    echo "Das ist eine wiederverwendbare Funktion!"meine_funktion() {
+
+}
+
+```}    echo "Das ist eine wiederverwendbare Funktion!"
+
+
+
+## Funktion mit Parametern```}
+
+
+
+In BASH werden Argumente positional übergeben: `$1`, `$2`, usw.```
+
+
+
+```bashAlternative Syntax (weniger üblich):
+
+begruesse() {
+
+    echo "Hallo $1!"Oder alternativ (weniger üblich, aber erlaubt):
+
+}
+
+```bash
+
+begruesse "Anna"
+
+# Ausgabe: Hallo Anna!function meine_funktion {```bash
+
+```
+
+    echo "Das ist eine wiederverwendbare Funktion!"function meine_funktion {
+
+## Rückgabewerte
+
+}    echo "Das ist eine wiederverwendbare Funktion!"
+
+### Numerischer Exit-Code
+
+```}
+
+Eine Funktion kann mit `return` einen numerischen Exit-Code (0–255) zurückgeben:
+
+```
+
+```bash
+
+teste_zahl() {## Funktion mit Parametern
+
+    if (( $1 > 10 )); then
+
+        return 0  # Erfolg---
+
+    else
+
+        return 1  # FehlerIn BASH werden Argumente positional übergeben: `$1`, `$2`, usw.
+
+    fi
+
+}### 🔹 **Funktion mit Parametern**
+
+
+
+if teste_zahl 15; then```bash
+
+    echo "Größer als 10"
+
+elsebegruesse() {In Bash werden Argumente **positional** übergeben — also `$1`, `$2`, usw.
+
+    echo "Nicht größer als 10"
+
+fi    echo "Hallo $1!"
+
+```
+
+}```bash
+
+### Text zurückgeben
+
+begruesse() {
+
+Um Text zurückzugeben, verwende `echo` oder `printf` und Command Substitution:
+
+begruesse "Anna"    echo "Hallo $1!"
+
+```bash
+
+addiere() {# Ausgabe: Hallo Anna!}
+
+    echo $(( $1 + $2 ))
+
+}```
+
+
+
+summe=$(addiere 3 5)begruesse "Anna"
+
+echo "Summe: $summe"  # Ausgabe: Summe: 8
+
+```## Rückgabewerte# Ausgabe: Hallo Anna!
+
+
+
+## Funktionen wiederverwendbar machen```
+
+
+
+Speichere Funktionen in einer separaten Datei und lade sie mit `source`:### Numerischer Exit-Code
+
+
+
+**funktionen.sh:**---
+
+```bash
+
+#!/bin/bashEine Funktion kann mit `return` einen numerischen Exit-Code (0–255) zurückgeben:
+
+begruesse() {
+
+    echo "Hallo $1!"### 🔹 **Rückgabewerte**
+
+}
+
+``````bash
+
+
+
+**hauptskript.sh:**teste_zahl() {- Eine Funktion kann mit `return` einen **numerischen Exit-Code** (0–255) zurückgeben.
+
+```bash
+
+#!/bin/bash    if (( $1 > 10 )); then    
+
+source ./funktionen.sh
+
+        return 0  # Erfolg- Um Text zurückzugeben, verwendest du **`echo`** oder **`printf`** und fängst den Wert mit **Command Substitution** ein.
+
+begruesse "Welt"
+
+```    else    
+
+
+
+Alternative: `. ./funktionen.sh`        return 1  # Fehler
+
+
+
+## Lokale Variablen    fi```bash
+
+
+
+Verwende `local`, um Variablen nur innerhalb der Funktion sichtbar zu machen:}# numerischer Rückgabewert
+
+
+
+```bashteste_zahl() {
+
+addiere() {
+
+    local summe=$(( $1 + $2 ))if teste_zahl 15; then    if (( $1 > 10 )); then
+
+    echo "$summe"
+
+}    echo "Größer als 10"        return 0  # Erfolg
+
+```
+
+else    else
+
+## Default-Werte für Parameter
+
+    echo "Nicht größer als 10"        return 1  # Fehler
+
+```bash
+
+mein_script() {fi    fi
+
+    local name="${1:-Welt}"       # Standardwert 'Welt'
+
+    local sprache="${2:-de}"      # Standardwert 'de'```}
+
+
+
+    echo "Name: $name, Sprache: $sprache"
+
+}
+
+### Text zurückgebenif teste_zahl 15; then
+
+mein_script "Anna" "en"  # Name: Anna, Sprache: en
+
+mein_script "Bob"        # Name: Bob, Sprache: de    echo "Größer als 10"
+
+```
+
+Um Text zurückzugeben, verwende `echo` oder `printf` und Command Substitution:else
+
+## Benannte Argumente simulieren
+
+    echo "Nicht größer als 10"
+
+### Mit case und Schleife
+
+```bashfi
+
+```bash
+
+begruesse() {addiere() {```
+
+    local name="Welt"
+
+    local sprache="de"    echo $(( $1 + $2 ))
+
+
+
+    for arg in "$@"; do}```bash
+
+        case $arg in
+
+            --name=*)# Text zurückgeben
+
+                name="${arg#*=}"
+
+                ;;summe=$(addiere 3 5)addiere() {
+
+            --sprache=*|--lang=*)
+
+                sprache="${arg#*=}"echo "Summe: $summe"  # Ausgabe: Summe: 8    echo $(( $1 + $2 ))
+
+                ;;
+
+            *)```}
+
+                echo "Unbekannte Option: $arg" >&2
+
+                ;;
+
+        esac
+
+    done## Funktionen wiederverwendbar machensumme=$(addiere 3 5)
+
+
+
+    echo "Hallo $name! (Sprache: $sprache)"echo "Summe: $summe"
+
+}
+
+Speichere Funktionen in einer separaten Datei und lade sie mit `source`:# Ausgabe: Summe: 8
+
+begruesse --name=Anna --sprache=en
+
+``````
+
+
+
+**Vorteile:****funktionen.sh:**
+
+- Reihenfolge der Argumente ist egal
+
+- Default-Werte bleiben bestehen```bash---
+
+- Sehr gut lesbar
+
+#!/bin/bash
+
+### Mit assoziativem Array
+
+begruesse() {### 🔹 **Wiederverwendbar machen**
+
+```bash
+
+begruesse() {    echo "Hallo $1!"
+
+    declare -A args=(
+
+        [name]="Welt"}Speichere deine Funktionen in einer separaten Datei, z. B. `funktionen.sh`, und **sourcen** sie in anderen Skripten:
+
+        [sprache]="de"
+
+    )```
+
+
+
+    for arg in "$@"; do**funktionen.sh**
+
+        [[ $arg == *=* ]] || continue
+
+        key="${arg%%=*}"**hauptskript.sh:**
+
+        val="${arg#*=}"
+
+        args[$key]="$val"```bash```bash
+
+    done
+
+#!/bin/bash#!/bin/bash
+
+    echo "Hallo ${args[name]}! (Sprache: ${args[sprache]})"
+
+}source ./funktionen.shbegruesse() {
+
+
+
+begruesse name=Anna sprache=en    echo "Hallo $1!"
+
+```
+
+begruesse "Welt"}
+
+## Praktische Beispiele
+
+``````
+
+### Backup-Funktion
+
+
+
+```bash
+
+backup_datei() {Alternative: `. ./funktionen.sh`**hauptskript.sh**
+
+    local datei="$1"
+
+    local backup="${datei}.backup-$(date +%Y%m%d)"
+
+    
+
+    if [[ -f "$datei" ]]; then## Lokale Variablen```bash
+
+        cp "$datei" "$backup"
+
+        echo "Backup erstellt: $backup"#!/bin/bash
+
+    else
+
+        echo "Fehler: $datei nicht gefunden" >&2Verwende `local`, um Variablen nur innerhalb der Funktion sichtbar zu machen:source ./funktionen.sh
+
+        return 1
+
+    fi
+
+}
+
+```bashbegruesse "Welt"
+
+backup_datei wichtig.txt
+
+```addiere() {```
+
+
+
+### Fehlerbehandlung    local summe=$(( $1 + $2 ))
+
+
+
+```bash    echo "$summe"Oder mit:
+
+sicheres_loeschen() {
+
+    local datei="$1"}
+
+    
+
+    if [[ ! -f "$datei" ]]; then``````bash
+
+        echo "Fehler: $datei existiert nicht" >&2
+
+        return 1. ./funktionen.sh
+
+    fi
+
+    ## Default-Werte für Parameter```
+
+    read -p "Wirklich $datei löschen? (j/n) " antwort
+
+    if [[ "$antwort" == "j" ]]; then
+
+        rm "$datei"
+
+        echo "$datei gelöscht"```bash---
+
+    else
+
+        echo "Abgebrochen"mein_script() {
+
+    fi
+
+}    local name="${1:-Welt}"       # Standardwert 'Welt'### 🔹 **Bonus: Funktionen mit lokaler Variable**
+
+```
+
+    local sprache="${2:-de}"      # Standardwert 'de'
+
+### Mehrere Rückgabewerte
+
+Verwende `local`, um Variablen nur innerhalb der Funktion sichtbar zu machen:
+
+```bash
+
+datei_info() {    echo "Name: $name, Sprache: $sprache"
+
+    local datei="$1"
+
+    }```bash
+
+    if [[ -f "$datei" ]]; then
+
+        echo "$(wc -l < "$datei")"     # Zeilenaddiere() {
+
+        echo "$(wc -w < "$datei")"     # Wörter
+
+        echo "$(stat -c%s "$datei")"   # Größemein_script "Anna" "en"  # Name: Anna, Sprache: en    local summe=$(( $1 + $2 ))
+
+    fi
+
+}mein_script "Bob"        # Name: Bob, Sprache: de    echo "$summe"
+
+
+
+# Verwendung```}
+
+read zeilen woerter groesse <<< $(datei_info text.txt)
+
+echo "Zeilen: $zeilen, Wörter: $woerter, Größe: $groesse"```
+
+```
+
+## Benannte Argumente simulieren
+
+## Best Practices
+
+---
+
+### Eingabevalidierung
+
+### Mit case und Schleife
+
+```bash
+
+verarbeite_zahl() {## 🧩 Beispiel 1: Named Arguments via `local` + Parameter Expansion
+
+    local zahl="$1"
+
+    ```bash
+
+    if ! [[ "$zahl" =~ ^[0-9]+$ ]]; then
+
+        echo "Fehler: Keine gültige Zahl" >&2begruesse() {```bash
+
+        return 1
+
+    fi    local name="Welt"mein_script() {
+
+    
+
+    echo "Ergebnis: $((zahl * 2))"    local sprache="de"    local name="${1:-Welt}"         # Standardwert 'Welt'
+
+}
+
+```    local sprache="${2:-de}"        # Standardwert 'de'
+
+
+
+### Dokumentation    for arg in "$@"; do
+
+
+
+```bash        case $arg in    echo "Name: $name"
+
+# Berechnet die Summe zweier Zahlen
+
+# Parameter:            --name=*)    echo "Sprache: $sprache"
+
+#   $1 - erste Zahl
+
+#   $2 - zweite Zahl                name="${arg#*=}"}
+
+# Rückgabe:
+
+#   Summe der beiden Zahlen                ;;
+
+addiere() {
+
+    echo $(( $1 + $2 ))            --sprache=*|--lang=*)mein_script "Anna" "en"
+
+}
+
+```                sprache="${arg#*=}"mein_script "Bob"
+
+
+
+### Fehler propagieren                ;;```
+
+
+
+```bash            *)
+
+hauptfunktion() {
+
+    hilfsfunktion || return $?                echo "Unbekannte Option: $arg" >&2➡️ Ausgabe:
+
+    # Weiterer Code nur wenn hilfsfunktion erfolgreich
+
+}                ;;
+
+```
+
+        esac```
+
+## Siehe auch
+
+    doneName: Anna
+
+- [[grep]] - Textsuche in Scripten
+
+- [[sed]] - Textmanipulation in FunktionenSprache: en
+
+- [[find]] - Dateien in Funktionen verarbeiten
+
+    echo "Hallo $name! (Sprache: $sprache)"Name: Bob
+
+}Sprache: de
+
+```
+
+begruesse --name=Anna --sprache=en
+
+```Aber das sind **positionsbasierte Argumente**, keine echten "benannten".
+
+
+
+**Vorteile:**---
+
+- Reihenfolge der Argumente ist egal
+
+- Default-Werte bleiben bestehen## 🧩 Beispiel 2: Simulierte **benannte Argumente** mit `case` oder Schleife
+
+- Sehr gut lesbar
+
+Du kannst Argumente wie `--name=Anna` oder `--lang=en` verwenden:
+
+### Mit assoziativem Array
+
+```bash
+
+```bashbegruesse() {
+
+begruesse() {    local name="Welt"
+
+    declare -A args=(    local sprache="de"
+
+        [name]="Welt"
+
+        [sprache]="de"    for arg in "$@"; do
+
+    )        case $arg in
+
+            --name=*)
+
+    for arg in "$@"; do                name="${arg#*=}"
+
+        [[ $arg == *=* ]] || continue                ;;
+
+        key="${arg%%=*}"            --sprache=*|--lang=*)
+
+        val="${arg#*=}"                sprache="${arg#*=}"
+
+        args[$key]="$val"                ;;
+
+    done            *)
+
+                echo "Unbekannte Option: $arg" >&2
+
+    echo "Hallo ${args[name]}! (Sprache: ${args[sprache]})"                ;;
+
+}        esac
+
+    done
+
+begruesse name=Anna sprache=en
+
+```    echo "Hallo $name! (Sprache: $sprache)"
+
+}
+
+## Siehe auch
+
+begruesse --name=Anna --sprache=en
+
+- [[find]] - BASH-Befehl zum Suchen von Dateienbegruesse
+
+- [[grep]] - Textsuche in Dateien```
+
+
+➡️ Ausgabe:
+
+```
+Hallo Anna! (Sprache: en)
+Hallo Welt! (Sprache: de)
+```
+
+✅ Vorteil: Reihenfolge der Argumente ist egal  
+✅ Default-Werte bleiben bestehen  
+✅ Sehr gut lesbar
+
+---
+
+## 🧩 Beispiel 3: Named Args via **`declare -A` (assoziatives Array)**
+
+Etwas fortgeschrittener, aber elegant:
+
+```bash
+begruesse() {
+    declare -A args=(
+        [name]="Welt"
+        [sprache]="de"
+    )
+
+    for arg in "$@"; do
+        [[ $arg == *=* ]] || continue
+        key="${arg%%=*}"
+        val="${arg#*=}"
+        args[$key]="$val"
+    done
+
+    echo "Hallo ${args[name]}! (Sprache: ${args[sprache]})"
+}
+
+begruesse name=Anna sprache=en
+```
+
+---
+
+## 🧩 Beispiel 4: Default-Werte per `:`-Operator
+
+Falls du Parameter ohne Parsing willst, kannst du Default-Werte einfach so setzen:
+
+```bash
+begruesse() {
+    local name="${1:-Welt}"
+    local sprache="${2:-de}"
+
+    echo "Hallo $name in Sprache $sprache"
+}
+```
+
+---
+
+### 🔹 Empfehlung
+
+Wenn du Funktionen **häufig wiederverwenden** oder **CLI-ähnliche Aufrufe** unterstützen willst, ist **Variante 2 (mit `--option=wert`)** am besten:
+
+- Lesbar
+    
+- Robust
+    
+- Einfach erweiterbar
+    
+
+---