9 Textverarbeitung und Datenmanipulation

# Basic Regular Expressions (Standard-grep)
grep "pattern" datei.txt

# Extended Regular Expressions
grep -E "pattern" datei.txt
# oder
egrep "pattern" datei.txt

# Perl-Compatible Regular Expressions
grep -P "pattern" datei.txt

# BRE: Um die Metazeichen +, ?, |, () zu verwenden, müssen sie mit \ escaped werden
grep "a\+" datei.txt         # Sucht nach "a" gefolgt von einem oder mehreren "a"

# ERE: Metazeichen wie +, ?, |, () können direkt verwendet werden
grep -E "a+" datei.txt       # Äquivalent zum obigen Befehl
egrep "a+" datei.txt         # Identisch zu grep -E

# PCRE: Fortgeschrittene Funktionen wie Lookaheads/Lookbehinds verfügbar
grep -P "a(?=b)" datei.txt   # Sucht nach "a", aber nur wenn es von "b" gefolgt wird

# Basic Regular Expressions (Standard)
sed 's/pattern/replacement/' datei.txt

# Extended Regular Expressions
sed -E 's/pattern/replacement/' datei.txt

# BRE: Suchen und Ersetzen mit Gruppierung
sed 's/\(Hallo\) \(Welt\)/\2 \1/' datei.txt  # Tauscht "Hallo Welt" gegen "Welt Hallo"

# ERE: Gleiche Funktion, aber einfachere Syntax
sed -E 's/(Hallo) (Welt)/\2 \1/' datei.txt   # Äquivalent zum obigen Befehl

awk '/pattern/ { aktion }' datei.txt

# Sucht nach Zeilen, die mit "user" beginnen und endet mit einer Zahl
# und gibt die zweite Spalte aus
awk '/^user.*[0-9]$/ { print $2 }' benutzer.txt

if [[ "$string" =~ pattern ]]; then
    echo "Muster gefunden"
fi

#!/bin/bash

email="benutzer@example.com"

# Überprüfen einer E-Mail-Adresse mit einem regulären Ausdruck
if [[ "$email" =~ ^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$ ]]; then
    echo "Gültige E-Mail-Adresse"
else
    echo "Ungültige E-Mail-Adresse"
fi

pattern="^[0-9]+$"

# Korrekt:
if [[ "123" =~ $pattern ]]; then
    echo "Übereinstimmung gefunden"
fi

# Auch korrekt, verhindert Shell-Expansionen im Pattern:
if [[ "123" =~ "^[0-9]+$" ]]; then
    echo "Übereinstimmung gefunden"
fi

#!/bin/bash

# Funktion zur Validierung einer IP-Adresse
validate_ip() {
    local ip=$1
    
    # IP-Adresse validieren mit einem regulären Ausdruck
    if [[ $ip =~ ^([0-9]{1,3}\.){3}[0-9]{1,3}$ ]]; then
        # Überprüfen, ob jede Zahl <= 255 ist
        IFS='.' read -r -a octets <<< "$ip"
        for octet in "${octets[@]}"; do
            if (( octet > 255 )); then
                return 1  # Ungültig
            fi
        done
        return 0  # Gültig
    else
        return 1  # Ungültig
    fi
}

# Benutzereingabe abfragen
read -p "Bitte geben Sie eine IP-Adresse ein: " ip_address

# Validierung aufrufen
if validate_ip "$ip_address"; then
    echo "Die IP-Adresse $ip_address ist gültig."
else
    echo "Die IP-Adresse $ip_address ist ungültig."
fi

#!/bin/bash

# Eine Log-Datei mit folgendem Format:
# [DATUM] [LEVEL] Nachricht
log_file="application.log"

# Extraktion aller ERROR-Meldungen mit grep und ERE
grep -E "^\[[0-9-]+\] \[ERROR\]" "$log_file"

# Extraktion der Zeitstempel und Nachrichteninhalte mit sed und ERE
sed -E 's/^\[([0-9-]+)\] \[([A-Z]+)\] (.*)$/Datum: \1, Level: \2, Nachricht: \3/' "$log_file"

# Extraktion und Verarbeitung mit awk
awk '
    /^\[[0-9-]+\] \[(ERROR|WARN)\]/ {
        gsub(/^\[|\]/, "", $1);  # Entfernt die eckigen Klammern aus dem Datum
        gsub(/^\[|\]/, "", $2);  # Entfernt die eckigen Klammern aus dem Level
        
        # Speichert Fehler und Warnungen nach Datum
        counts[$1][$2]++;
    }
    
    END {
        print "Zusammenfassung der Fehler und Warnungen nach Datum:";
        for (date in counts) {
            printf "%s: ", date;
            for (level in counts[date]) {
                printf "%s=%d ", level, counts[date][level];
            }
            printf "\n";
        }
    }
' "$log_file"

#!/bin/bash

# Eine HTML-Datei bearbeiten, um alle Links zu modifizieren
html_file="seite.html"

# Alle externen Links auf HTTPS umstellen
sed -E 's/(href="http:\/\/[^"]+)"/\1s"/' "$html_file" > "seite_https.html"

# Alle leeren HTML-Tags finden (z.B. <tag></tag> oder <tag />)
grep -E "<([a-zA-Z]+)[^>]*>([ \t]*)<\/\1>|<([a-zA-Z]+)[^>]*\/>" "$html_file"

# Positive Lookahead: Findet "a", aber nur wenn es von "b" gefolgt wird
grep -P "a(?=b)" datei.txt

# Negative Lookahead: Findet "a", aber nur wenn es NICHT von "b" gefolgt wird
grep -P "a(?!b)" datei.txt

# Positive Lookbehind: Findet "b", aber nur wenn es von "a" vorangestellt wird
grep -P "(?<=a)b" datei.txt

# Negative Lookbehind: Findet "b", aber nur wenn es NICHT von "a" vorangestellt wird
grep -P "(?<!a)b" datei.txt

# Gierige Übereinstimmung (Standard)
grep -P "<.+>" datei.html  # Könnte mehrere Tags auf einmal erfassen

# Nicht-gierige Übereinstimmung
grep -P "<.+?>" datei.html  # Erfasst jeden Tag einzeln

grep [Optionen] Muster [Datei...]

# Nach dem Wort "error" in einer Logdatei suchen
grep "error" logfile.txt

# Nach Zeilen suchen, die mit "user" beginnen, in mehreren Dateien
grep "^user" file1.txt file2.txt

