18 Performance

$ time ./mein_skript.sh

real    0m3.456s
user    0m2.123s
sys     0m0.876s

#!/bin/bash

# Funktion zur Zeitmessung
measure_time() {
    local start_time=$1
    local end_time=$(date +%s.%N)
    local elapsed=$(echo "$end_time - $start_time" | bc)
    echo "Ausführungszeit: $elapsed Sekunden"
}

# Start der Messung
start_time=$(date +%s.%N)

# Zu messender Code-Block
for i in {1..1000}; do
    echo $i > /dev/null
done

# Ende der Messung und Ausgabe
measure_time $start_time

#!/bin/bash

# Start der Messung
SECONDS=0

# Zu messender Code-Block
for i in {1..1000}; do
    echo $i > /dev/null
done

# Ende der Messung und Ausgabe
duration=$SECONDS
echo "Ausführungszeit: $duration Sekunden"

#!/bin/bash

# Angepasste PS4-Variable für Profiling
export PS4='+ $(date "+%s.%N") ${BASH_SOURCE}:${LINENO}: '

# Trace aktivieren
set -x

# Zu analysierender Code
for i in {1..100}; do
    echo $i > /dev/null
done

grep "pattern" /etc/passwd > /dev/null

# Weitere Befehle...

# Trace deaktivieren
set +x

#!/bin/bash

# Profiling-Funktion
profile_cmd() {
    local start_time=$(date +%s.%N)
    trap 'local end_time=$(date +%s.%N); \
          local duration=$(echo "$end_time - $start_time" | bc); \
          echo "Befehl \"$BASH_COMMAND\" dauerte $duration Sekunden" >&2' DEBUG
}

# Profiling für einen bestimmten Abschnitt aktivieren
profile_cmd

# Zu messender Code-Block
for i in {1..1000}; do
    echo $i > /dev/null
done

# Profiling deaktivieren
trap - DEBUG

$ shellcheck mein_skript.sh

$ perf record -g ./mein_skript.sh
$ perf report

$ iotop -p $(pgrep -f "mein_skript.sh")

$ iostat -dx 1

#!/bin/bash
# log_analyzer.sh - Analysiert Apache-Logdateien

output_file="report.txt"
echo "Log-Analyse gestartet: $(date)" > "$output_file"

# Anzahl der HTTP-Status-Codes zählen
echo "HTTP-Status-Verteilung:" >> "$output_file"

# Potenzieller Leistungsengpass: Mehrfache Dateiverarbeitung
for status_code in 200 301 302 304 403 404 500; do
    count=$(grep -c " $status_code " access.log)
    echo "Status $status_code: $count" >> "$output_file"
done

# Top 10 IP-Adressen finden
echo "Top 10 IP-Adressen:" >> "$output_file"
# Potenzieller Leistungsengpass: Komplexe Pipeline
grep -o "[0-9]\+\.[0-9]\+\.[0-9]\+\.[0-9]\+" access.log | sort | uniq -c | sort -nr | head -10 >> "$output_file"

echo "Log-Analyse beendet: $(date)" >> "$output_file"

#!/bin/bash
# backup_script.sh - Sichert wichtige Verzeichnisse

# Konfiguration
source_dirs=("/home/user/documents" "/var/www" "/etc")
backup_dir="/backup/$(date +%Y-%m-%d)"
log_file="/var/log/backup.log"

# Backup-Verzeichnis erstellen
mkdir -p "$backup_dir"

# Sicherung durchführen
echo "Backup gestartet: $(date)" > "$log_file"

for dir in "${source_dirs[@]}"; do
    echo "Sichere $dir..." >> "$log_file"
    # Potenzieller Leistungsengpass: Einzelne Dateien werden komprimiert
    find "$dir" -type f -name "*.txt" | while read -r file; do
        gzip -c "$file" > "$backup_dir/$(basename "$file").gz"
    done
    
    # Potenzieller Leistungsengpass: Separate tar-Prozesse
    tar -czf "$backup_dir/$(basename "$dir").tar.gz" "$dir"
done

# Alte Backups bereinigen (älter als 30 Tage)
find /backup -type d -mtime +30 -exec rm -rf {} \; 2>/dev/null || true

echo "Backup abgeschlossen: $(date)" >> "$log_file"

#!/bin/bash
# Ineffizient: String mit Trennzeichen
files_string="file1.txt file2.txt file3.txt"
for file in $files_string; do
    process_file "$file"
done

# Effizienter: Array verwenden
files_array=("file1.txt" "file2.txt" "file3.txt")
for file in "${files_array[@]}"; do
    process_file "$file"
done

#!/bin/bash
# Ineffizient: Lineare Suche in einer Liste
users=("alice" "bob" "charlie" "dave" "eve")
permissions=("read" "write" "read" "admin" "read")

get_permission() {
    local user=$1
    for i in "${!users[@]}"; do
        if [[ "${users[$i]}" == "$user" ]]; then
            echo "${permissions[$i]}"
            return
        fi
    done
    echo "none"
}

# Effizienter: Assoziatives Array für O(1) Zugriff
declare -A user_permissions
user_permissions["alice"]="read"
user_permissions["bob"]="write"
user_permissions["charlie"]="read"
user_permissions["dave"]="admin"
user_permissions["eve"]="read"

get_permission_fast() {
    local user=$1
    echo "${user_permissions[$user]:-none}"
}

# Vergleich der Ausführungszeit
time get_permission "eve"
time get_permission_fast "eve"

#!/bin/bash
# Array für die Speicherung bereits berechneter Ergebnisse
declare -A fibonacci_cache

# Recursive Fibonacci with memoization
fibonacci() {
    local n=$1
    
    # Basisfall
    if [[ $n -le 1 ]]; then
        echo $n
        return
    fi
    
    # Prüfen, ob das Ergebnis bereits berechnet wurde
    if [[ -n "${fibonacci_cache[$n]}" ]]; then
        echo "${fibonacci_cache[$n]}"
        return
    fi
    
    # Berechnung durchführen
    local a=$(fibonacci $((n-1)))
    local b=$(fibonacci $((n-2)))
    local result=$((a + b))
    
    # Ergebnis zwischenspeichern
    fibonacci_cache[$n]=$result
    
    echo $result
}