# Alle .conf-Dateien im /etc Verzeichnis nach einem Muster durchsuchen
grep "network" /etc/*.conf

# Fall-insensitive Suche
grep -i "error" logfile.txt

# Zeilen, die NICHT "success" enthalten
grep -v "success" logfile.txt

# Dateien im Systemlog finden, die Fehlermeldungen enthalten
grep -l "error" /var/log/*.log

# Zeilen mit Kontext anzeigen
grep -C 2 "critical failure" application.log

# Rekursive Suche nach einer IP-Adresse in einem Verzeichnis
grep -r "192\.168\.1\.[0-9]\+" /var/log/

# Prozesse finden, die von einem bestimmten Benutzer ausgeführt werden
ps aux | grep "username"

# Anzahl der HTTP 404-Fehler in einem Apache-Zugriffslog zählen
cat access.log | grep "HTTP/1.1\" 404" | wc -l

# Alle SSH-Verbindungen aus einer bestimmten IP-Adresse finden
cat /var/log/auth.log | grep "sshd" | grep "192.168.1.10"

sed [Optionen] 'Befehl' [Datei...]

# Ersetzen des ersten Vorkommens von "old" durch "new" in jeder Zeile
sed 's/old/new/' file.txt

# Ersetzen aller Vorkommen von "old" durch "new" in jeder Zeile
sed 's/old/new/g' file.txt

# Nur Zeilen 10-20 einer Datei anzeigen
sed -n '10,20p' file.txt

# Kommentarzeilen aus einer Konfigurationsdatei entfernen
sed '/^#/d' config.conf

# Nur Zeile 5 bearbeiten
sed '5s/old/new/' file.txt

# Zeilen 5 bis 10 bearbeiten
sed '5,10s/old/new/' file.txt

# Vom Anfang bis zu einer Zeile, die "END" enthält
sed '1,/END/s/old/new/' file.txt

# Jede zweite Zeile auswählen
sed '0~2s/old/new/' file.txt

# Nur Zeilen, die einem Muster entsprechen
sed '/pattern/s/old/new/' file.txt

# Hinzufügen einer Zeile nach jeder Zeile, die einem Muster entspricht
sed '/pattern/a\Neue Zeile nach dem Muster' file.txt

# Entfernen von Leerzeilen
sed '/^$/d' file.txt

# Entfernen von führenden und nachfolgenden Leerzeichen
sed 's/^[ \t]*//;s/[ \t]*$//' file.txt

# Extrahieren von Texten zwischen bestimmten Markern
sed -n '/START/,/END/p' file.txt

# In-Place-Bearbeitung einer Datei (Vorsicht!)
sed -i 's/old/new/g' file.txt

# Backup erstellen vor In-Place-Bearbeitung
sed -i.bak 's/old/new/g' file.txt

# sed-Skriptdatei erstellen
cat > transform.sed << 'EOF'
# Kommentarzeilen entfernen
/^#/d

# Leerzeilen entfernen
/^$/d

# "DEBUG" durch "INFO" ersetzen
s/DEBUG/INFO/g