# Beispielverwendung
time fibonacci 30

#!/bin/bash
# Ineffizient: Sortieren und dann Unique in separaten Schritten
sort large_file.txt > sorted.txt
uniq sorted.txt > unique.txt
rm sorted.txt

# Effizienter: Pipeline verwenden, um temporäre Dateien zu vermeiden
sort large_file.txt | uniq > unique.txt

# Noch effizienter: sort mit -u Option (sortiert und entfernt Duplikate)
sort -u large_file.txt > unique.txt

# Parallele Sortierung mit mehreren Threads (auf modernen Systemen)
sort --parallel=4 -u large_file.txt > unique.txt

# Bei sehr großen Dateien: temporäre Dateien im Arbeitsspeicher halten
sort -u --buffer-size=1G large_file.txt > unique.txt

#!/bin/bash
# Ineffizient: Mehrfacher Durchlauf durch die Datei
grep "pattern1" large_file.txt > matches1.txt
grep "pattern2" large_file.txt > matches2.txt
grep "pattern3" large_file.txt > matches3.txt

# Effizienter: Einmaliger Durchlauf mit mehreren Patterns
grep -e "pattern1" -e "pattern2" -e "pattern3" large_file.txt > all_matches.txt

# Alternative: awk für komplexere Muster
awk '/pattern1/ {print > "matches1.txt"} 
     /pattern2/ {print > "matches2.txt"} 
     /pattern3/ {print > "matches3.txt"}' large_file.txt

# Effizienter: Optimierter regulärer Ausdruck
grep -E 'pattern1|pattern2|pattern3' large_file.txt > all_matches.txt

#!/bin/bash
# Binäre Suche in einer sortierten Liste
binary_search() {
    local needle=$1
    shift
    local haystack=("$@")
    local low=0
    local high=$((${#haystack[@]} - 1))
    
    while [[ $low -le $high ]]; do
        local mid=$(( (low + high) / 2 ))
        local mid_val=${haystack[$mid]}
        
        if [[ "$mid_val" == "$needle" ]]; then
            echo "Gefunden an Position $mid"
            return 0
        elif [[ "$mid_val" < "$needle" ]]; then
            low=$((mid + 1))
        else
            high=$((mid - 1))
        fi
    done
    
    echo "Nicht gefunden"
    return 1
}

# Beispiel mit einer sortierten Liste
sorted_array=($(for i in {1..1000}; do echo $i; done))
time binary_search 750 "${sorted_array[@]}"

# Vergleich mit linearer Suche
linear_search() {
    local needle=$1
    shift
    local haystack=("$@")
    
    for i in "${!haystack[@]}"; do
        if [[ "${haystack[$i]}" == "$needle" ]]; then
            echo "Gefunden an Position $i"
            return 0
        fi
    done
    
    echo "Nicht gefunden"
    return 1
}

time linear_search 750 "${sorted_array[@]}"

#!/bin/bash
# Ineffizient: Viele Subshell-Aufrufe
for i in {1..1000}; do
    result=$(echo $i | grep -o "[0-9]")
    # Weitere Verarbeitung...
done

# Effizienter: Bult-in-Funktionen nutzen
for i in {1..1000}; do
    if [[ $i =~ [0-9] ]]; then
        result=$BASH_REMATCH
        # Weitere Verarbeitung...
    fi
done

#!/bin/bash
# Ineffizient: Externe Befehle
file_size=$(stat -c "%s" "$file")
if [ "$file_size" -gt 1024 ]; then
    echo "Datei ist größer als 1 KB"
fi

# Effizienter: Interne Funktionen verwenden (Bash 4+)
if [[ -f "$file" ]]; then
    read -r file_size < <(stat -c "%s" "$file")  # Nur ein externer Aufruf
    if (( file_size > 1024 )); then
        echo "Datei ist größer als 1 KB"
    fi
fi

#!/bin/bash
# Ineffizient: Gesamte Datei in den Speicher laden
lines=$(cat large_file.txt)
for line in $lines; do
    # Verarbeitung...
done

# Effizienter: Zeilenweise Verarbeitung
while IFS= read -r line; do
    # Verarbeitung...
done < large_file.txt

#!/bin/bash
# Ineffizient: Mehrere Durchläufe durch dieselbe Datei
total_lines=$(wc -l < data.txt)
echo "Anzahl der Zeilen: $total_lines"

matched_lines=$(grep "pattern" data.txt | wc -l)
echo "Zeilen mit Treffern: $matched_lines"

# Effizienter: Einmaliger Durchlauf mit awk
awk '
    BEGIN { matches = 0; total = 0; }
    { total++; }
    /pattern/ { matches++; }
    END { print "Anzahl der Zeilen: " total; print "Zeilen mit Treffern: " matches; }
' data.txt

#!/bin/bash
# Vorverarbeitung: Erstellen einer Lookup-Tabelle
create_lookup_table() {
    local input_file=$1
    local output_file=$2
    
    # Index erstellen: ID als Schlüssel, Rest als Wert
    awk -F, '{print $1 ":" $0}' "$input_file" > "$output_file"
    
    # Sortieren für binäre Suche
    sort -t: -k1,1 -o "$output_file" "$output_file"
}

# Beispiel
create_lookup_table "large_data.csv" "indexed_data.txt"

# Schnelles Nachschlagen mittels binärer Suche (mit grep)
lookup_record() {
    local key=$1
    local index_file=$2
    
    # Binäre Suche mit grep
    grep -m1 "^$key:" "$index_file" | cut -d: -f2-
}

# Nutzung
record=$(lookup_record "12345" "indexed_data.txt")
echo "$record"

#!/bin/bash
# Vorverarbeitung: Extrahieren relevanter Spalten
extract_columns() {
    local input_file=$1
    local column_numbers=$2  # Kommagetrennte Liste von Spaltennummern
    local output_prefix=$3
    
    # Für jede angegebene Spalte
    for col in $(echo "$column_numbers" | tr ',' ' '); do
        cut -d, -f"$col" "$input_file" > "${output_prefix}_col${col}.txt"
    done
}

# Beispiel
extract_columns "large_csv.csv" "1,3,5" "extracted"

# Schneller Zugriff auf eine bestimmte Spalte
column_data=$(cat "extracted_col3.txt")

#!/bin/bash
# log_analysis_optimized.sh - Optimierte Analyse von Webserver-Logs

LOG_FILE="access.log"
TEMP_DIR=$(mktemp -d)
trap 'rm -rf "$TEMP_DIR"' EXIT

# Effiziente Extraktion relevanter Daten in einem Durchlauf
echo "Extrahiere relevante Daten..."
awk '{
    # IP-Adresse (1. Feld)
    print $1 > "'"$TEMP_DIR"'/ips.txt";
    
    # HTTP-Status (9. Feld)
    print $9 > "'"$TEMP_DIR"'/status_codes.txt";
    
    # URL (7. Feld)
    print $7 > "'"$TEMP_DIR"'/urls.txt";
    
    # Speichern der Zeilen mit Fehlern (5xx Status)
    if ($9 ~ /^5[0-9][0-9]$/) {
        print $0 > "'"$TEMP_DIR"'/errors.txt";
    }
}' "$LOG_FILE"

# Parallele Verarbeitung der extrahierten Daten
echo "Analysiere Daten..."

# IP-Statistik
{
    echo "Top 10 IP-Adressen:"
    sort "$TEMP_DIR/ips.txt" | uniq -c | sort -nr | head -10
} > "ip_stats.txt" &

# Status-Code-Statistik
{
    echo "Verteilung der HTTP-Status-Codes:"
    sort "$TEMP_DIR/status_codes.txt" | uniq -c | sort -nr
} > "status_stats.txt" &

# URL-Statistik
{
    echo "Top 10 URLs:"
    sort "$TEMP_DIR/urls.txt" | uniq -c | sort -nr | head -10
} > "url_stats.txt" &

# Auf Abschluss der Hintergrundprozesse warten
wait

echo "Analyse abgeschlossen. Ergebnisse in:"
echo "- ip_stats.txt"
echo "- status_stats.txt"
echo "- url_stats.txt"
if [[ -f "$TEMP_DIR/errors.txt" ]]; then
    cp "$TEMP_DIR/errors.txt" "error_log_entries.txt"
    echo "- error_log_entries.txt"
fi

#!/bin/bash
# data_deduplication.sh - Effiziente Deduplizierung großer Datensätze

INPUT_FILE="$1"
OUTPUT_FILE="$2"
CHUNK_SIZE=100000  # Anzahl der Zeilen pro Chunk
TEMP_DIR=$(mktemp -d)
trap 'rm -rf "$TEMP_DIR"' EXIT

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

# Effizienz durch Chunking: Datei in handhabbare Teile zerlegen
echo "Teile Datei in Chunks..."
split -l "$CHUNK_SIZE" "$INPUT_FILE" "$TEMP_DIR/chunk_"

# Jedes Chunk parallel deduplizieren
echo "Dedupliziere Chunks..."
for chunk in "$TEMP_DIR"/chunk_*; do
    sort -u "$chunk" > "${chunk}.sorted" &
    
    # Begrenze die Anzahl paralleler Prozesse
    if [[ $(jobs -r | wc -l) -ge $(nproc) ]]; then
        wait -n
    fi
done

# Auf Abschluss aller Hintergrundprozesse warten
wait

# Zusammenführen der sortierten Chunks mit effizientem Merge-Sort
echo "Führe deduplizierte Chunks zusammen..."
sort -m -u "$TEMP_DIR"/chunk_*.sorted > "$OUTPUT_FILE"

# Statistik ausgeben
original_lines=$(wc -l < "$INPUT_FILE")
dedup_lines=$(wc -l < "$OUTPUT_FILE")
removed=$((original_lines - dedup_lines))
percent=$((removed * 100 / original_lines))

echo "Deduplizierung abgeschlossen:"
echo "- Ursprüngliche Zeilen: $original_lines"
echo "- Deduplizierte Zeilen: $dedup_lines"
echo "- Entfernte Duplikate: $removed ($percent%)"

#!/bin/bash
# Skript mit vielen Prozessaufrufen analysieren
PS4='+ $LINENO: ' bash -x mein_skript.sh 2> trace.log

# Anzahl der Prozessaufrufe im Log zählen
grep -c "+" trace.log

# Alternative: strace zur Analyse von Systemaufrufen
strace -c -f bash mein_skript.sh

#!/bin/bash
# Ineffizient: Externe Programme für String-Operationen
filename="example.txt"
basename=$(echo "$filename" | sed 's/\..*$//')  # Erzeugt 2 Prozesse

# Effizient: Bash-interne String-Manipulation
basename=${filename%.*}  # Kein zusätzlicher Prozess

#!/bin/bash
# Ineffizient: Wiederholter Aufruf im Loop
for file in *.txt; do
    lines=$(wc -l < "$file")
    if [[ $lines -gt 100 ]]; then
        current_date=$(date +"%Y-%m-%d")  # Unnötige Wiederholung
        echo "$file hat $lines Zeilen am $current_date"
    fi
done

# Effizient: Aufruf vor der Schleife
current_date=$(date +"%Y-%m-%d")  # Nur einmal aufgerufen
for file in *.txt; do
    lines=$(wc -l < "$file")
    if [[ $lines -gt 100 ]]; then
        echo "$file hat $lines Zeilen am $current_date"
    fi
done

#!/bin/bash
# Ineffizient: Prozessaufruf in jeder Iteration
for i in {1..1000}; do
    echo "$i" | grep -q "^[0-9]*$"
    # Weitere Verarbeitung...
done

# Effizient: Bash-interne Funktionen nutzen
for i in {1..1000}; do
    if [[ $i =~ ^[0-9]*$ ]]; then
        # Weitere Verarbeitung...
    fi
done

#!/bin/bash
# Ineffizient: Einzelverarbeitung jeder Datei
for file in *.log; do
    gzip "$file"
done

# Effizient: Batch-Verarbeitung aller Dateien
gzip *.log

#!/bin/bash
# Ineffizient: Unnötige Subshell
result=$(cat file.txt)  # Erzeugt Subshell

# Effizient: Redirection ohne Subshell
result=$(<file.txt)  # Keine Subshell

#!/bin/bash
# Ineffizient: Pipeline in Subshell
lines=$(grep "error" logfile.txt | wc -l)  # 3 Prozesse: grep, wc und Subshell

# Effizienter: Process Substitution
while read -r line; do
    (( count++ ))
done < <(grep "error" logfile.txt)  # 1 Prozess: grep, keine Subshell für die Zählung
echo "Anzahl der Fehler: $count"

#!/bin/bash
# Ineffizient: Implizite Subshell durch Pipe in Funktion
get_errors() {
    grep "error" "$1" | sort  # Erzeugt Subshell wegen Pipe
}
errors=$(get_errors "logfile.txt")

# Effizienter: Verwendung von Process Substitution
get_errors_efficient() {
    sort < <(grep "error" "$1")  # Vermeidet eine zusätzliche Subshell
}
errors=$(get_errors_efficient "logfile.txt")

#!/bin/bash
# Ineffizient: Lange Pipeline mit vielen Prozessen
cat logfile.txt | grep "error" | sort | uniq -c | sort -nr | head -5

# Effizienter: Reduzierung der Pipeline-Elemente
grep "error" logfile.txt | sort | uniq -c | sort -nr | head -5  # Ein Prozess weniger

#!/bin/bash
# Ineffizient: Viele kleine Operationen
cat names.txt | tr 'A-Z' 'a-z' | sort | uniq > unique_names.txt

# Effizienter: Verwendung von awk für kombinierte Operationen
awk '{print tolower($0)}' names.txt | sort -u > unique_names.txt

#!/bin/bash
# Ineffizient: Temporäre Dateien und zusätzliche Prozesse
grep "pattern" input.txt > temp.txt
sort temp.txt > sorted.txt
uniq sorted.txt > result.txt
rm temp.txt sorted.txt

# Effizient: Direkte Pipeline ohne temporäre Dateien
grep "pattern" input.txt | sort | uniq > result.txt

#!/bin/bash
# Ineffizient: Mehrfache find-Aufrufe
for ext in txt log csv; do
    count=$(find /path -name "*.$ext" | wc -l)
    echo "Anzahl $ext-Dateien: $count"
done

# Effizient: Einmaliger find-Aufruf
declare -A counts
while read -r file; do
    ext="${file##*.}"
    ((counts[$ext]++))
done < <(find /path -type f)

for ext in "${!counts[@]}"; do
    echo "Anzahl $ext-Dateien: ${counts[$ext]}"
done

#!/bin/bash
# Übersicht wichtiger Bash-Builtins
builtin_commands=$(help | grep -o '^\w\+' | sort)
echo "Verfügbare Bash-Builtins: $builtin_commands"

# Beispiel: test-Builtin statt externes Programm
if [ -f "$file" ]; then  # Externes [
    echo "Datei existiert"
fi

# Effizienter: Bash-internes [[
if [[ -f "$file" ]]; then  # Bash-Builtin
    echo "Datei existiert"
fi

#!/bin/bash
# Ineffizient: Externe Programme für Berechnungen
sum=$(expr $a + $b)
product=$(echo "$a * $b" | bc)

# Effizient: Bash-interne Arithmetik
sum=$((a + b))
product=$((a * b))

# Für komplexere Berechnungen: bc in einer Transaktion
complex_calculation=$(bc <<EOF
scale=2
$a * $b / ($c + $d)
EOF
)

#!/bin/bash
# log_parser_optimized.sh - Optimiertes Parsing von Log-Dateien

LOG_FILE="application.log"
SEARCH_TERM="ERROR"
OUTPUT_FILE="error_summary.txt"

# Ineffiziente Implementierung:
#
# for line in $(cat "$LOG_FILE"); do
#     if echo "$line" | grep -q "$SEARCH_TERM"; then
#         timestamp=$(echo "$line" | cut -d' ' -f1-2)
#         error_code=$(echo "$line" | grep -o "ERR-[0-9]\+" || echo "UNKNOWN")
#         echo "$timestamp: $error_code" >> "$OUTPUT_FILE"
#     fi
# done

# Optimierte Implementierung:
# 1. Vermeidet `cat`
# 2. Verwendet Bash-Regex statt grep
# 3. Verwendet Bash-Parameter-Expansion statt cut
# 4. Reduziert die Anzahl der Prozessaufrufe in der Schleife

# Initialisierung des Ausgabefiles
> "$OUTPUT_FILE"

# Regex-Muster für Fehlercode vordefinieren
error_pattern="(ERR-[0-9]+)"

while IFS= read -r line; do
    if [[ "$line" == *"$SEARCH_TERM"* ]]; then
        # Zeitstempel extrahieren (die ersten beiden Felder)
        timestamp="${line%% *}"  # Erstes Feld
        rest="${line#* }"
        timestamp="$timestamp ${rest%% *}"  # Zweites Feld hinzufügen
        
        # Fehlercode extrahieren
        if [[ "$line" =~ $error_pattern ]]; then
            error_code="${BASH_REMATCH[1]}"
        else
            error_code="UNKNOWN"
        fi
        
        echo "$timestamp: $error_code" >> "$OUTPUT_FILE"
    fi
done < "$LOG_FILE"

echo "Fehleranalyse abgeschlossen. Ergebnisse in $OUTPUT_FILE"

#!/bin/bash
# filesystem_stats_optimized.sh - Optimierte Dateisystem-Statistiken

TARGET_DIR="${1:-.}"  # Zielverzeichnis oder aktuelles Verzeichnis

if [[ ! -d "$TARGET_DIR" ]]; then
    echo "Fehler: Verzeichnis '$TARGET_DIR' existiert nicht." >&2
    exit 1
fi

echo "Analysiere Verzeichnis: $TARGET_DIR"

# Ineffiziente Implementierung:
#
# echo "Anzahl der Dateien pro Typ:"
# for ext in txt log conf bak; do
#     count=$(find "$TARGET_DIR" -type f -name "*.$ext" | wc -l)
#     echo ".$ext: $count"
# done
#
# total_size=$(du -sh "$TARGET_DIR" | cut -f1)
# echo "Gesamtgröße: $total_size"
#
# largest_file=$(find "$TARGET_DIR" -type f -exec du -h {} \; | sort -hr | head -1)
# echo "Größte Datei: $largest_file"

# Optimierte Implementierung:
# 1. Einmaliger find-Aufruf statt mehrerer
# 2. Prozessierung in Bash statt externen Programmen
# 3. Verwendung assoziativer Arrays für Zählung
# 4. Parallele Operationen für unabhängige Analysen

# Deklaration für Statistiken
declare -A file_counts
declare -A size_bytes

# Prozess 1: Dateianzahl und -größen analysieren
{
    while IFS= read -r file; do
        # Dateiendung extrahieren
        if [[ "$file" == *.* ]]; then
            ext="${file##*.}"
            ((file_counts[$ext]++))
            
            # Dateigröße für die Top-10-Liste
            size=$(stat -c "%s" "$file" 2>/dev/null || echo "0")
            size_bytes["$file"]=$size
        fi
    done < <(find "$TARGET_DIR" -type f -not -path "*/\.*" 2>/dev/null)
    
    # Ausgabe der Dateianzahl nach Typ
    echo "=== Anzahl der Dateien pro Typ ==="
    for ext in "${!file_counts[@]}"; do
        printf "%-10s: %d\n" ".$ext" "${file_counts[$ext]}"
    done
} > stats_types.txt &

# Prozess 2: Gesamtgröße berechnen (du ist schneller als manuelles Aufsummieren)
{
    echo "=== Speicherverbrauch ==="
    echo -n "Gesamtgröße: "
    du -sh "$TARGET_DIR" 2>/dev/null | cut -f1
} > stats_size.txt &

# Prozess 3: Die 10 größten Dateien finden
{
    echo "=== Die 10 größten Dateien ==="
    find "$TARGET_DIR" -type f -not -path "*/\.*" -exec du -h {} \; 2>/dev/null | sort -hr | head -10
} > stats_largest.txt &

# Auf Abschluss aller Hintergrundprozesse warten
wait

# Ergebnisse zusammenführen und anzeigen
cat stats_types.txt stats_size.txt stats_largest.txt
rm stats_types.txt stats_size.txt stats_largest.txt

echo "Analyse abgeschlossen."

#!/bin/bash
# Vergleich verschiedener Schleifentypen

echo "Performance-Vergleich von Schleifentypen:"

# 1. for-Schleife mit Bereichsexpansion (schnellste Methode für numerische Bereiche)
time {
    for i in {1..10000}; do
        : # Null-Operation
    done
}

# 2. for-Schleife mit seq (erzeugt separaten Prozess)
time {
    for i in $(seq 1 10000); do
        :
    done
}

# 3. C-ähnliche for-Schleife (gut für numerische Schleifen)
time {
    for ((i=1; i<=10000; i++)); do
        :
    done
}

# 4. while-Schleife mit arithmetischem Test
time {
    i=1
    while (( i <= 10000 )); do
        ((i++))
    done
}

# 5. until-Schleife mit arithmetischem Test
time {
    i=1
    until (( i > 10000 )); do
        ((i++))
    done
}

#!/bin/bash
# Ineffizient: Verwendung von seq (erzeugt einen separaten Prozess)
for i in $(seq 1 1000); do
    echo "$i"
done

# Effizienter: Bereichsexpansion (interne Shell-Expansion)
for i in {1..1000}; do
    echo "$i"
done

# Ebenfalls effizient: C-ähnliche for-Schleife
for ((i=1; i<=1000; i++)); do
    echo "$i"
done

#!/bin/bash
# Ineffizient: Verwendung von ls in einer Schleife
for file in $(ls *.txt); do
    # Problematisch bei Dateinamen mit Leerzeichen und Sonderzeichen
    wc -l "$file"
done

# Effizienter: Direkte Globbing-Expansion
for file in *.txt; do
    wc -l "$file"
done

#!/bin/bash
# Ineffizient: Verwendung von cat
for line in $(cat file.txt); do
    # Problematisch - teilt nach Whitespace, nicht nach Zeilen
    echo "Zeile: $line"
done

# Besser: Verwendung von while-read
while IFS= read -r line; do
    echo "Zeile: $line"
done < file.txt

#!/bin/bash
# Ineffizient: Verwendung von cat und Pipe
cat file.txt | while read -r line; do
    echo "Verarbeite: $line"
done

# Effizient: Direkte Umleitung
while IFS= read -r line; do
    echo "Verarbeite: $line"
done < file.txt

#!/bin/bash
# Ineffizient: Mehrere externe Befehle pro Zeile
while IFS= read -r line; do
    name=$(echo "$line" | cut -d, -f1)
    email=$(echo "$line" | cut -d, -f2)
    echo "Name: $name, Email: $email"
done < users.csv

# Effizient: IFS für Feldtrennung verwenden
while IFS=, read -r name email rest; do
    echo "Name: $name, Email: $email"
done < users.csv

#!/bin/bash
# Effizienter: Zeilenweises Lesen mit IFS und Batch-Verarbeitung
{
    # Array für Batch-Verarbeitung
    declare -a batch
    batch_size=1000
    count=0
    
    while IFS= read -r line; do
        batch[count++]="$line"
        
        # Batch verarbeiten, wenn voll
        if ((count == batch_size)); then
            # Batch-Verarbeitung hier
            for item in "${batch[@]}"; do
                # Verarbeitung jedes Elements
                : # Platzhalter für tatsächliche Verarbeitung
            done
            
            # Batch zurücksetzen
            batch=()
            count=0
        fi
    done < largefile.txt
    
    # Restlichen Batch verarbeiten
    for item in "${batch[@]}"; do
        # Verarbeitung jedes Elements
        : # Platzhalter für tatsächliche Verarbeitung
    done
}

#!/bin/bash
# Ineffizient: Durchlaufen des gesamten Arrays
array=(1 2 3 4 5 ... 10000)
found=0

for item in "${array[@]}"; do
    if [[ "$item" -eq 42 ]]; then
        found=1
    fi
    # Weitere teure Operationen...
done

if [[ "$found" -eq 1 ]]; then
    echo "Element gefunden"
fi

# Effizient: Frühes Abbrechen
for item in "${array[@]}"; do
    if [[ "$item" -eq 42 ]]; then
        echo "Element gefunden"
        break  # Schleife sofort verlassen
    fi
    # Weitere teure Operationen...
done

#!/bin/bash
# Ineffizient: Häufigster Fall wird zuletzt geprüft
process_request() {
    if [[ "$request_type" == "delete" ]]; then
        # Selten (5% der Fälle)
        delete_resource
    elif [[ "$request_type" == "update" ]]; then
        # Gelegentlich (15% der Fälle)
        update_resource
    elif [[ "$request_type" == "get" ]]; then
        # Sehr häufig (80% der Fälle)
        get_resource
    fi
}

# Effizient: Häufigste Fälle zuerst prüfen
process_request_optimized() {
    if [[ "$request_type" == "get" ]]; then
        # Sehr häufig (80% der Fälle)
        get_resource
    elif [[ "$request_type" == "update" ]]; then
        # Gelegentlich (15% der Fälle)
        update_resource
    elif [[ "$request_type" == "delete" ]]; then
        # Selten (5% der Fälle)
        delete_resource
    fi
}

#!/bin/bash
# Ineffizient: Mehrere if-Anweisungen
check_status() {
    if [[ "$status" == "running" ]]; then
        handle_running
    elif [[ "$status" == "stopped" ]]; then
        handle_stopped
    elif [[ "$status" == "paused" ]]; then
        handle_paused
    elif [[ "$status" == "unknown" ]]; then
        handle_unknown
    fi
}

# Effizient: case-Anweisung
check_status_optimized() {
    case "$status" in
        running)
            handle_running
            ;;
        stopped)
            handle_stopped
            ;;
        paused)
            handle_paused
            ;;
        unknown|*)
            handle_unknown
            ;;
    esac
}