# Zeilen mit "ERROR" markieren
/ERROR/s/^/*** /
EOF

# Anwenden des Skripts auf eine Datei
sed -f transform.sed logfile.txt

awk [Optionen] 'Programm' [Datei...]

# Zweite Spalte einer Datei ausgeben
awk '{ print $2 }' file.txt

# Zeilen ausgeben, deren erste Spalte größer als 100 ist
awk '$1 > 100' file.txt

# Summe der Werte in der dritten Spalte berechnen
awk '{ sum += $3 } END { print sum }' file.txt

# Arithmetische Operatoren: +, -, *, /, %, ^
# Vergleichsoperatoren: ==, !=, <, >, <=, >=
# Logische Operatoren: &&, ||, !

# Bedingte Anweisung
if (Bedingung) {
    Aktionen
} else if (andere_Bedingung) {
    Andere_Aktionen
} else {
    Standard_Aktionen
}

# Schleifen
for (i = 1; i <= 10; i++) {
    Aktionen
}

while (Bedingung) {
    Aktionen
}

do {
    Aktionen
} while (Bedingung)

# break und continue sind ebenfalls verfügbar

# CSV-Datei mit benutzerdefiniertem Trennzeichen verarbeiten
awk -F';' '{ print $1 ", " $3 }' data.csv

# Summe und Durchschnitt einer numerischen Spalte berechnen
awk '{ sum += $1; count++ } END { print "Summe:", sum, "Durchschnitt:", sum/count }' zahlen.txt

# Spaltenüberschriften hinzufügen
awk 'BEGIN { print "Name\tAlter\tStadt" } { print $1 "\t" $2 "\t" $3 }' personen.txt

# Daten filtern und formatieren
awk '$3 > 30 { printf "%-20s %-10s %d\n", $1, $2, $3 }' data.txt

# Gruppieren und Aggregieren von Daten
awk '{ users[$1]++ } END { for (user in users) print user, users[user] }' access.log

# Zählen der Wörter in einer Datei
awk '{ for (i = 1; i <= NF; i++) words[$i]++ } 
     END { for (w in words) print w, words[w] }' text.txt

#!/bin/bash

# Analyse eines Apache-Zugriffslogfiles mit awk
cat << 'EOF' > analyze_log.awk
BEGIN {
    FS = " "
    print "=== Apache Log Analysis ==="
    print "IP Address\t\tRequests\t404s\tBytes Sent"
    print "---------------------------------------------------"
}

{
    # Sammeln von Statistiken
    ip_count[$1]++
    
    # Zählen von 404-Fehlern
    if ($9 == 404) {
        ip_404[$1]++
    }
    
    # Summe der gesendeten Bytes
    if ($10 ~ /^[0-9]+$/) {
        ip_bytes[$1] += $10
    }
}

END {
    # Ausgabe der Ergebnisse
    for (ip in ip_count) {
        printf "%-15s\t%d\t\t%d\t%d\n", ip, ip_count[ip], ip_404[ip] ? ip_404[ip] : 0, ip_bytes[ip] ? ip_bytes[ip] : 0
    }
    
    print "\n=== Summary ==="
    print "Total Requests:", NR
    print "Unique IP Addresses:", length(ip_count)
    
    # Finden der IP mit den meisten Anfragen
    max_requests = 0
    max_ip = ""
    for (ip in ip_count) {
        if (ip_count[ip] > max_requests) {
            max_requests = ip_count[ip]
            max_ip = ip
        }
    }
    print "Most Active IP:", max_ip, "with", max_requests, "requests"
}
EOF

# Anwenden des awk-Skripts auf eine Logdatei
awk -f analyze_log.awk access.log

# Gemeinsame Zeilen in zwei Dateien finden
grep -Fx -f file1.txt file2.txt

# Alle Prozesse eines Benutzers beenden
ps -ef | grep username | grep -v grep | awk '{ print $2 }' | xargs kill

# Top 10 IP-Adressen in einem Apache-Zugriffslog
awk '{ print $1 }' access.log | sort | uniq -c | sort -nr | head -10

# CSV-Daten verarbeiten und nach einer bestimmten Spalte filtern
cat data.csv | awk -F';' '$3 > 1000 { print $1 "," $2 "," $3 }' | sed 's/,/;/g' > filtered.csv

# Tägliche Zusammenfassung aus einem Logfile extrahieren
grep "$(date +%Y-%m-%d)" system.log | \
    sed 's/^.*ERROR: \(.*\)$/\1/' | \
    awk '!seen[$0]++' | \
    sed 's/^/- /' > daily_error_summary.txt

#!/bin/bash

# Logfile-Analysator mit grep, sed und awk

if [ $# -ne 1 ]; then
    echo "Verwendung: $0 <logfile>"
    exit 1
fi

LOGFILE="$1"

if [ ! -f "$LOGFILE" ]; then
    echo "Fehler: Datei '$LOGFILE' nicht gefunden."
    exit 2
fi

echo "=== Logfile-Analyse für $LOGFILE ==="
echo ""

# 1. Anzahl der Einträge
TOTAL_ENTRIES=$(wc -l < "$LOGFILE")
echo "Gesamtanzahl der Einträge: $TOTAL_ENTRIES"

# 2. Verteilung nach Schweregrad mit grep und wc
echo -e "\nVerteilung nach Schweregrad:"
echo "---------------------------"
ERRORS=$(grep -c "ERROR" "$LOGFILE")
WARNINGS=$(grep -c "WARNING" "$LOGFILE")
INFO=$(grep -c "INFO" "$LOGFILE")
DEBUG=$(grep -c "DEBUG" "$LOGFILE")

echo "ERROR:   $ERRORS"
echo "WARNING: $WARNINGS"
echo "INFO:    $INFO"
echo "DEBUG:   $DEBUG"

# 3. Häufigste Fehlermeldungen mit grep, sed und sort
echo -e "\nTop 5 häufigste Fehlermeldungen:"
echo "------------------------------"
grep "ERROR" "$LOGFILE" | \
    sed -E 's/^.*ERROR[^:]*: (.*)/\1/' | \
    sort | uniq -c | sort -nr | head -5 | \
    awk '{ printf("%3d: %s\n", $1, substr($0, index($0, $2))) }'

# 4. Zeitliche Verteilung mit awk
echo -e "\nZeitliche Verteilung:"
echo "-------------------"
grep -E "^[0-9]{4}-[0-9]{2}-[0-9]{2}" "$LOGFILE" | \
    awk '{
        # Extrahieren des Datums (angenommen Format: YYYY-MM-DD HH:MM:SS)
        split($1, date_parts, "-")
        year = date_parts[1]
        month = date_parts[2]
        
        # Zählen nach Monat
        counts[month]++
    }
    END {
        for (month = 1; month <= 12; month++) {
            m = sprintf("%02d", month)
            count = counts[m] ? counts[m] : 0
            bar = ""
            # Erstellen eines einfachen Balkengraphen
            for (i = 0; i < count / 100; i++) bar = bar "#"
            printf("Monat %s: %5d %s\n", m, count, bar)
        }
    }'

# 5. Systemkomponenten mit den meisten Fehlern
echo -e "\nSystemkomponenten mit den meisten Problemen:"
echo "------------------------------------------"
grep -E "ERROR|WARNING" "$LOGFILE" | \
    sed -E 's/^.*\[([^]]+)\].*$/\1/' | \
    sort | uniq -c | sort -nr | head -5 | \
    awk '{ printf("%3d: %s\n", $1, substr($0, index($0, $2))) }'

echo -e "\nAnalyse abgeschlossen."

# Einfache alphabetische Sortierung
sort datei.txt

# Numerische Sortierung
sort -n zahlen.txt

# Umgekehrte Sortierung
sort -r datei.txt

# Sortieren nach der dritten Spalte (numerisch)
sort -k3,3n daten.txt

# Zufällige Reihenfolge (shuffle)
sort -R datei.txt

# CSV-Datei nach der zweiten Spalte (numerisch) sortieren
sort -t';' -k2,2n daten.csv

# Sortieren einer Datei mit IP-Adressen
sort -t. -k1,1n -k2,2n -k3,3n -k4,4n ips.txt

# Top 10 der am häufigsten vorkommenden Wörter in einer Datei
cat textdatei.txt | tr -s ' ' '\n' | sort | uniq -c | sort -nr | head -10

# Duplikate entfernen
sort datei.txt | uniq

# Zählen, wie oft jede Zeile vorkommt
sort datei.txt | uniq -c

# Nur Zeilen anzeigen, die mehrfach vorkommen
sort datei.txt | uniq -d

# Nur Zeilen anzeigen, die nur einmal vorkommen
sort datei.txt | uniq -u

# Extrahieren von Zeichen 3-8 aus jeder Zeile
cut -c3-8 datei.txt

# Extrahieren der ersten und dritten Spalte (durch Tabulator getrennt)
cut -f1,3 daten.tsv

# Extrahieren der zweiten Spalte (durch Doppelpunkt getrennt)
cut -d':' -f2 /etc/passwd

# Zwei Dateien Zeile für Zeile zusammenfügen (TAB-getrennt)
paste datei1.txt datei2.txt

# Mit benutzerdefiniertem Trennzeichen
paste -d':' datei1.txt datei2.txt

# Eine Datei in mehrere Spalten umwandeln
paste -d',' - - - < eineSpalte.txt > dreiSpalten.csv

# Verknüpfen zweier Dateien über das erste Feld
join file1.txt file2.txt

# Verknüpfen über das zweite Feld in der ersten Datei und das erste Feld in der zweiten Datei
join -1 2 -2 1 file1.txt file2.txt

# Ausgabe spezifischer Felder
join -o 1.1,1.3,2.2 file1.txt file2.txt

# Aufteilen einer Datei in 1000-Zeilen-Stücke
split -l 1000 large_file.txt chunk_

# Aufteilen in Stücke bestimmter Größe
split -b 10M large_file.dat piece_

# Aufteilen mit angepassten Suffixen
split -l 100 -d data.csv data_part_

# Umwandlung von Kleinbuchstaben in Großbuchstaben
cat file.txt | tr 'a-z' 'A-Z'

# Löschen bestimmter Zeichen
cat file.txt | tr -d '\n\r\t'

# Komprimieren von wiederholten Zeichen
echo "viele    Leerzeichen" | tr -s ' '

# Tabs in Leerzeichen umwandeln
expand tabbed_file.txt > spaces_file.txt

# Leerzeichen in Tabs umwandeln
unexpand -a spaces_file.txt > tabbed_file.txt

# Umbruch nach 80 Zeichen
fold -w 80 long_line_file.txt

# Umbruch nach 40 Zeichen an Leerzeichen
fold -w 40 -s long_line_file.txt

# Vollständige Statistik
wc file.txt

# Nur Zeilen zählen
wc -l file.txt

# Nur Wörter zählen
wc -w file.txt

# Nur Bytes zählen
wc -c file.txt

# Ausgabe in drei Spalten (exklusiv-1, exklusiv-2, gemeinsam)
comm file1.txt file2.txt

# Nur Zeilen zeigen, die in beiden Dateien vorkommen
comm -12 file1.txt file2.txt

# Nur Zeilen zeigen, die ausschließlich in der ersten Datei vorkommen
comm -23 file1.txt file2.txt

# Standardausgabe
diff file1.txt file2.txt

# Seite-an-Seite-Vergleich
diff -y file1.txt file2.txt

# Zusammenfassende Statistik
diff -s file1.txt file2.txt

# Kontextdiff mit 3 Zeilen Kontext
diff -c3 file1.txt file2.txt

# Patch von diff-Ausgabe erstellen
diff -u original.txt modified.txt > changes.patch

# Patch auf eine Datei anwenden
patch original.txt < changes.patch

# Rückgängig machen eines Patches
patch -R original.txt < changes.patch

#!/bin/bash
# Findet und meldet doppelte Einträge in einer Datendatei

if [ $# -ne 1 ]; then
    echo "Verwendung: $0 <datendatei>"
    exit 1
fi

DATAFILE=$1

if [ ! -f "$DATAFILE" ]; then
    echo "Fehler: Datei nicht gefunden: $DATAFILE"
    exit 2
fi

# Spalte festlegen, nach der gesucht werden soll (z.B. Email-Adressen in Spalte 3)
COLUMN=3
DELIMITER=","

echo "Suche nach doppelten Einträgen in Spalte $COLUMN..."

# Extrahieren der Spalte, sortieren, zählen und filtern
cut -d"$DELIMITER" -f"$COLUMN" "$DATAFILE" | sort | uniq -c | sort -nr | grep -v "^ *1 " > duplicates.tmp

if [ -s duplicates.tmp ]; then
    COUNT=$(wc -l < duplicates.tmp)
    echo "Gefunden: $COUNT doppelte Einträge."
    echo "Häufigste Duplikate:"
    head -10 duplicates.tmp

    # Extraktion der tatsächlichen doppelten Werte
    awk '{ $1=""; print substr($0,2) }' duplicates.tmp > duplicate_values.tmp
    
    echo -e "\nBeispiele von betroffenen Zeilen:"
    # Für jeden doppelten Wert einige Beispielzeilen ausgeben
    COUNT=0
    while read -r value && [ $COUNT -lt 5 ]; do
        echo -e "\nDuplikat: $value"
        grep "$value" "$DATAFILE" | head -3
        COUNT=$((COUNT + 1))
    done < duplicate_values.tmp
else
    echo "Keine doppelten Einträge gefunden."
fi

# Aufräumen
rm -f duplicates.tmp duplicate_values.tmp

exit 0

#!/bin/bash
# Extrahiert und transformiert Daten aus einer CSV-Datei für einen Bericht

INPUT_FILE=$1
OUTPUT_FILE="report_$(date +%Y%m%d).csv"
TEMP_DIR=$(mktemp -d)

if [ ! -f "$INPUT_FILE" ]; then
    echo "Fehler: Eingabedatei nicht gefunden."
    exit 1
fi

echo "Verarbeite Datei: $INPUT_FILE"
echo "Ausgabe wird gespeichert in: $OUTPUT_FILE"

# 1. Extrahieren relevanter Spalten
echo "1. Extrahieren relevanter Spalten..."
cut -d',' -f1,3,5,7 "$INPUT_FILE" > "$TEMP_DIR/step1.csv"

# 2. Filtern nach bestimmten Kriterien
echo "2. Filtern der Daten..."
grep -v "^#" "$TEMP_DIR/step1.csv" | grep "ACTIVE" > "$TEMP_DIR/step2.csv"

# 3. Sortieren nach der ersten Spalte
echo "3. Sortieren der Daten..."
sort -t',' -k1,1 "$TEMP_DIR/step2.csv" > "$TEMP_DIR/step3.csv"

# 4. Hinzufügen einer Kopfzeile
echo "4. Formatieren der Ausgabe..."
echo "ID,Name,Status,Wert" > "$OUTPUT_FILE"
cat "$TEMP_DIR/step3.csv" >> "$OUTPUT_FILE"

# 5. Zusammenfassung erstellen
echo "5. Zusammenfassung erstellen..."
TOTAL_RECORDS=$(wc -l < "$TEMP_DIR/step3.csv")
TOTAL_VALUE=$(cut -d',' -f4 "$TEMP_DIR/step3.csv" | tr -d '$' | awk '{ sum += $1 } END { print sum }')

echo -e "\nBerichtszusammenfassung:"
echo "------------------------"
echo "Datensätze gesamt: $TOTAL_RECORDS"
echo "Gesamtwert: \$$TOTAL_VALUE"

# Säubern
rm -rf "$TEMP_DIR"

echo "Verarbeitung abgeschlossen."

#!/bin/bash
# Rotiert Logdateien und erstellt komprimierte Backups

LOG_DIR="/var/log/myapp"
MAX_LOGS=5
TIMESTAMP=$(date +%Y%m%d-%H%M%S)

# Prüfen, ob das Verzeichnis existiert
if [ ! -d "$LOG_DIR" ]; then
    echo "Fehler: Log-Verzeichnis nicht gefunden: $LOG_DIR"
    exit 1
fi

# Aktive Logdatei rotieren
if [ -f "$LOG_DIR/current.log" ]; then
    echo "Rotiere aktive Logdatei..."
    
    # Kopfzeilen (erste 10 Zeilen) extrahieren
    head -10 "$LOG_DIR/current.log" > "$LOG_DIR/header.tmp"
    
    # Zusammenfassung erstellen
    echo "Erstelle Zusammenfassung..."
    TOTAL_LINES=$(wc -l < "$LOG_DIR/current.log")
    ERROR_LINES=$(grep -c "ERROR" "$LOG_DIR/current.log")
    WARNING_LINES=$(grep -c "WARNING" "$LOG_DIR/current.log")
    
    # Extrahieren der letzten 100 Fehler für das Inhaltsverzeichnis
    grep "ERROR" "$LOG_DIR/current.log" | tail -100 > "$LOG_DIR/errors.tmp"
    
    # Zusammenfassungsdatei erstellen
    cat > "$LOG_DIR/summary_$TIMESTAMP.txt" << EOF
LOG ROTATION SUMMARY - $TIMESTAMP
===============================
Datei: current.log
Zeilen gesamt: $TOTAL_LINES
Fehler: $ERROR_LINES
Warnungen: $WARNING_LINES

TOP ERRORS:
-----------
$(sort "$LOG_DIR/errors.tmp" | uniq -c | sort -nr | head -10)

FIRST ENTRIES:
-------------
$(head -5 "$LOG_DIR/current.log")

LAST ENTRIES:
------------
$(tail -5 "$LOG_DIR/current.log")
EOF
    
    # Komprimieren und archivieren der aktuellen Logdatei
    echo "Komprimiere Logdatei..."
    cat "$LOG_DIR/header.tmp" "$LOG_DIR/summary_$TIMESTAMP.txt" > "$LOG_DIR/index_$TIMESTAMP.txt"
    tar -czf "$LOG_DIR/archive/log_$TIMESTAMP.tar.gz" -C "$LOG_DIR" current.log index_$TIMESTAMP.txt
    
    # Aktive Logdatei leeren
    echo "Datei gesäubert: $(date)" > "$LOG_DIR/current.log"
    
    # Aufräumen
    rm -f "$LOG_DIR/header.tmp" "$LOG_DIR/errors.tmp"
    
    # Alte Archivdateien rotieren
    echo "Rotiere alte Archive..."
    ls -t "$LOG_DIR/archive/"*.tar.gz | tail -n +$((MAX_LOGS+1)) | xargs -r rm
    
    echo "Logrotation abgeschlossen."
else
    echo "Keine aktive Logdatei gefunden."
fi

exit 0

# Ausgabeumleitungen
command > file        # Stdout in Datei umleiten (überschreibt)
command >> file       # Stdout an Datei anhängen
command 2> file       # Stderr in Datei umleiten
command &> file       # Stdout und Stderr in Datei umleiten
command > file 2>&1   # Stdout und Stderr in Datei umleiten (alternativer Syntax)

# Eingabeumleitungen
command < file        # Stdin aus Datei lesen
command << EOL        # Here-Document (Eingabe bis zum Begrenzungswort)
...
EOL
command <<< "string"  # Here-String (Eingabe aus dem angegebenen String)

# Pipes
command1 | command2   # Stdout von command1 an stdin von command2 weiterleiten

# Aktivieren der noclobber-Option
set -o noclobber

# Versuch, eine existierende Datei zu überschreiben
echo "Neuer Inhalt" > datei.txt    # Fehlermeldung, wenn die Datei existiert

# Erzwingen des Überschreibens trotz noclobber
echo "Neuer Inhalt" >| datei.txt   # Überschreiben erzwingen

#!/bin/bash

# Einfaches zeilenweises Lesen einer Datei
while IFS= read -r line; do
    echo "Verarbeite Zeile: $line"
done < "datei.txt"

#!/bin/bash

# CSV-Datei lesen und nach Spalten aufteilen
while IFS=',' read -r spalte1 spalte2 spalte3 rest; do
    echo "Spalte 1: $spalte1"
    echo "Spalte 2: $spalte2"
    echo "Spalte 3: $spalte3"
    echo "Rest: $rest"
    echo "-------------------"
done < "daten.csv"

#!/bin/bash

# CSV-Datei lesen und in ein Array einlesen
while IFS=',' read -r -a felder; do
    echo "Anzahl der Felder: ${#felder[@]}"
    echo "Erstes Feld: ${felder[0]}"
    echo "Zweites Feld: ${felder[1]}"
    
    # Alle Felder durchlaufen
    for i in "${!felder[@]}"; do
        echo "Feld $i: ${felder[$i]}"
    done
    echo "-------------------"
done < "daten.csv"

#!/bin/bash

# Gesamte Datei in eine Variable einlesen
inhalt=$(<datei.txt)
echo "Dateiinhalt: $inhalt"

# Alternative Methode (funktioniert auch in älteren Bash-Versionen)
inhalt=$(cat datei.txt)
echo "Dateiinhalt: $inhalt"

#!/bin/bash

zeilennr=0
while IFS= read -r line; do
    ((zeilennr++))
    echo "$zeilennr: $line"
done < "datei.txt"

#!/bin/bash

# Nur bestimmte Zeilen lesen (z.B. Zeilen 5-10)
start_line=5
end_line=10
current_line=0

while IFS= read -r line && [ $current_line -le $end_line ]; do
    ((current_line++))
    
    if [ $current_line -ge $start_line ]; then
        echo "Zeile $current_line: $line"
    fi
done < "datei.txt"

#!/bin/bash

# Datei erstellen/überschreiben
echo "Zeile 1" > datei.txt

# An Datei anhängen
echo "Zeile 2" >> datei.txt
echo "Zeile 3" >> datei.txt

#!/bin/bash

# Mehrere Zeilen in eine Datei schreiben
cat > konfiguration.ini << 'EOL'
[Abschnitt1]
Option1=Wert1
Option2=Wert2

[Abschnitt2]
Option3=Wert3
# Dies ist ein Kommentar
Option4=Wert4
EOL

#!/bin/bash

name="Max Mustermann"
datum=$(date +"%Y-%m-%d")
version="1.0"

# Template mit dynamischem Inhalt erstellen
cat > bericht.txt << EOL
Bericht generiert von: $name
Datum: $datum
Version: $version

Zusammenfassung:
---------------
$(ls -la | head -5)

Systeminfos:
-----------
$(uname -a)
EOL

#!/bin/bash

# Formatierte Ausgabe in eine Datei schreiben
printf "%-20s %10s %8s\n" "Name" "Wert" "Status" > tabelle.txt
printf "%-20s %10d %8s\n" "Parameter1" 42 "aktiv" >> tabelle.txt
printf "%-20s %10.2f %8s\n" "Parameter2" 3.14159 "inaktiv" >> tabelle.txt

#!/bin/bash

datei="konfiguration.txt"
tempfile=$(mktemp)

# Datei ändern und in temporäre Datei schreiben
while IFS= read -r line; do
    # Zeile modifizieren (Beispiel: "DEBUG" durch "INFO" ersetzen)
    modified_line=${line//DEBUG/INFO}
    echo "$modified_line" >> "$tempfile"
done < "$datei"

# Temporäre Datei zurück in die Originaldatei verschieben
mv "$tempfile" "$datei"

#!/bin/bash

# Temporäre Datei erstellen
tempfile=$(mktemp)

# Aufräumen bei Beendigung sicherstellen
trap 'rm -f "$tempfile"' EXIT

# Mit der temporären Datei arbeiten
echo "Daten" > "$tempfile"
# ... weitere Operationen

# Aufräumen passiert automatisch durch die trap-Anweisung

#!/bin/bash

datei="dokument.txt"
tempfile=$(mktemp)
zeile_zum_einfügen="Dieser Text wird nach Zeile 5 eingefügt."
position=5

# Zeilenweise lesen und modifizieren
zeilennr=0
while IFS= read -r line; do
    ((zeilennr++))
    echo "$line" >> "$tempfile"
    
    # Nach der angegebenen Position den neuen Inhalt einfügen
    if [ $zeilennr -eq $position ]; then
        echo "$zeile_zum_einfügen" >> "$tempfile"
    fi
done < "$datei"

# Temporäre Datei zurück in die Originaldatei verschieben
mv "$tempfile" "$datei"

#!/bin/bash

datei="/pfad/zur/datei.txt"

# Existenz prüfen
if [ -e "$datei" ]; then
    echo "Datei existiert"
fi

# Prüfen, ob es sich um eine reguläre Datei handelt
if [ -f "$datei" ]; then
    echo "Es ist eine reguläre Datei"
fi

# Prüfen, ob es sich um ein Verzeichnis handelt
if [ -d "$datei" ]; then
    echo "Es ist ein Verzeichnis"
fi

# Lese-, Schreib- und Ausführungsrechte prüfen
if [ -r "$datei" ]; then
    echo "Datei ist lesbar"
fi

if [ -w "$datei" ]; then
    echo "Datei ist beschreibbar"
fi

if [ -x "$datei" ]; then
    echo "Datei ist ausführbar"
fi

# Dateigröße prüfen
if [ -s "$datei" ]; then
    echo "Datei ist nicht leer"
fi

#!/bin/bash

datei="/pfad/zur/datei.txt"

# Grundlegende Metadaten abrufen
echo "Dateigröße in Bytes: $(stat -c %s "$datei")"
echo "Letzte Änderung: $(stat -c %y "$datei")"
echo "Berechtigungen (Oktal): $(stat -c %a "$datei")"
echo "Eigentümer: $(stat -c %U "$datei")"
echo "Gruppe: $(stat -c %G "$datei")"

#!/bin/bash

# Vergleich zweier Befehlsausgaben
diff <(ls -la /dir1) <(ls -la /dir2)

# Lesen aus der Ausgabe eines Befehls
while read -r line; do
    echo "Verarbeite: $line"
done < <(grep "wichtig" logfile.txt)

#!/bin/bash

# Parallel durch mehrere Dateien iterieren
paste <(cat datei1.txt) <(cat datei2.txt) <(cat datei3.txt) | while read -r col1 col2 col3; do
    echo "Zeile aus Datei 1: $col1"
    echo "Zeile aus Datei 2: $col2"
    echo "Zeile aus Datei 3: $col3"
    echo "-------------------"
done

#!/bin/bash

# Hexadezimale Darstellung einer Binärdatei erzeugen
hexdump -C binärdatei.bin > hexdarstellung.txt

# Ersten 10 Bytes einer Datei lesen (in Hexadezimal)
head -c 10 binärdatei.bin | xxd

# Binärdateien vergleichen
cmp -l datei1.bin datei2.bin | gawk '{printf "%08X %02X %02X\n", $1, strtonum(sprintf("0x%02X", $2)), strtonum(sprintf("0x%02X", $3))}'

#!/bin/bash

# INEFFIZIENT: Wiederholtes Anhängen an eine Datei in einer Schleife
for i in {1..1000}; do
    echo "Zeile $i" >> ausgabe.txt
done

# BESSER: Ausgabe sammeln und einmal schreiben
{
    for i in {1..1000}; do
        echo "Zeile $i"
    done
} > ausgabe.txt

#!/bin/bash

# INEFFIZIENT für große Dateien: Alles auf einmal einlesen
inhalt=$(<große_datei.txt)

# BESSER: Zeilenweise verarbeiten
while IFS= read -r line; do
    # Verarbeite jede Zeile einzeln
    process_line "$line"
done < "große_datei.txt"

#!/bin/bash

# Effizienter: Mehrere Zeilen auf einmal schreiben
{
    echo "Zeile 1"
    echo "Zeile 2"
    echo "Zeile 3"
    # ... weitere Ausgaben
} > ausgabe.txt

#!/bin/bash
# Extrahiert bestimmte Spalten aus einer CSV-Datei

input_file="daten.csv"
output_file="extrahiert.csv"
columns=(1 3 5)  # Spalten, die extrahiert werden sollen (1-basiert)

# Header überprüfen und Spaltennamen ausgeben
if [[ -f "$input_file" ]]; then
    header=$(head -1 "$input_file")
    IFS=',' read -r -a header_fields <<< "$header"
    
    echo "Verfügbare Spalten:"
    for i in "${!header_fields[@]}"; do
        echo "$((i+1)): ${header_fields[$i]}"
    done
    
    # Extrahierten Header erstellen
    extracted_header=""
    for col in "${columns[@]}"; do
        idx=$((col-1))
        if [[ $idx -lt ${#header_fields[@]} ]]; then
            if [[ -n "$extracted_header" ]]; then
                extracted_header="$extracted_header,${header_fields[$idx]}"
            else
                extracted_header="${header_fields[$idx]}"
            fi
        fi
    done
    
    # Header in die Ausgabedatei schreiben
    echo "$extracted_header" > "$output_file"
    
    # Zeilenweise die Datei lesen und extrahieren
    tail -n +2 "$input_file" | while IFS=',' read -r -a fields; do
        line=""
        for col in "${columns[@]}"; do
            idx=$((col-1))
            if [[ $idx -lt ${#fields[@]} ]]; then
                if [[ -n "$line" ]]; then
                    line="$line,${fields[$idx]}"
                else
                    line="${fields[$idx]}"
                fi
            fi
        done
        echo "$line" >> "$output_file"
    done
    
    echo "Extraktion abgeschlossen. Ausgabe in $output_file"
else
    echo "Fehler: Eingabedatei $input_file nicht gefunden!"
    exit 1
fi

#!/bin/bash
# Liest und modifiziert eine Konfigurationsdatei im INI-Format

config_file="config.ini"
temp_file=$(mktemp)
section=""

# Aufräumen bei Beendigung
trap 'rm -f "$temp_file"' EXIT

# Funktion zum Setzen eines Wertes in der Konfigurationsdatei
update_config() {
    local target_section="$1"
    local key="$2"
    local value="$3"
    local found=false
    local section_found=false
    
    # Datei lesen und modifizieren
    while IFS= read -r line; do
        # Abschnitt erkennen
        if [[ "$line" =~ ^\[([^]]+)\]$ ]]; then
            section="${BASH_REMATCH[1]}"
            if [[ "$section" == "$target_section" ]]; then
                section_found=true
            fi
        # Schlüssel/Wert-Paar in richtigem Abschnitt erkennen und ändern
        elif [[ "$section" == "$target_section" && "$line" =~ ^($key)[[:space:]]*=[[:space:]]*(.*)$ ]]; then
            echo "$key = $value"
            found=true
        else
            echo "$line"
        fi
    done < "$config_file" > "$temp_file"
    
    # Wenn Abschnitt existiert, aber der Schlüssel nicht gefunden wurde
    if $section_found && ! $found; then
        # Zurück zum Abschnitt gehen und den Schlüssel hinzufügen
        section=""
        while IFS= read -r line; do
            echo "$line"
            if [[ "$line" =~ ^\[([^]]+)\]$ ]]; then
                section="${BASH_REMATCH[1]}"
                if [[ "$section" == "$target_section" ]]; then
                    echo "$key = $value"
                fi
            fi
        done < "$temp_file" > "$temp_file.2"
        mv "$temp_file.2" "$temp_file"
    fi
    
    # Wenn weder Abschnitt noch Schlüssel gefunden wurden
    if ! $section_found; then
        {
            echo ""
            echo "[$target_section]"
            echo "$key = $value"
        } >> "$temp_file"
    fi
    
    # Temporäre Datei in die Konfigurationsdatei kopieren
    mv "$temp_file" "$config_file"
}

# Funktion zum Auslesen eines Werts aus der Konfigurationsdatei
read_config() {
    local target_section="$1"
    local key="$2"
    local default_value="${3:-}"
    local value="$default_value"
    local current_section=""
    
    if [[ -f "$config_file" ]]; then
        while IFS= read -r line; do
            # Leere Zeilen und Kommentare überspringen
            [[ -z "$line" || "$line" =~ ^[[:space:]]*[#;] ]] && continue
            
            # Abschnitt erkennen
            if [[ "$line" =~ ^\[([^]]+)\]$ ]]; then
                current_section="${BASH_REMATCH[1]}"
                continue
            fi
            
            # Schlüssel/Wert-Paar im richtigen Abschnitt erkennen
            if [[ "$current_section" == "$target_section" && "$line" =~ ^($key)[[:space:]]*=[[:space:]]*(.*)$ ]]; then
                value="${BASH_REMATCH[2]}"
                # Anführungszeichen entfernen, falls vorhanden
                value="${value#\"}"
                value="${value%\"}"
                value="${value#\'}"
                value="${value%\'}"
                break
            fi
        done < "$config_file"
    fi
    
    echo "$value"
}

# Beispiel: Konfigurationswerte lesen
server_ip=$(read_config "Server" "ip" "localhost")
port=$(read_config "Server" "port" "8080")
username=$(read_config "Credentials" "username" "admin")

echo "Aktuelle Konfiguration:"
echo "Server IP: $server_ip"
echo "Port: $port"
echo "Username: $username"

# Beispiel: Konfigurationswerte setzen
update_config "Server" "port" "9090"
update_config "Logging" "level" "DEBUG"

echo "Konfiguration aktualisiert."

#!/bin/bash
# Verarbeitet eine Logdatei und erstellt eine statistische Auswertung

log_file="/var/log/apache2/access.log"
output_file="log_stats_$(date +%Y%m%d).txt"

if [ ! -f "$log_file" ]; then
    echo "Fehler: Logdatei $log_file nicht gefunden!"
    exit 1
fi

# Temporäres Verzeichnis für die Verarbeitung
temp_dir=$(mktemp -d)
trap 'rm -rf "$temp_dir"' EXIT

echo "Verarbeite Logdatei: $log_file"
echo "Ausgabe wird gespeichert in: $output_file"

# IP-Adressen extrahieren
awk '{print $1}' "$log_file" > "$temp_dir/ips.txt"

# HTTP-Statuscodes extrahieren
awk '{print $9}' "$log_file" > "$temp_dir/status_codes.txt"

# Anfrage-URLs extrahieren
awk '{print $7}' "$log_file" > "$temp_dir/urls.txt"

# Zeitstempel extrahieren
awk '{print $4 $5}' "$log_file" | tr -d '[]' > "$temp_dir/timestamps.txt"

# Statistik erstellen
{
    echo "=== LOGDATEI-STATISTIK ==="
    echo "Generiert am: $(date)"
    echo "Datei: $log_file"
    echo "Zeitraum: $(head -1 "$temp_dir/timestamps.txt") bis $(tail -1 "$temp_dir/timestamps.txt")"
    echo ""
    
    echo "=== ALLGEMEINE INFORMATIONEN ==="
    echo "Gesamtzahl der Einträge: $(wc -l < "$log_file")"
    echo "Eindeutige IP-Adressen: $(sort "$temp_dir/ips.txt" | uniq | wc -l)"
    echo ""
    
    echo "=== TOP 10 IP-ADRESSEN ==="
    sort "$temp_dir/ips.txt" | uniq -c | sort -nr | head -10
    echo ""
    
    echo "=== HTTP-STATUSCODE-VERTEILUNG ==="
    sort "$temp_dir/status_codes.txt" | uniq -c | sort -nr
    echo ""
    
    echo "=== TOP 10 ANFRAGE-URLS ==="
    sort "$temp_dir/urls.txt" | uniq -c | sort -nr | head -10
    echo ""
    
    echo "=== STÜNDLICHE VERTEILUNG ==="
    awk '{print substr($4,2,2)}' "$log_file" | sort | uniq -c | sort -k2,2n | awk '{printf "Stunde %s: %s Anfragen\n", $2, $1}'
    echo ""
    
    echo "=== FEHLERSTATISTIK ==="
    grep -E ' (4[0-9]{2}|5[0-9]{2}) ' "$log_file" | awk '{print $9}' | sort | uniq -c | sort -nr
    echo ""
    
    echo "=== DURCHSCHNITTLICHE ANTWORTGRÖSSE ==="
    awk '{sum+=$10; count++} END {printf "%.2f Bytes pro Anfrage\n", sum/count}' "$log_file"
    echo ""
    
    echo "=== ABSCHLUSS ==="
    echo "Auswertung abgeschlossen."
    echo "Weitere Informationen finden Sie in der ausführlichen Analyse."
} > "$output_file"

echo "Statistik wurde erstellt in: $output_file"
exit 0

#!/bin/bash

# Festlegen des Feldtrennzeichens für `read`
IFS=','

# Überspringen der Kopfzeile (optional)
read -r header < "daten.csv"
echo "Spaltenüberschriften: $header"

# Zeilenweise durch die Datei iterieren (ohne Kopfzeile)
tail -n +2 "daten.csv" | while read -r name alter stadt; do
    echo "Name: $name, Alter: $alter, Stadt: $stadt"
done

#!/bin/bash

# CSV-Datei mit dynamischer Spaltenzahl verarbeiten
while IFS=',' read -r -a fields; do
    echo "Zeile enthält ${#fields[@]} Felder:"
    for i in "${!fields[@]}"; do
        echo "  Feld $i: ${fields[$i]}"
    done
done < "daten.csv"

#!/bin/bash

# CSV mit Anführungszeichen und Escape-Sequenzen verarbeiten
awk -F, '
BEGIN {
    FPAT = "([^,]+)|(\"[^\"]+\")"  # Pattern für Felder: entweder ohne Komma oder in Anführungszeichen
}
{
    for (i = 1; i <= NF; i++) {
        # Anführungszeichen entfernen und maskierte Anführungszeichen entfernen
        gsub(/^"|"$/, "", $i)
        gsub(/""/, "\"", $i)
        printf "Feld %d: %s\n", i, $i
    }
    printf "\n"
}' komplexe_daten.csv

#!/bin/bash

# CSV mit Kopfzeilen verarbeiten
csv_file="daten.csv"

# Kopfzeile lesen und als Spaltennamen verwenden
IFS=',' read -r -a headers < "$csv_file"

# Durch die Datenzeilen iterieren
tail -n +2 "$csv_file" | while IFS=',' read -r -a values; do
    echo "Datensatz:"
    for i in "${!headers[@]}"; do
        if [ $i -lt ${#values[@]} ]; then
            echo "  ${headers[$i]}: ${values[$i]}"
        fi
    done
    echo ""
done

#!/bin/bash

# Filtern von CSV-Zeilen nach Kriterien
csv_file="mitarbeiter.csv"
filter_city="Berlin"
min_age=30

# Kopfzeile beibehalten
head -1 "$csv_file" > "gefiltert.csv"

# Filtern und Anhängen der passenden Zeilen
tail -n +2 "$csv_file" | while IFS=',' read -r name alter stadt; do
    # Nur Mitarbeiter aus Berlin, die mindestens 30 Jahre alt sind
    if [[ "$stadt" == "$filter_city" && $alter -ge $min_age ]]; then
        echo "$name,$alter,$stadt" >> "gefiltert.csv"
    fi
done

echo "Gefilterte Daten wurden in gefiltert.csv gespeichert."

#!/bin/bash

# Spalten auswählen und neu anordnen
input_csv="quelldaten.csv"
output_csv="zieldaten.csv"
columns=(3 1 4)  # Indizes der gewünschten Spalten (1-basiert)

# Kopfzeile entsprechend den ausgewählten Spalten umordnen
IFS=',' read -r -a headers < "$input_csv"
new_header=""
for col in "${columns[@]}"; do
    index=$((col - 1))
    if [ $index -lt ${#headers[@]} ]; then
        if [ -n "$new_header" ]; then
            new_header+=","
        fi
        new_header+="${headers[$index]}"
    fi
done
echo "$new_header" > "$output_csv"

# Datenzeilen entsprechend transformieren
tail -n +2 "$input_csv" | while IFS=',' read -r -a fields; do
    new_line=""
    for col in "${columns[@]}"; do
        index=$((col - 1))
        if [ $index -lt ${#fields[@]} ]; then
            if [ -n "$new_line" ]; then
                new_line+=","
            fi
            new_line+="${fields[$index]}"
        fi
    done
    echo "$new_line" >> "$output_csv"
done

echo "Spalten wurden neu angeordnet und in $output_csv gespeichert."

#!/bin/bash

# Aggregation von CSV-Daten nach einer Gruppierungsspalte
csv_file="verkaufsdaten.csv"
group_column=2  # Region (Spaltenindex, 1-basiert)
value_column=3  # Verkaufsbetrag (Spaltenindex, 1-basiert)

# Überspringen der Kopfzeile
tail -n +2 "$csv_file" | {
    # Arrays für die Aggregation
    declare -A sum
    declare -A count
    
    # Einlesen und Aggregieren der Daten
    while IFS=',' read -r -a fields; do
        group="${fields[$((group_column-1))]}"
        value="${fields[$((value_column-1))]}"
        
        # Numerische Validierung
        if [[ "$value" =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
            sum["$group"]=$(echo "${sum["$group"]:=0} + $value" | bc)
            ((count["$group"]++))
        fi
    done
    
    # Ausgabe der Ergebnisse
    echo "Region,Anzahl,Summe,Durchschnitt"
    for group in "${!sum[@]}"; do
        avg=$(echo "scale=2; ${sum["$group"]} / ${count["$group"]}" | bc)
        echo "$group,${count["$group"]},${sum["$group"]},$avg"
    done
} | sort -t',' -k3,3nr > "zusammenfassung.csv"

echo "Zusammenfassung wurde in zusammenfassung.csv gespeichert."