#!/bin/bash
# Ineffizient: Alle Bedingungen werden immer geprüft
if [[ -f "$file" ]]; then
    if [[ -r "$file" ]]; then
        if [[ $(stat -c %s "$file") -gt 0 ]]; then
            process_file "$file"
        fi
    fi
fi

# Effizient: Kurzschlussauswertung
if [[ -f "$file" && -r "$file" && $(stat -c %s "$file") -gt 0 ]]; then
    process_file "$file"
fi

# Noch effizienter: Teure Operationen zuletzt
if [[ -f "$file" && -r "$file" ]] && [[ $(stat -c %s "$file") -gt 0 ]]; then
    process_file "$file"
fi

#!/bin/bash
# Ineffizient: Teure Berechnung wird immer durchgeführt
if [[ $(expensive_calculation) -eq $expected_value ]]; then
    # Nur relevant, wenn Bedingung wahr ist
fi

# Effizient: Berechnung in Variable speichern, wenn mehrfach verwendet
result=$(expensive_calculation)
if [[ $result -eq $expected_value ]]; then
    # Verwende $result mehrfach
fi

# Alternative: Berechnung nur bei Bedarf durchführen
if [[ condition_that_is_often_false ]]; then
    result=$(expensive_calculation)
    if [[ $result -eq $expected_value ]]; then
        # Weitere Verarbeitung
    fi
fi

#!/bin/bash
# Ineffizient: Schleife für einfache Textsuche
found=0
while IFS= read -r line; do
    if [[ "$line" == *"ERROR"* ]]; then
        found=1
        break
    fi
done < logfile.txt

# Effizient: grep für einfache Textsuche verwenden
if grep -q "ERROR" logfile.txt; then
    found=1
fi

#!/bin/bash
# Komplexe Filterung effizient implementieren
if grep -q "ERROR" logfile.txt; then
    # Nur wenn Fehler vorhanden sind, weitere Analysen durchführen
    error_lines=$(grep "ERROR" logfile.txt)
    
    # Weitere Verarbeitung der Fehlerzeilen
    echo "$error_lines" | while IFS= read -r line; do
        # Detaillierte Analyse jeder Fehlerzeile
        error_code=$(echo "$line" | grep -o "ERR-[0-9]\+")
        echo "Gefundener Fehlercode: $error_code"
    done
fi

#!/bin/bash
# Ineffizient: Bedingungsprüfungen in jeder Iteration
for file in *.log; do
    if [[ -f "$file" && ! -L "$file" && -r "$file" ]]; then
        if grep -q "ERROR" "$file"; then
            # Verarbeitung...
        fi
    fi
done

# Effizienter: Vorabfilterung der Dateien
for file in *.log; do
    [[ -f "$file" && ! -L "$file" && -r "$file" ]] || continue
    
    # Nur Dateien verarbeiten, die die Bedingungen erfüllen
    if grep -q "ERROR" "$file"; then
        # Verarbeitung...
    fi
done

# Alternative: find mit exec für parallele Verarbeitung
find . -name "*.log" -type f -readable -exec grep -l "ERROR" {} \; | 
while IFS= read -r file; do
    # Verarbeitung...
done

#!/bin/bash
# Ineffizient: Zeilenweise Verarbeitung
while IFS= read -r line; do
    lines+=("$line")
done < file.txt

# Effizient: Direkt in Array einlesen (Bash 4+)
mapfile -t lines < file.txt

# Noch effizienter für große Dateien: Einlesen in Blöcken
mapfile -n 1000 -t lines < file.txt  # Erste 1000 Zeilen einlesen

#!/bin/bash
# Ineffizient: Iteration zum Transformieren jeder Zeile
transformed_lines=()
while IFS= read -r line; do
    transformed_lines+=("$(echo "$line" | tr '[:lower:]' '[:upper:]')")
done < file.txt

# Effizient: Direkte Transformation ohne Schleife
tr '[:lower:]' '[:upper:]' < file.txt > transformed.txt

#!/bin/bash
# Sequenzielle Verarbeitung
for file in *.log; do
    process_file "$file"  # Zeitaufwändige Verarbeitung
done

# Parallele Verarbeitung mit Kontrolle der gleichzeitigen Prozesse
max_jobs=4  # Maximale Anzahl gleichzeitiger Prozesse
current_jobs=0

for file in *.log; do
    # Warten, wenn maximale Anzahl an Jobs erreicht
    while ((current_jobs >= max_jobs)); do
        # Warten auf Beendigung eines Jobs
        wait -n
        ((current_jobs--))
    done
    
    # Starten eines neuen Hintergrundprozesses
    process_file "$file" &
    ((current_jobs++))
done

# Warten auf Abschluss aller verbleibenden Jobs
wait

#!/bin/bash
# optimized_text_processor.sh - Effiziente Verarbeitung großer Textdateien

INPUT_FILE="$1"
OUTPUT_FILE="$2"
SEARCH_PATTERN="$3"

if [[ $# -lt 3 ]]; then
    echo "Verwendung: $0 <eingabedatei> <ausgabedatei> <suchmuster>" >&2
    exit 1
fi

if [[ ! -f "$INPUT_FILE" || ! -r "$INPUT_FILE" ]]; then
    echo "Fehler: Eingabedatei nicht gefunden oder nicht lesbar." >&2
    exit 1
fi

# Zähle die Zeilen, die dem Suchmuster entsprechen
matching_lines=$(grep -c "$SEARCH_PATTERN" "$INPUT_FILE")

# Frühzeitiger Abbruch, wenn keine Übereinstimmungen
if [[ $matching_lines -eq 0 ]]; then
    echo "Keine Übereinstimmungen gefunden. Erstelle leere Ausgabedatei."
    > "$OUTPUT_FILE"
    exit 0
fi

echo "Gefundene Übereinstimmungen: $matching_lines"

# Effiziente Batch-Verarbeitung der Zeilen
{
    # Kopfzeile in Ausgabedatei schreiben
    echo "# Verarbeitete Zeilen mit Muster: $SEARCH_PATTERN" > "$OUTPUT_FILE"
    echo "# Gesamtzahl der Übereinstimmungen: $matching_lines" >> "$OUTPUT_FILE"
    echo "# Zeitstempel: $(date)" >> "$OUTPUT_FILE"
    echo "# Format: Zeilennummer|Verarbeitete Zeile" >> "$OUTPUT_FILE"
    echo "-------------------------------------------" >> "$OUTPUT_FILE"
    
    # Optimierte Verarbeitung der übereinstimmenden Zeilen
    grep -n "$SEARCH_PATTERN" "$INPUT_FILE" | 
    while IFS=: read -r line_num line_content; do
        # Effiziente String-Manipulation mit Shell-internen Funktionen
        # 1. Entferne führende/nachfolgende Leerzeichen
        trimmed="${line_content#"${line_content%%[![:space:]]*}"}"
        trimmed="${trimmed%"${trimmed##*[![:space:]]}"}"
        
        # 2. Konvertiere zu Großbuchstaben (Bash 4+)
        upper="${trimmed^^}"
        
        # 3. Schreibe das Ergebnis in die Ausgabedatei
        echo "$line_num|$upper" >> "$OUTPUT_FILE"
    done
}

echo "Verarbeitung abgeschlossen. Ergebnisse in $OUTPUT_FILE"

#!/bin/bash
# optimized_file_finder.sh - Effiziente Suche und Filterung von Dateien

TARGET_DIR="${1:-.}"
MIN_SIZE="${2:-0}"  # Minimale Größe in Bytes
PATTERN="${3:-.*}"  # Regex-Muster für Dateinamen
MAX_DEPTH="${4:-999}"  # Maximale Suchtiefe

if [[ ! -d "$TARGET_DIR" ]]; then
    echo "Fehler: Verzeichnis '$TARGET_DIR' existiert nicht." >&2
    exit 1
fi

echo "Suche Dateien in: $TARGET_DIR"
echo "Minimale Größe: $MIN_SIZE Bytes"
echo "Namensmuster: $PATTERN"
echo "Maximale Suchtiefe: $MAX_DEPTH"

# Array für gefundene Dateien
declare -a found_files

# Optimierte Tiefenbegrenzung mit find
if [[ $MAX_DEPTH -eq 999 ]]; then
    # Keine Tiefenbegrenzung angegeben, verwende Standard
    depth_option=""
else
    depth_option="-maxdepth $MAX_DEPTH"
fi

# Effiziente Verwendung von find mit vorgefilterten Ergebnissen
echo "Suche nach Dateien..."
start_time=$(date +%s.%N)

# Einmaliger find-Aufruf mit allen Filtern
mapfile -t found_files < <(find "$TARGET_DIR" $depth_option -type f -size +"$MIN_SIZE"c -regextype posix-extended -regex ".*$PATTERN.*" -not -path "*/\.*")

end_time=$(date +%s.%N)
elapsed=$(echo "$end_time - $start_time" | bc)

# Effiziente Verarbeitung der Ergebnisse
total_files=${#found_files[@]}
total_size=0

if [[ $total_files -gt 0 ]]; then
    echo -e "\nGefundene Dateien ($total_files):"
    
    # Effiziente Schleife durch die gefundenen Dateien
    for ((i=0; i<$total_files; i++)); do
        file="${found_files[$i]}"
        
        # Größe direkt mit stat abrufen (effizienter als du)
        size=$(stat -c %s "$file")
        size_human=$(numfmt --to=iec-i --suffix=B --format="%.2f" "$size")
        
        # Akkumulierte Größe berechnen
        ((total_size += size))
        
        # Ausgabe mit Formatierung
        printf "%4d: %s (%s)\n" $((i+1)) "$file" "$size_human"
        
        # Bei zu vielen Dateien nach jeweils 20 eine Pause für Benutzerinteraktion
        if ((i+1 >= 20 && (i+1) % 20 == 0 && i+1 < total_files)); then
            read -p "-- Drücken Sie Enter für weitere Ergebnisse (${i+1}/$total_files) --" -s
            echo
        fi
    done
    
    # Gesamtgröße formatieren
    total_size_human=$(numfmt --to=iec-i --suffix=B --format="%.2f" "$total_size")
    
    echo -e "\nZusammenfassung:"
    echo "Gefundene Dateien: $total_files"
    echo "Gesamtgröße: $total_size_human"
    echo "Suchzeit: $elapsed Sekunden"
else
    echo "Keine Dateien gefunden, die den Kriterien entsprechen."
fi

#!/bin/bash
# Ineffizient: Wiederholter Aufruf desselben Befehls
for user in $(cat users.txt); do
    home_dir=$(grep "^$user:" /etc/passwd | cut -d: -f6)
    echo "Heimatverzeichnis von $user ist $home_dir"
done

# Effizient: Caching der Passwortdaten
passwd_data=$(cat /etc/passwd)
for user in $(cat users.txt); do
    home_dir=$(echo "$passwd_data" | grep "^$user:" | cut -d: -f6)
    echo "Heimatverzeichnis von $user ist $home_dir"
done

#!/bin/bash
# Deklarieren eines assoziativen Arrays für den Cache
declare -A factorial_cache

# Rekursive Fakultätsfunktion mit Memoization
factorial() {
    local n=$1
    
    # Basisfall
    if [[ $n -le 1 ]]; then
        echo 1
        return
    fi
    
    # Prüfen, ob das Ergebnis bereits im Cache ist
    if [[ -n "${factorial_cache[$n]}" ]]; then
        echo "${factorial_cache[$n]}"
        return
    fi
    
    # Berechnung durchführen
    local prev=$(factorial $(($n - 1)))
    local result=$(($n * $prev))
    
    # Ergebnis im Cache speichern
    factorial_cache[$n]=$result
    
    echo $result
}

# Beispielverwendung
time echo "Fakultät von 20: $(factorial 20)"
time echo "Fakultät von 20 (cached): $(factorial 20)"

#!/bin/bash
# Funktion zum Speichern von Daten im Cache
cache_store() {
    local key=$1
    local value=$2
    local cache_dir=${CACHE_DIR:-"$HOME/.cache/myscript"}
    
    # Cache-Verzeichnis erstellen, falls nicht vorhanden
    mkdir -p "$cache_dir"
    
    # Schlüssel in einen sicheren Dateinamen umwandeln
    local safe_key=$(echo "$key" | md5sum | cut -d' ' -f1)
    
    # Wert in die Cache-Datei schreiben
    echo "$value" > "$cache_dir/$safe_key"
    
    # Metadaten speichern (Original-Schlüssel und Zeitstempel)
    echo "key: $key" > "$cache_dir/$safe_key.meta"
    echo "timestamp: $(date +%s)" >> "$cache_dir/$safe_key.meta"
}

# Funktion zum Abrufen von Daten aus dem Cache
cache_retrieve() {
    local key=$1
    local max_age=${2:-86400}  # Standardmäßig 24 Stunden (in Sekunden)
    local cache_dir=${CACHE_DIR:-"$HOME/.cache/myscript"}
    
    # Schlüssel in einen sicheren Dateinamen umwandeln
    local safe_key=$(echo "$key" | md5sum | cut -d' ' -f1)
    local cache_file="$cache_dir/$safe_key"
    local meta_file="$cache_dir/$safe_key.meta"
    
    # Prüfen, ob Cache-Eintrag existiert
    if [[ ! -f "$cache_file" || ! -f "$meta_file" ]]; then
        return 1
    fi
    
    # Zeitstempel aus Metadaten lesen
    local timestamp=$(grep "^timestamp: " "$meta_file" | cut -d' ' -f2)
    local current_time=$(date +%s)
    local age=$((current_time - timestamp))
    
    # Prüfen, ob der Cache-Eintrag noch gültig ist
    if [[ $age -gt $max_age ]]; then
        return 1
    fi
    
    # Cache-Eintrag zurückgeben
    cat "$cache_file"
    return 0
}

# Funktion zum Löschen eines Cache-Eintrags
cache_invalidate() {
    local key=$1
    local cache_dir=${CACHE_DIR:-"$HOME/.cache/myscript"}
    
    # Schlüssel in einen sicheren Dateinamen umwandeln
    local safe_key=$(echo "$key" | md5sum | cut -d' ' -f1)
    
    # Cache-Dateien löschen
    rm -f "$cache_dir/$safe_key" "$cache_dir/$safe_key.meta"
}

# Funktion mit Caching
get_weather() {
    local city=$1
    local cache_key="weather_$city"
    
    # Versuchen, Daten aus dem Cache zu holen (max. 1 Stunde alt)
    if weather_data=$(cache_retrieve "$cache_key" 3600); then
        echo "$weather_data [cached]"
        return
    fi
    
    # Wenn nicht im Cache, Daten abrufen (simuliert)
    echo "Rufe Wetterdaten für $city ab..." >&2
    sleep 2  # Simuliere eine langsame API-Anfrage
    weather_data="Sonnig, 25°C in $city"
    
    # Daten im Cache speichern
    cache_store "$cache_key" "$weather_data"
    
    echo "$weather_data [fresh]"
}

# Beispielverwendung
get_weather "Berlin"  # Erste Anfrage: nicht im Cache
get_weather "Berlin"  # Zweite Anfrage: aus dem Cache
get_weather "München" # Neue Stadt: nicht im Cache