10 Arbeit mit Dateien und Verzeichnissen

# Pfade als Variablen definieren
BASE_DIR="/var/log"
BACKUP_DIR="/mnt/backup/logs"
LOG_FILE="$BASE_DIR/system.log"

# Absoluter Pfad - beginnt mit /
cd /var/log

# Relativer Pfad - relativ zum aktuellen Verzeichnis
cd ../config

# Aktuelles Verzeichnis ermitteln
CURRENT_DIR=$(pwd)
# Alternative Methode
CURRENT_DIR="$PWD"

# Das Verzeichnis, in dem das Skript liegt (nicht das Arbeitsverzeichnis)
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"

# Prüfen, ob eine Datei existiert
if [ -f "$FILENAME" ]; then
    echo "Die Datei $FILENAME existiert."
fi

# Prüfen, ob ein Verzeichnis existiert
if [ -d "$DIRNAME" ]; then
    echo "Das Verzeichnis $DIRNAME existiert."
fi

# Prüfen, ob eine Datei lesbar ist
if [ -r "$FILENAME" ]; then
    echo "Die Datei $FILENAME ist lesbar."
fi

# Prüfen, ob eine Datei schreibbar ist
if [ -w "$FILENAME" ]; then
    echo "Die Datei $FILENAME ist schreibbar."
fi

# Prüfen, ob eine Datei ausführbar ist
if [ -x "$FILENAME" ]; then
    echo "Die Datei $FILENAME ist ausführbar."
fi

# Prüfen, ob eine Datei nicht leer ist
if [ -s "$FILENAME" ]; then
    echo "Die Datei $FILENAME ist nicht leer."
fi

# Ein Verzeichnis erstellen, falls es nicht existiert
if [ ! -d "$LOG_DIR" ]; then
    mkdir -p "$LOG_DIR"
    echo "Verzeichnis $LOG_DIR wurde erstellt."
fi

# Mehrere Verzeichnisebenen auf einmal erstellen
mkdir -p /pfad/zu/verschachteltem/verzeichnis

# Eine leere Datei erstellen (oder Zeitstempel aktualisieren, wenn sie existiert)
touch "$LOG_FILE"

# Eine Datei mit Inhalt erstellen
cat > "$CONFIG_FILE" << EOF
# Konfigurationseinstellungen
DEBUG=true
LOG_LEVEL=info
MAX_CONNECTIONS=100
EOF

# Dateien kopieren mit Erhaltung der Attribute
cp -p "$SOURCE_FILE" "$DEST_FILE"

# Verzeichnisse rekursiv kopieren
cp -r "$SOURCE_DIR" "$DEST_DIR"

# Datei verschieben/umbenennen
mv "$OLD_NAME" "$NEW_NAME"

# Datei sicher löschen (mit Nachfrage)
rm -i "$FILENAME"

# Verzeichnis rekursiv löschen (Vorsicht!)
rm -rf "$DIRNAME"

# GEFÄHRLICH - Variablen könnten leer sein!
rm -rf $DIR/  # Wenn $DIR leer ist, wird / gelöscht!

# SICHER - Prüfung, ob die Variable nicht leer ist
if [ -n "$DIR" ] && [ -d "$DIR" ]; then
    rm -rf "$DIR"
fi

# SICHER - Durch Anführungszeichen und Vorprüfung
[ -d "$DIR" ] && rm -rf "$DIR"

FULLPATH="/var/log/syslog.1.gz"

# Dateiname ohne Pfad extrahieren
FILENAME=$(basename "$FULLPATH")  # Ergebnis: syslog.1.gz

# Verzeichnispfad extrahieren
DIRECTORY=$(dirname "$FULLPATH")  # Ergebnis: /var/log

# Dateiendung entfernen
BASENAME="${FILENAME%.*}"         # Ergebnis: syslog.1

# Alles nach dem ersten Punkt entfernen
NAME="${FILENAME%%.*}"            # Ergebnis: syslog

# Endung extrahieren
EXTENSION="${FILENAME##*.}"       # Ergebnis: gz

# Temporäre Datei erstellen
TEMP_FILE=$(mktemp)
echo "Temporäre Daten" > "$TEMP_FILE"
# Mit der Datei arbeiten...
rm "$TEMP_FILE"  # Aufräumen nicht vergessen

# Temporäres Verzeichnis erstellen
TEMP_DIR=$(mktemp -d)
# Mit dem Verzeichnis arbeiten...
rm -rf "$TEMP_DIR"  # Aufräumen

# Alle Logdateien in /var/log finden, die älter als 7 Tage sind
find /var/log -name "*.log" -type f -mtime +7

# Alle leeren Dateien im Home-Verzeichnis finden und löschen
find ~ -type f -empty -delete

# Alle ausführbaren Dateien in /usr/bin finden
find /usr/bin -type f -executable

# Nach Dateigröße suchen (größer als 100MB)
find /home -type f -size +100M

# Dateien nach Inhaltstyp suchen
find /var/www -type f -name "*.php" -exec grep -l "mysql_connect" {} \;

# Alle Textdateien in UTF-8 konvertieren
find . -name "*.txt" -exec iconv -f ISO-8859-1 -t UTF-8 {} -o {}.utf8 \;

# Berechtigungen für alle Skripte in einem Verzeichnis ändern
find ./scripts -name "*.sh" -exec chmod 755 {} \;

# Alle gefundenen Dateien komprimieren
find ./logs -name "*.log" -mtime +30 -exec gzip {} \;

# Viele Dateien auf einmal löschen (effizienter)
find /tmp -name "temp*" -mtime +7 -exec rm {} \+

# Zeilen aus einer Datei lesen und verarbeiten
while IFS= read -r line; do
    echo "Verarbeite: $line"
    # Weitere Verarbeitung...
done < "$INPUT_FILE"

# Bestimmte Zeilen auswählen
sed -n '10,20p' "$FILE"  # Zeilen 10-20 ausgeben

# Text in einer Datei ersetzen
sed -i 's/alter_text/neuer_text/g' "$FILE"

# Zeilen hinzufügen
echo "Neue Zeile" >> "$FILE"

# Freien Speicherplatz prüfen
SPACE_AVAILABLE=$(df -k /var/log | awk 'NR==2 {print $4}')
if [ "$SPACE_AVAILABLE" -lt 1048576 ]; then  # Weniger als 1GB
    echo "Warnung: Wenig Speicherplatz verfügbar!"
fi

# Dateigröße ermitteln
FILE_SIZE=$(stat -c %s "$FILENAME")
echo "Die Datei $FILENAME ist $FILE_SIZE Bytes groß."

# Zeitstempel der letzten Änderung abrufen
LAST_MODIFIED=$(stat -c %Y "$FILENAME")
echo "Die Datei wurde zuletzt am $(date -d @$LAST_MODIFIED) geändert."

#!/bin/bash
# backup.sh - Ein einfaches Backup-Skript

# Konfiguration
SOURCE_DIR="/home/user/documents"
BACKUP_DIR="/mnt/backup"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="$BACKUP_DIR/backup_$TIMESTAMP.tar.gz"

# Prüfen, ob Quellverzeichnis existiert
if [ ! -d "$SOURCE_DIR" ]; then
    echo "Fehler: Quellverzeichnis $SOURCE_DIR existiert nicht!"
    exit 1
fi

# Prüfen, ob Backup-Verzeichnis existiert, sonst erstellen
if [ ! -d "$BACKUP_DIR" ]; then
    mkdir -p "$BACKUP_DIR"
    if [ $? -ne 0 ]; then
        echo "Fehler: Konnte Backup-Verzeichnis nicht erstellen!"
        exit 2
    fi
fi

# Freien Speicherplatz prüfen
SPACE_NEEDED=$(du -s "$SOURCE_DIR" | awk '{print $1}')
SPACE_AVAILABLE=$(df -k "$BACKUP_DIR" | awk 'NR==2 {print $4}')

if [ "$SPACE_AVAILABLE" -lt "$SPACE_NEEDED" ]; then
    echo "Fehler: Nicht genug Speicherplatz für Backup!"
    exit 3
fi

# Backup erstellen
echo "Erstelle Backup von $SOURCE_DIR nach $BACKUP_FILE..."
tar -czf "$BACKUP_FILE" -C "$(dirname "$SOURCE_DIR")" "$(basename "$SOURCE_DIR")"

if [ $? -eq 0 ]; then
    echo "Backup erfolgreich erstellt: $BACKUP_FILE"
    # Alte Backups aufräumen (älter als 30 Tage)
    find "$BACKUP_DIR" -name "backup_*.tar.gz" -type f -mtime +30 -delete
    echo "Alte Backups wurden aufgeräumt."
else
    echo "Fehler beim Erstellen des Backups!"
    exit 4
fi

exit 0

# Alle Dateien im aktuellen Verzeichnis auflisten
ls *

# Alle Textdateien auflisten
ls *.txt

# Alle Dateien, die mit 'log' beginnen
ls log*

# Alle Dateien mit 'config' irgendwo im Namen
ls *config*

# Alle Dateien, die mit 'data' beginnen und mit '.csv' enden
ls data*.csv

# Dateien mit einem Zeichen nach 'file' auflisten
ls file?.txt      # Passt auf file1.txt, fileA.txt, etc.

# Dateien mit drei Zeichen nach 'log' auflisten
ls log???.txt     # Passt auf log001.txt, logABC.txt, etc.

# Dateien mit genau einem Zeichen vor der Erweiterung
ls file.?         # Passt auf file.a, file.1, etc.

# Dateien, deren Namen mit einer Ziffer von 1 bis 5 enden
ls file[12345]

# Dateien, deren Namen mit einem Buchstaben von a bis e enden
ls file[a-e]

# Dateien, deren Namen mit einem Kleinbuchstaben oder einer Ziffer enden
ls file[a-z0-9]

# Dateien, deren Namen mit allem außer x, y oder z enden
ls file[^xyz]
ls file[!xyz]     # Alternative Syntax

# Erweiterte Globbing-Muster aktivieren
shopt -s extglob

# Aktivieren des erweiterten Globbings
shopt -s extglob

# Alle Dateien außer .txt-Dateien
ls !(*.txt)

# Dateien, die entweder .jpg oder .png sind
ls *@(.jpg|.png)

# Dateien, die mit log beginnen und optional mit .txt oder .log enden
ls log*?(.txt|.log)

# Dateien, die mit einer oder mehr Ziffern beginnen
ls +([0-9])*

#!/bin/bash
# Beispiel: Alle .txt-Dateien in .md-Dateien konvertieren

# Prüfen, ob .txt-Dateien existieren
txt_files=(*.txt)
if [ ${#txt_files[@]} -eq 0 ] || [ ! -e "${txt_files[0]}" ]; then
    echo "Keine .txt-Dateien gefunden!"
    exit 1
fi

# Alle .txt-Dateien durchlaufen und in .md umwandeln
for file in *.txt; do
    # Neuen Dateinamen erstellen (Endung ändern)
    new_file="${file%.txt}.md"
    
    # Datei konvertieren (hier nur einfaches Kopieren)
    cp "$file" "$new_file"
    echo "Konvertiert: $file -> $new_file"
done

echo "Konvertierung abgeschlossen."

# Alle .log-Dateien in allen Unterverzeichnissen nach einem Fehler durchsuchen
shopt -s globstar
grep -l "ERROR" **/*.log

# Alle .txt-Dateien außer README.txt löschen
rm -f !(README).txt

# Alle Dateien außer .git-Verzeichnis in ein Archiv packen
tar -czf backup.tar.gz !(*.git|*.git/*|backup.tar.gz)

# Mehrere Dateien auf einmal erstellen
touch file{1..5}.txt  # Erstellt file1.txt bis file5.txt

# Mit führenden Nullen
touch image{01..10}.jpg  # Erstellt image01.jpg bis image10.jpg

# Mit Schrittweite
echo {10..20..2}  # Ausgabe: 10 12 14 16 18 20

# Kombinationen von Texten
echo file{A,B,C}.txt  # Ausgabe: fileA.txt fileB.txt fileC.txt

# Verschachtelte Braces
echo {a,b{1,2},c}.txt  # Ausgabe: a.txt b1.txt b2.txt c.txt

# Alle .txt und .md Dateien kopieren
cp ./*.{txt,md} /backup/

# Mehrere Verzeichnisse auf einmal erstellen
mkdir -p ./logs/{app,system,error}/{2023,2024}/{01..12}

#!/bin/bash
# pack_project.sh - Projektdateien archivieren mit Ausschlüssen

PROJECT_DIR="$1"
OUTPUT_FILE="${2:-project_backup.tar.gz}"

if [ -z "$PROJECT_DIR" ] || [ ! -d "$PROJECT_DIR" ]; then
    echo "Fehler: Bitte gültiges Projektverzeichnis angeben."
    echo "Verwendung: $0 <projektverzeichnis> [ausgabedatei]"
    exit 1
fi

# In das Projektverzeichnis wechseln
cd "$PROJECT_DIR" || exit 2

# Erweiterte Globbing-Muster aktivieren
shopt -s extglob

# Dateien und Verzeichnisse, die ausgeschlossen werden sollen
EXCLUDE_PATTERN="@(*/.git|*/node_modules|*/build|*/dist|*/.DS_Store|*/*.log|*/*.tmp)"

# Temporäre Datei für die Liste der einzuschließenden Dateien
INCLUDE_LIST=$(mktemp)

# Alle Dateien außer den ausgeschlossenen finden
find . -type f -not -path "$EXCLUDE_PATTERN" > "$INCLUDE_LIST"

# Archiv erstellen
echo "Erstelle Archiv $OUTPUT_FILE..."
tar -czf "../$OUTPUT_FILE" -T "$INCLUDE_LIST"

# Aufräumen
rm "$INCLUDE_LIST"

echo "Fertig! Archiv wurde erstellt: $(realpath "../$OUTPUT_FILE")"
echo "Anzahl der archivierten Dateien: $(tar -tf "../$OUTPUT_FILE" | wc -l)"

exit 0

# Grundlegende Syntax
find [Startverzeichnis] [Ausdrücke]

# Alle .log-Dateien im gesamten /var/log-Verzeichnis finden
find /var/log -type f -name "*.log"

# Alle leeren Verzeichnisse finden
find /home/user -type d -empty

# Alle Dateien über 100MB finden
find /var -type f -size +100M

# Alle Dateien, die in den letzten 7 Tagen geändert wurden
find /home/user/documents -type f -mtime -7

# Alle .php-Dateien rekursiv nach einem Muster durchsuchen
find /var/www -name "*.php" -exec grep -l "mysql_connect" {} \;

# Alle .tmp-Dateien rekursiv löschen
find /tmp -name "*.tmp" -exec rm -f {} \;

# Alle Verzeichnisse mit bestimmten Berechtigungen finden und ändern
find /opt -type d -perm 777 -exec chmod 755 {} \;

# Komprimieren aller Textdateien, die älter als 30 Tage sind
find /var/log -name "*.txt" -type f -mtime +30 -exec gzip {} \;

# Ineffizient: Ein Befehlsaufruf pro Datei
find /var/log -name "*.old" -exec rm {} \;

# Effizienter: Mehrere Dateien pro Befehlsaufruf
find /var/log -name "*.old" -exec rm {} \+

# Parallelisierte Komprimierung von Logdateien (4 Prozesse gleichzeitig)
find /var/log -name "*.log" -type f -print0 | xargs -0 -P 4 -I {} gzip {}

# Nur bis zur Tiefe 2 suchen (aktuelles Verzeichnis = Tiefe 0)
find /home/user -maxdepth 2 -name "*.conf"

# Erst ab Tiefe 2 beginnen
find /var -mindepth 2 -name "*.pid"

# Rekursives Kopieren eines Verzeichnisses mit allen Unterverzeichnissen
cp -r /quellverzeichnis /zielverzeichnis

# Rekursives Kopieren mit Erhaltung von Attributen
cp -a /quellverzeichnis /zielverzeichnis

# Rekursives Löschen eines Verzeichnisses und aller Inhalte
rm -r /zu/löschendes/verzeichnis

# Rekursives Löschen ohne Nachfrage (Vorsicht!)
rm -rf /zu/löschendes/verzeichnis

#!/bin/bash
# Sicheres rekursives Löschen

TARGET_DIR="$1"

# Sicherheitsprüfungen
if [ -z "$TARGET_DIR" ]; then
    echo "Fehler: Kein Zielverzeichnis angegeben." >&2
    exit 1
fi

if [ "$TARGET_DIR" = "/" ] || [ "$TARGET_DIR" = "/home" ] || [ "$TARGET_DIR" = "/etc" ]; then
    echo "Fehler: Löschen kritischer Systemverzeichnisse nicht erlaubt." >&2
    exit 2
fi

# Bestätigung vom Benutzer einholen
echo "Soll das Verzeichnis '$TARGET_DIR' mit ALLEN Inhalten gelöscht werden? (j/N)"
read -r response
if [[ ! "$response" =~ ^[jJ] ]]; then
    echo "Abgebrochen."
    exit 0
fi

# Rekursives Löschen mit Ausgabe der gelöschten Dateien
find "$TARGET_DIR" -type f -print -delete
find "$TARGET_DIR" -type d -empty -print -delete

echo "Löschvorgang abgeschlossen."

# Rekursives Ändern von Berechtigungen
chmod -R 755 /verzeichnis

# Berechtigungen nur für Verzeichnisse rekursiv ändern (mit find)
find /verzeichnis -type d -exec chmod 755 {} \;

# Berechtigungen nur für Dateien rekursiv ändern (mit find)
find /verzeichnis -type f -exec chmod 644 {} \;

# Rekursives Ändern von Besitzer und Gruppe
chown -R benutzer:gruppe /verzeichnis

# Nur den Besitzer rekursiv ändern
chown -R benutzer /verzeichnis

# Nur die Gruppe rekursiv ändern
chgrp -R gruppe /verzeichnis

# Rekursive Suche mit grep
grep -r "suchtext" /verzeichnis

# Rekursives Auflisten von Dateien mit ls
ls -R /verzeichnis

# Rekursives Finden und Ersetzen mit sed (vorsichtig!)
find /verzeichnis -type f -name "*.txt" -exec sed -i 's/alt/neu/g' {} \;

# globstar aktivieren
shopt -s globstar

# Alle .sh-Dateien in allen Unterverzeichnissen auflisten
ls -la **/*.sh

# Alle .txt-Dateien rekursiv nach einem Muster durchsuchen
grep "muster" **/*.txt

# Alle .bak-Dateien rekursiv löschen
rm **/*.bak

# globstar deaktivieren
shopt -u globstar

# Rekursive Verzeichnisgrößen anzeigen (human-readable)
du -h /verzeichnis

# Nur Gesamtgröße anzeigen
du -sh /verzeichnis

# Die 5 größten Unterverzeichnisse finden
du -h /verzeichnis | sort -rh | head -5

# Rekursiv alle Ereignisse im Verzeichnis überwachen
inotifywait -m -r /verzeichnis

# Nur bestimmte Ereignisse überwachen (z.B. Änderungen)
inotifywait -m -r -e modify,create,delete /verzeichnis

# Skript zur Protokollierung von Dateisystemänderungen
#!/bin/bash
LOG_FILE="/var/log/fs_changes.log"

inotifywait -m -r -e modify,create,delete,move --format '%:e %w%f' /zu/überwachendes/verzeichnis |
while read -r line; do
    echo "$(date '+%Y-%m-%d %H:%M:%S') $line" >> "$LOG_FILE"
done

# Grundlegende rekursive Synchronisation
rsync -av /quellverzeichnis/ /zielverzeichnis/

# Synchronisation mit Löschung nicht mehr vorhandener Dateien
rsync -av --delete /quellverzeichnis/ /zielverzeichnis/

# Trockenlauf (zeigt, was synchronisiert würde, ohne Änderungen vorzunehmen)
rsync -av --dry-run /quellverzeichnis/ /zielverzeichnis/

# Inkrementelles Backup mit Hardlinks für unverändertes
rsync -av --link-dest=/pfad/zum/letzten/backup /quellverzeichnis/ /backup/$(date +%Y%m%d)/

# Nur bestimmte Dateitypen einbeziehen
find /verzeichnis -type f -name "*.log" -o -name "*.txt"

# Bestimmte Verzeichnisse ausschließen
find /verzeichnis -type f -not -path "*/node_modules/*" -not -path "*/.*/*"

# Alle Verzeichnisse außer './temp' und './cache' durchsuchen
find . \( -name temp -o -name cache \) -prune -o -type f -name "*.py" -print

# Die schnelleren Tests zuerst platzieren
find /verzeichnis -type f -size -1M -mtime +30 -name "*.log"

# Bei großen Dateimengen: parallel verarbeiten
find /verzeichnis -type f -name "*.jpg" -print0 | xargs -0 -P 8 -n 10 jpegoptim

#!/bin/bash
# search_replace.sh - Rekursive Suche und Ersetzung in Dateien
# Verwendung: search_replace.sh Verzeichnis Suchmuster Ersetzung Dateimuster

if [ $# -ne 4 ]; then
    echo "Verwendung: $0 <verzeichnis> <suchmuster> <ersetzung> <dateimuster>"
    echo "Beispiel: $0 /var/www 'alte_domain.com' 'neue_domain.com' '*.php'"
    exit 1
fi

DIR="$1"
SEARCH="$2"
REPLACE="$3"
PATTERN="$4"

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

# Zuerst Dateien finden, die das Suchmuster enthalten
echo "Suche nach Dateien, die '$SEARCH' enthalten..."
MATCHING_FILES=$(grep -l "$SEARCH" $(find "$DIR" -type f -name "$PATTERN"))

if [ -z "$MATCHING_FILES" ]; then
    echo "Keine übereinstimmenden Dateien gefunden."
    exit 0
fi

# Anzahl der gefundenen Dateien ermitteln
COUNT=$(echo "$MATCHING_FILES" | wc -l)
echo "Gefunden: $COUNT Dateien mit dem Muster '$SEARCH'"

# Bestätigung einholen
echo "Möchten Sie '$SEARCH' durch '$REPLACE' in diesen Dateien ersetzen? (j/N)"
read -r CONFIRM
if [[ ! "$CONFIRM" =~ ^[jJ] ]]; then
    echo "Abgebrochen."
    exit 0
fi

# Ersetzung durchführen
echo "$MATCHING_FILES" | while read -r FILE; do
    echo "Bearbeite: $FILE"
    sed -i "s|$SEARCH|$REPLACE|g" "$FILE"
done

echo "Ersetzung abgeschlossen."
exit 0

#!/bin/bash
# cleanup_logs.sh - Alte Logdateien komprimieren oder löschen

# Konfiguration
LOG_DIR="/var/log"
DAYS_TO_COMPRESS=7
DAYS_TO_DELETE=30
DRY_RUN=false

# Optionen verarbeiten
while getopts "d:c:r:n" opt; do
  case $opt in
    d) LOG_DIR="$OPTARG" ;;
    c) DAYS_TO_COMPRESS="$OPTARG" ;;
    r) DAYS_TO_DELETE="$OPTARG" ;;
    n) DRY_RUN=true ;;
    *) echo "Ungültige Option"; exit 1 ;;
  esac
done

# Funktion: Logdateien komprimieren, die älter als X Tage sind
compress_old_logs() {
    local days="$1"
    echo "Suche nach Logdateien älter als $days Tage zur Komprimierung..."
    
    if $DRY_RUN; then
        find "$LOG_DIR" -name "*.log" -type f -mtime +$days -not -name "*.gz" -print
    else
        find "$LOG_DIR" -name "*.log" -type f -mtime +$days -not -name "*.gz" -exec gzip {} \;
    fi
}

# Funktion: Alte komprimierte Logs löschen
delete_old_logs() {
    local days="$1"
    echo "Suche nach komprimierten Logdateien älter als $days Tage zum Löschen..."
    
    if $DRY_RUN; then
        find "$LOG_DIR" -name "*.log.gz" -type f -mtime +$days -print
    else
        find "$LOG_DIR" -name "*.log.gz" -type f -mtime +$days -delete
    fi
}

# Hauptprogramm
if [ ! -d "$LOG_DIR" ]; then
    echo "Fehler: Verzeichnis '$LOG_DIR' existiert nicht."
    exit 1
fi

if $DRY_RUN; then
    echo "DRY RUN: Es werden keine Änderungen vorgenommen."
fi

compress_old_logs "$DAYS_TO_COMPRESS"
delete_old_logs "$DAYS_TO_DELETE"

echo "Bereinigung abgeschlossen."
exit 0

#!/bin/bash
# find_duplicates.sh - Sucht Dateiduplikate in einem Verzeichnis basierend auf MD5-Hashes

if [ $# -lt 1 ]; then
    echo "Verwendung: $0 <verzeichnis> [--delete]"
    exit 1
fi

DIR="$1"
DELETE=false

if [ "$2" = "--delete" ]; then
    DELETE=true
    echo "WARNUNG: Automatisches Löschen von Duplikaten aktiviert!"
fi

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

TEMP_FILE=$(mktemp)
DUPE_REPORT="duplicate_files_$(date +%Y%m%d_%H%M%S).txt"

echo "Berechne Hashes für alle Dateien (dies kann einige Zeit dauern)..."
find "$DIR" -type f -exec md5sum {} \; | sort > "$TEMP_FILE"

echo "Suche nach Duplikaten..."
cat "$TEMP_FILE" | uniq -w 32 -d --all-repeated=separate > "$DUPE_REPORT"

# Anzahl der Duplikatsgruppen ermitteln
DUPE_GROUPS=$(grep -c "^[0-9a-f]\{32\}" "$DUPE_REPORT")

if [ "$DUPE_GROUPS" -eq 0 ]; then
    echo "Keine Duplikate gefunden."
    rm "$TEMP_FILE" "$DUPE_REPORT"
    exit 0
fi

echo "Gefunden: $DUPE_GROUPS Duplikatsgruppen."
echo "Vollständiger Bericht gespeichert in: $DUPE_REPORT"

if $DELETE; then
    echo "Lösche alle Duplikate außer der ersten Instanz jeder Datei..."
    
    # Durchlaufe jede Gruppe von Duplikaten
    cat "$TEMP_FILE" | cut -c 35- | uniq -d | while read -r original; do
        # Finde alle Dateien mit dem gleichen Hash
        md5=$(md5sum "$original" | cut -d' ' -f1)
        duplicates=$(grep "^$md5" "$TEMP_FILE" | cut -c 35- | grep -v "^$original$")
        
        # Lösche die Duplikate
        echo "$duplicates" | while read -r duplicate; do
            echo "Lösche Duplikat: $duplicate"
            rm "$duplicate"
        done
    done
    
    echo "Bereinigung abgeschlossen."
fi

rm "$TEMP_FILE"
exit 0

# Nach Dateien mit exaktem Namen suchen
find /pfad/zum/verzeichnis -name "dateiname.txt"

# Nach Dateien mit Muster suchen (Globbing)
find /pfad/zum/verzeichnis -name "*.log"

# Groß-/Kleinschreibung ignorieren
find /pfad/zum/verzeichnis -iname "*.Jpg"

# Negation: Alles außer bestimmten Dateien
find /pfad/zum/verzeichnis -not -name "*.tmp"

# Logisches ODER: Dateien mit .jpg ODER .png Endung
find /pfad/zum/verzeichnis -name "*.jpg" -o -name "*.png"

# Logisches UND: Dateien mit .log Endung, die NICHT cache im Namen haben
find /pfad/zum/verzeichnis -name "*.log" -not -name "*cache*"

# Gruppierung mit Klammern (Escape-Zeichen beachten)
find /pfad/zum/verzeichnis \( -name "*.jpg" -o -name "*.png" \) -not -name "*thumb*"

# Reguläre Dateien
find /pfad/zum/verzeichnis -type f

# Verzeichnisse
find /pfad/zum/verzeichnis -type d

# Symbolische Links
find /pfad/zum/verzeichnis -type l

# Pipes (FIFOs)
find /pfad/zum/verzeichnis -type p

# Socket-Dateien
find /pfad/zum/verzeichnis -type s

# Block-Gerätedateien
find /pfad/zum/verzeichnis -type b

# Zeichen-Gerätedateien
find /pfad/zum/verzeichnis -type c

find /pfad/zum/verzeichnis -not -type f

# Dateien größer als 10MB
find /pfad/zum/verzeichnis -type f -size +10M

# Dateien kleiner als 1KB
find /pfad/zum/verzeichnis -type f -size -1k

# Dateien genau 0 Bytes (leere Dateien)
find /pfad/zum/verzeichnis -type f -size 0

# Dateien zwischen 5MB und 10MB
find /pfad/zum/verzeichnis -type f -size +5M -size -10M

#!/bin/bash
# large_files.sh - Finde die 10 größten Dateien in einem Verzeichnis

TARGET_DIR="${1:-/home/user}"
NUM_FILES="${2:-10}"

echo "Die $NUM_FILES größten Dateien in $TARGET_DIR:"
find "$TARGET_DIR" -type f -printf "%s %p\n" | sort -rn | head -n "$NUM_FILES" | 
awk '{printf "%.2f MB\t%s\n", $1/(1024*1024), substr($0, length($1)+2)}'

# Dateien, die in den letzten 7 Tagen geändert wurden
find /pfad/zum/verzeichnis -type f -mtime -7

# Dateien, die vor mehr als 30 Tagen geändert wurden
find /pfad/zum/verzeichnis -type f -mtime +30

# Dateien, die genau vor 1 Tag geändert wurden
find /pfad/zum/verzeichnis -type f -mtime 1

# Dateien, auf die in den letzten 14 Tagen nicht zugegriffen wurde
find /pfad/zum/verzeichnis -type f -atime +14

# Dateien, die in den letzten 60 Minuten geändert wurden
find /pfad/zum/verzeichnis -type f -mmin -60

# Dateien, auf die in den letzten 30 Minuten zugegriffen wurde
find /pfad/zum/verzeichnis -type f -amin -30

# Dateien, die neuer als eine Referenzdatei sind
find /pfad/zum/verzeichnis -type f -newer /pfad/zur/referenzdatei

# Dateien, die nach einem bestimmten Zeitpunkt geändert wurden
touch -t 202401010000 /tmp/zeitstempel
find /pfad/zum/verzeichnis -type f -newer /tmp/zeitstempel

#!/bin/bash
# archive_old_files.sh - Archiviert Dateien, die älter als X Tage sind

SOURCE_DIR="${1:-/var/data}"
DAYS_OLD="${2:-90}"
ARCHIVE_DIR="/var/archives/$(date +%Y%m)"

# Archivverzeichnis erstellen, falls es nicht existiert
mkdir -p "$ARCHIVE_DIR"

# Dateien finden, die älter als DAYS_OLD Tage sind
echo "Suche Dateien in $SOURCE_DIR, die älter als $DAYS_OLD Tage sind..."
OLD_FILES=$(find "$SOURCE_DIR" -type f -mtime +$DAYS_OLD)

if [ -z "$OLD_FILES" ]; then
    echo "Keine alten Dateien gefunden."
    exit 0
fi

# Erstelle temporäre Dateiliste
TEMP_LIST=$(mktemp)
echo "$OLD_FILES" > "$TEMP_LIST"

# Archiviere die alten Dateien
echo "Archiviere alte Dateien nach $ARCHIVE_DIR..."
tar -czf "$ARCHIVE_DIR/old_files_$(date +%Y%m%d).tar.gz" -T "$TEMP_LIST"

# Lösche die Originaldateien nach erfolgreicher Archivierung
if [ $? -eq 0 ]; then
    echo "Entferne alte Dateien..."
    xargs rm -f < "$TEMP_LIST"
else
    echo "Fehler beim Archivieren, Originaldateien bleiben erhalten."
fi

# Aufräumen
rm "$TEMP_LIST"

# Dateien mit exakten Berechtigungen (777)
find /pfad/zum/verzeichnis -type f -perm 777

# Dateien mit mindestens den angegebenen Berechtigungen (alle haben Schreibzugriff)
find /pfad/zum/verzeichnis -type f -perm -002

# Dateien mit irgendeiner der angegebenen Berechtigungen (irgendwer hat Schreibzugriff)
find /pfad/zum/verzeichnis -type f -perm /002

# Symbolische Darstellung für weltlesbare Dateien
find /pfad/zum/verzeichnis -type f -perm -o=r

# SUID-Binärdateien finden (potenzielle Sicherheitsrisiken)
find /usr -type f -perm -4000

#!/bin/bash
# security_audit.sh - Findet Dateien mit potenziell unsicheren Berechtigungen

TARGET_DIR="${1:-/home}"
REPORT_FILE="security_audit_$(date +%Y%m%d).txt"

echo "Sicherheitsaudit für $TARGET_DIR am $(date)" > "$REPORT_FILE"
echo "=================================================" >> "$REPORT_FILE"

# Weltschreibbare Verzeichnisse finden
echo -e "\n### Weltschreibbare Verzeichnisse ###" >> "$REPORT_FILE"
find "$TARGET_DIR" -type d -perm -o=w | grep -v '/tmp$\|/temp$' >> "$REPORT_FILE"

# Weltschreibbare Dateien finden
echo -e "\n### Weltschreibbare Dateien ###" >> "$REPORT_FILE"
find "$TARGET_DIR" -type f -perm -o=w >> "$REPORT_FILE"

# SUID/SGID Programme finden
echo -e "\n### SUID/SGID Programme ###" >> "$REPORT_FILE"
find "$TARGET_DIR" -type f \( -perm -4000 -o -perm -2000 \) >> "$REPORT_FILE"

# Weltausführbare Skripte finden
echo -e "\n### Weltausführbare Skriptdateien ###" >> "$REPORT_FILE"
find "$TARGET_DIR" -type f -perm -o=x -name "*.sh" -o -name "*.pl" -o -name "*.py" >> "$REPORT_FILE"

echo "Audit abgeschlossen. Ergebnisse in $REPORT_FILE"

# Dateien, die einem bestimmten Benutzer gehören
find /pfad/zum/verzeichnis -type f -user benutzername

# Dateien, die einer bestimmten Gruppe gehören
find /pfad/zum/verzeichnis -type f -group gruppenname

# Dateien ohne Eigentümer (Besitzer gelöscht)
find /pfad/zum/verzeichnis -type f -nouser

# Dateien ohne gültige Gruppe
find /pfad/zum/verzeichnis -type f -nogroup

#!/bin/bash
# orphaned_files.sh - Behandelt Dateien ohne Eigentümer

TARGET_DIR="${1:-/}"
ACTION="${2:-report}"  # 'report' oder 'cleanup'

case "$ACTION" in
    report)
        echo "Bericht über verwaiste Dateien in $TARGET_DIR:"
        find "$TARGET_DIR" \( -nouser -o -nogroup \) -ls
        ;;
    cleanup)
        echo "Bereinigung verwaister Dateien in $TARGET_DIR:"
        # Verwaiste Dateien in /lost+found verschieben
        mkdir -p /lost+found
        find "$TARGET_DIR" \( -nouser -o -nogroup \) -type f \
            -exec mv {} /lost+found/ \; -printf "Verschoben: %p\n"
        find "$TARGET_DIR" \( -nouser -o -nogroup \) -type d \
            -exec chown root:root {} \; -printf "Eigentümer gesetzt: %p\n"
        ;;
    *)
        echo "Ungültige Aktion: $ACTION"
        echo "Verwendung: $0 [verzeichnis] [report|cleanup]"
        exit 1
        ;;
esac

# Dateien finden, die ein bestimmtes Muster enthalten
find /pfad/zum/verzeichnis -type f -exec grep -l "suchmuster" {} \;

# Effizienter mit xargs
find /pfad/zum/verzeichnis -type f -name "*.conf" | xargs grep -l "parameter"

# Noch effizienter mit null-terminierter Ausgabe (für Dateien mit Leerzeichen)
find /pfad/zum/verzeichnis -type f -name "*.php" -print0 | xargs -0 grep -l "function"

#!/bin/bash
# content_search.sh - Suche in Dateien nach mehreren Mustern

TARGET_DIR="${1:-.}"
shift
PATTERNS=("$@")

if [ ${#PATTERNS[@]} -eq 0 ]; then
    echo "Verwendung: $0 [verzeichnis] <muster1> [muster2] ..."
    exit 1
fi

# Erstelle temporäre Datei für Ergebnisse
RESULTS=$(mktemp)

echo "Suche in $TARGET_DIR nach: ${PATTERNS[*]}"
echo "Ergebnisse:"

# Für jedes Muster suchen und Ergebnisse sammeln
for pattern in "${PATTERNS[@]}"; do
    echo -e "\nDateien mit '$pattern':" >> "$RESULTS"
    find "$TARGET_DIR" -type f -exec grep -l "$pattern" {} \; | sort >> "$RESULTS"
done

# Dateien finden, die ALLE angegebenen Muster enthalten
if [ ${#PATTERNS[@]} -gt 1 ]; then
    echo -e "\nDateien mit ALLEN angegebenen Mustern:" >> "$RESULTS"
    
    # Erstelle temporäre Dateien für die Schnittmenge
    TEMP1=$(mktemp)
    TEMP2=$(mktemp)
    
    # Erste Suchliste in TEMP1 speichern
    find "$TARGET_DIR" -type f -exec grep -l "${PATTERNS[0]}" {} \; > "$TEMP1"
    
    # Für jedes weitere Muster die Schnittmenge bilden
    for ((i=1; i<${#PATTERNS[@]}; i++)); do
        find "$TARGET_DIR" -type f -exec grep -l "${PATTERNS[$i]}" {} \; | \
        sort | comm -12 "$TEMP1" - > "$TEMP2"
        cat "$TEMP2" > "$TEMP1"
    done
    
    cat "$TEMP1" >> "$RESULTS"
    
    # Aufräumen
    rm "$TEMP1" "$TEMP2"
fi

# Ergebnisse anzeigen
cat "$RESULTS"
rm "$RESULTS"

# Dateien auf einem bestimmten Dateisystem finden
find /pfad/zum/verzeichnis -fstype ext4

# Dateien mit einer bestimmten Inode-Nummer finden
find /pfad/zum/verzeichnis -inum 12345

# Mehrere Links zu derselben Inode finden (Hardlinks)
find /pfad/zum/verzeichnis -type f -links +1

# Leere Dateien finden
find /pfad/zum/verzeichnis -type f -empty

# Leere Verzeichnisse finden
find /pfad/zum/verzeichnis -type d -empty

# Leere Dateien und Verzeichnisse finden und löschen
find /pfad/zum/verzeichnis -empty -delete

#!/bin/bash
# cleanup_empty_dirs.sh - Räumt leere Verzeichnisse auf

TARGET_DIR="${1:-.}"
MIN_DEPTH="${2:-1}"  # Mindesttiefe, um Löschen des Wurzelverzeichnisses zu verhindern

if [ ! -d "$TARGET_DIR" ]; then
    echo "Fehler: $TARGET_DIR ist kein Verzeichnis."
    exit 1
fi

echo "Suche nach leeren Verzeichnissen in $TARGET_DIR..."

# Zuerst nur zählen und anzeigen
EMPTY_DIRS=$(find "$TARGET_DIR" -mindepth "$MIN_DEPTH" -type d -empty)
COUNT=$(echo "$EMPTY_DIRS" | grep -v "^$" | wc -l)

if [ "$COUNT" -eq 0 ]; then
    echo "Keine leeren Verzeichnisse gefunden."
    exit 0
fi

echo "Gefunden: $COUNT leere Verzeichnisse."
echo "$EMPTY_DIRS"

# Nachfragen, ob gelöscht werden soll
read -p "Möchten Sie diese Verzeichnisse löschen? (j/N) " -n 1 -r
echo

if [[ $REPLY =~ ^[jJ]$ ]]; then
    # Von der tiefsten Ebene beginnend löschen
    find "$TARGET_DIR" -mindepth "$MIN_DEPTH" -type d -empty -delete
    
    # Prüfen, ob alle leeren Verzeichnisse gelöscht wurden
    REMAINING=$(find "$TARGET_DIR" -mindepth "$MIN_DEPTH" -type d -empty | wc -l)
    
    if [ "$REMAINING" -eq 0 ]; then
        echo "Alle leeren Verzeichnisse wurden gelöscht."
    else
        echo "Es konnten nicht alle Verzeichnisse gelöscht werden. $REMAINING verbleibend."
    fi
else
    echo "Vorgang abgebrochen. Keine Verzeichnisse wurden gelöscht."
fi

# Große, kürzlich geänderte Logdateien finden
find /var/log -type f -name "*.log" -size +10M -mtime -7

# Alte Konfigurationsdateien finden, die weltlesbar sind
find /etc -type f -perm -o=r -mtime +365

# Ausführbare Skriptdateien finden, die einem bestimmten Benutzer gehören
find /home -type f -user username -perm /u=x -name "*.sh"

# Bestimmte Verzeichnisse ausschließen
find /home -type f -not -path "*/node_modules/*" -not -path "*/.git/*"

# Effizientere Methode mit -prune
find /home -type d \( -name node_modules -o -name .git \) -prune -o -type f -print

#!/bin/bash
# code_search.sh - Suche in Codebasen unter Ausschluss von Build-Verzeichnissen

TARGET_DIR="${1:-.}"
PATTERN="$2"

if [ -z "$PATTERN" ]; then
    echo "Verwendung: $0 [verzeichnis] <suchmuster>"
    exit 1
fi

# Liste häufiger Verzeichnisse, die auszuschließen sind
EXCLUDE_DIRS=(
    node_modules
    .git
    .svn
    build
    dist
    target
    vendor
    __pycache__
    .idea
    .vscode
)

# Erstelle den Ausschlussfilter für find
EXCLUDE_EXPR=""
for dir in "${EXCLUDE_DIRS[@]}"; do
    EXCLUDE_EXPR="$EXCLUDE_EXPR -name $dir -o"
done
EXCLUDE_EXPR="( ${EXCLUDE_EXPR% -o} ) -prune -o"

# Dateiendungen für Quellcode
CODE_EXTENSIONS=(
    "*.c" "*.cpp" "*.h" "*.hpp"
    "*.java" "*.cs" "*.py" "*.rb"
    "*.js" "*.ts" "*.php" "*.go"
    "*.sh" "*.pl" "*.pm" "*.swift"
)

# Erstelle den Filter für Quellcodedateien
FILE_EXPR=""
for ext in "${CODE_EXTENSIONS[@]}"; do
    FILE_EXPR="$FILE_EXPR -name $ext -o"
done
FILE_EXPR="( ${FILE_EXPR% -o} )"

# Führe die Suche aus
echo "Suche nach '$PATTERN' in $TARGET_DIR (ohne Build-Verzeichnisse)..."

find "$TARGET_DIR" $EXCLUDE_EXPR -type f $FILE_EXPR -exec grep -l "$PATTERN" {} \;

# Benutzerdefinierte Ausgabeformatierung
find /pfad/zum/verzeichnis -type f -printf "%p %s %TY-%Tm-%Td %TH:%TM\n"

# Häufig verwendete Formatierungsoptionen:
# %p - Dateipfad
# %f - Dateiname
# %h - Verzeichnis
# %s - Größe in Bytes
# %TY, %Tm, %Td - Jahr, Monat, Tag der letzten Änderung
# %TH, %TM - Stunde, Minute der letzten Änderung
# %u - Eigentümer (Benutzername)
# %g - Gruppe
# %m - Berechtigungen (als Oktalzahl)

#!/bin/bash
# detailed_file_list.sh - Erstellt eine detaillierte Dateilistenanzeige

TARGET_DIR="${1:-.}"
OUTPUT_FORMAT="${2:-standard}"  # standard, csv, html

if [ ! -d "$TARGET_DIR" ]; then
    echo "Fehler: $TARGET_DIR ist kein Verzeichnis."
    exit 1
fi

case "$OUTPUT_FORMAT" in
    standard)
        echo "Detaillierte Dateiliste für $TARGET_DIR"
        echo "=========================================="
        find "$TARGET_DIR" -type f -printf "%-50p | %10s Bytes | %TY-%Tm-%Td %TH:%TM | %u:%g\n" | \
            sort
        ;;
    csv)
        OUTPUT_FILE="file_list_$(date +%Y%m%d).csv"
        echo "Pfad,Größe (Bytes),Datum,Zeit,Eigentümer,Gruppe" > "$OUTPUT_FILE"
        find "$TARGET_DIR" -type f -printf "\"%p\",%s,%TY-%Tm-%Td,%TH:%TM:%TS,%u,%g\n" >> "$OUTPUT_FILE"
        echo "CSV-Datei erstellt: $OUTPUT_FILE"
        ;;
    html)
        OUTPUT_FILE="file_list_$(date +%Y%m%d).html"
        cat > "$OUTPUT_FILE" << EOF
<!DOCTYPE html>
<html>
<head>
    <title>Dateiliste für $TARGET_DIR</title>
    <style>
        body { font-family: Arial, sans-serif; }
        table { border-collapse: collapse; width: 100%; }
        th, td { text-align: left; padding: 8px; border-bottom: 1px solid #ddd; }
        tr:nth-child(even) { background-color: #f2f2f2; }
        th { background-color: #4CAF50; color: white; }
    </style>
</head>
<body>
    <h1>Dateiliste für $TARGET_DIR</h1>
    <p>Erstellt am $(date)</p>
    <table>
        <tr>
            <th>Datei</th>
            <th>Größe</th>
            <th>Datum</th>
            <th>Eigentümer</th>
        </tr>
EOF

        find "$TARGET_DIR" -type f -printf "<tr><td>%p</td><td>%s Bytes</td><td>%TY-%Tm-%Td %TH:%TM</td><td>%u:%g</td></tr>\n" \
            >> "$OUTPUT_FILE"

        cat >> "$OUTPUT_FILE" << EOF
    </table>
</body>
</html>
EOF
        echo "HTML-Datei erstellt: $OUTPUT_FILE"
        ;;
    *)
        echo "Fehler: Ungültiges Ausgabeformat. Mögliche Werte: standard, csv, html"
        exit 1
        ;;
esac

# Schnelle Suche nach Dateinamen
locate filename.txt

# Aktualisieren der locate-Datenbank
sudo updatedb

# Installation (Ubuntu/Debian)
# sudo apt install fd-find

# Grundlegende Suche (implizit rekursiv)
fd pattern /pfad/zum/verzeichnis

# Nur bestimmte Dateitypen
fd --type f --extension txt

# Ignorieren von Verzeichnissen
fd pattern --exclude node_modules

# Installation (Ubuntu/Debian)
# sudo apt install fzf

# Interaktive Dateisuche
fzf

# Mit Vorschau
fzf --preview 'cat {}'

# Als Filter in Pipe
find . -type f | fzf

# Einfacher Zugriff auf /tmp
echo "Temporäre Daten" > /tmp/meine_temp_datei

# Prüfen des Dateisystem-Typs von /tmp
df -T /tmp

# Grundlegende Verwendung
TEMP_FILE=$(mktemp)
echo "Datei erstellt: $TEMP_FILE"  # Ausgabe z.B.: /tmp/tmp.A1B2C3D4E5

# Mit benutzerdefiniertem Präfix
TEMP_FILE=$(mktemp /tmp/myapp.XXXXXX)
echo "Datei erstellt: $TEMP_FILE"  # Ausgabe z.B.: /tmp/myapp.A1B2C3

# Temporäres Verzeichnis erstellen
TEMP_DIR=$(mktemp -d)
echo "Verzeichnis erstellt: $TEMP_DIR"

#!/bin/bash
# temp_file_example.sh - Demonstration temporärer Dateien

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

# Aufräumen bei Beendigung des Skripts
trap 'rm -f "$TEMP_FILE"' EXIT

echo "Temporäre Datei: $TEMP_FILE"

# Daten in die temporäre Datei schreiben
echo "Zeile 1: Beispieldaten" > "$TEMP_FILE"
echo "Zeile 2: Weitere Daten" >> "$TEMP_FILE"

# Mit den Daten arbeiten
echo "Inhalt der temporären Datei:"
cat "$TEMP_FILE"

# Datei verarbeiten (z.B. sortieren)
sort "$TEMP_FILE" -o "$TEMP_FILE.sorted"
echo "Sortierter Inhalt:"
cat "$TEMP_FILE.sorted"

# Aufräumen der zusätzlichen Datei
rm -f "$TEMP_FILE.sorted"

echo "Skript beendet. Die temporäre Datei wird automatisch gelöscht."

# Kein explizites Löschen nötig, da die trap-Anweisung dies übernimmt
exit 0

# Grundlegende Syntax
trap 'Befehle' SIGNALE

# Beispiel: Aufräumen bei normalem Beenden und bei Abbruch
trap 'rm -f "$TEMP_FILE"; echo "Aufgeräumt!"' EXIT INT TERM

#!/bin/bash
# multi_temp_files.sh - Verwaltung mehrerer temporärer Dateien

# Temporäres Verzeichnis für alle temporären Dateien erstellen
TEMP_DIR=$(mktemp -d)
trap 'rm -rf "$TEMP_DIR"' EXIT

echo "Temporäres Arbeitsverzeichnis: $TEMP_DIR"

# Mehrere temporäre Dateien im temporären Verzeichnis erstellen
TEMP_FILE1="$TEMP_DIR/file1"
TEMP_FILE2="$TEMP_DIR/file2"
TEMP_FILE3="$TEMP_DIR/file3"

# Dateien mit Beispieldaten füllen
seq 1 5 > "$TEMP_FILE1"
seq 6 10 > "$TEMP_FILE2"

# Dateien verarbeiten
cat "$TEMP_FILE1" "$TEMP_FILE2" > "$TEMP_FILE3"

echo "Kombinierte Daten:"
cat "$TEMP_FILE3"

echo "Alle temporären Dateien werden beim Beenden gelöscht."
exit 0

# Temporäre Datei mit restriktiven Berechtigungen erstellen
TEMP_FILE=$(mktemp)
chmod 600 "$TEMP_FILE"  # Nur Lese-/Schreibzugriff für den Eigentümer

# Für gemeinsam genutzte temporäre Dateien (Vorsicht!)
SHARED_TEMP=$(mktemp)
chmod 644 "$SHARED_TEMP"  # Lesbar für alle, aber nur vom Eigentümer schreibbar

# UNSICHER: Vorhersehbarer Dateiname
TEMP_FILE="/tmp/myapp_$$.tmp"  # $$ ist die Prozess-ID
echo "Geheime Daten" > "$TEMP_FILE"
# ... Verarbeitung ...
rm -f "$TEMP_FILE"

# SICHER: Zufälliger Dateiname mit mktemp
TEMP_FILE=$(mktemp)
trap 'rm -f "$TEMP_FILE"' EXIT INT TERM
echo "Geheime Daten" > "$TEMP_FILE"
chmod 600 "$TEMP_FILE"  # Nur Eigentümer kann lesen/schreiben
# ... Verarbeitung ...
# Explizites Überschreiben vor dem Löschen bei sensiblen Daten
shred -u "$TEMP_FILE"  # Überschreibt die Datei mehrmals und löscht sie

# Temporäre .txt-Datei erstellen
TEMP_TXT=$(mktemp --suffix=.txt)

# Alternative Methode
TEMP_BASE=$(mktemp)
TEMP_TXT="${TEMP_BASE}.txt"
mv "$TEMP_BASE" "$TEMP_TXT"

#!/bin/bash
# temp_structure.sh - Erstellen und Verwenden einer temporären Verzeichnisstruktur

# Temporäres Hauptverzeichnis erstellen
TEMP_ROOT=$(mktemp -d)
trap 'rm -rf "$TEMP_ROOT"' EXIT

echo "Temporäres Hauptverzeichnis: $TEMP_ROOT"

# Unterverzeichnisse erstellen
mkdir -p "$TEMP_ROOT"/{input,output,logs}

# Dateien in den Unterverzeichnissen erstellen
echo "Eingabedaten" > "$TEMP_ROOT/input/data.txt"
echo "Protokoll gestartet" > "$TEMP_ROOT/logs/process.log"

# Verarbeitung simulieren
cat "$TEMP_ROOT/input/data.txt" | tr 'a-z' 'A-Z' > "$TEMP_ROOT/output/result.txt"
echo "Verarbeitung abgeschlossen" >> "$TEMP_ROOT/logs/process.log"

# Ergebnisse anzeigen
echo "Verarbeitete Daten:"
cat "$TEMP_ROOT/output/result.txt"

echo "Protokoll:"
cat "$TEMP_ROOT/logs/process.log"

echo "Temporäre Verzeichnisstruktur wird beim Beenden gelöscht."
exit 0

# Standard-Temporärverzeichnis verwenden
TEMP_FILE=$(mktemp)

# Benutzerdefiniertes Temporärverzeichnis setzen
export TMPDIR=/path/to/custom/temp
TEMP_FILE=$(mktemp)  # Wird nun in $TMPDIR erstellt

#!/bin/bash
# tmpdir_example.sh - Verwendet TMPDIR Umgebungsvariable

# Fallback auf /tmp, wenn TMPDIR nicht gesetzt ist
: "${TMPDIR:=/tmp}"

# Temporäre Datei im durch TMPDIR definierten Verzeichnis erstellen
TEMP_FILE=$(mktemp)
trap 'rm -f "$TEMP_FILE"' EXIT

echo "Temporäre Datei: $TEMP_FILE"
# ... Rest des Skripts ...

#!/bin/bash
# persistent_temp.sh - Demonstration persistenter temporärer Dateien

# Temporäres Verzeichnis mit Zeitstempel
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
TEMP_DIR="/tmp/myapp_$TIMESTAMP"

mkdir -p "$TEMP_DIR"
echo "Temporäres Verzeichnis erstellt: $TEMP_DIR"

# Daten generieren
echo "Beispieldaten für spätere Analyse" > "$TEMP_DIR/data.txt"

echo "Das temporäre Verzeichnis wird NICHT automatisch gelöscht."
echo "Sie können es mit folgendem Befehl löschen:"
echo "  rm -rf $TEMP_DIR"

# Speicherort in einer Log-Datei festhalten
echo "$TEMP_DIR" >> ~/.myapp_temp_dirs.log

#!/bin/bash
# cleanup_old_temp.sh - Bereinigt alte temporäre Dateien einer Anwendung

TEMP_PATTERN="/tmp/myapp_*"
MAX_AGE_DAYS=7

echo "Suche nach temporären Dateien älter als $MAX_AGE_DAYS Tage..."

# Alte temporäre Dateien finden und löschen
find ${TEMP_PATTERN} -type d -mtime +${MAX_AGE_DAYS} -print -exec rm -rf {} \;

echo "Bereinigung abgeschlossen."

#!/bin/bash
# data_pipeline.sh - Verarbeitet Daten in mehreren Schritten mit Zwischenergebnissen

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

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

echo "Verarbeite $INPUT_FILE..."

# Schritt 1: Daten extrahieren
echo "Schritt 1: Daten extrahieren..."
grep -v "^#" "$INPUT_FILE" | cut -f2,3,5 > "$TEMP_DIR/step1.txt"

# Schritt 2: Daten transformieren
echo "Schritt 2: Daten transformieren..."
awk '{print $1 "," $2 "," $3}' "$TEMP_DIR/step1.txt" > "$TEMP_DIR/step2.csv"

# Schritt 3: Daten aggregieren
echo "Schritt 3: Daten aggregieren..."
sort -t, -k1,1 "$TEMP_DIR/step2.csv" | \
  awk -F, '{ sum[$1] += $3; count[$1]++ } 
  END { for (key in sum) print key "," sum[key] "," sum[key]/count[key] }' > \
  "$TEMP_DIR/step3.csv"

# Finale Ausgabe
echo "Ergebnisse:"
cat "$TEMP_DIR/step3.csv"

# Optional: Ergebnisse in eine permanente Datei speichern
OUTPUT_FILE="output_$(date +%Y%m%d).csv"
cp "$TEMP_DIR/step3.csv" "$OUTPUT_FILE"
echo "Ergebnisse gespeichert in $OUTPUT_FILE"

echo "Verarbeitung abgeschlossen. Temporäre Dateien werden gelöscht."
exit 0

# RAM-basiertes temporäres Verzeichnis verwenden
TEMP_FILE="/dev/shm/myapp_$RANDOM"
echo "Daten im RAM" > "$TEMP_FILE"
# ... Verarbeitung ...
rm -f "$TEMP_FILE"

# Sicherere Variante mit mktemp
TEMP_FILE=$(mktemp -p /dev/shm)
trap 'rm -f "$TEMP_FILE"' EXIT

#!/bin/bash
# temp_config.sh - Erstellt eine temporäre Konfigurationsdatei für ein Programm

# Temporäre Konfigurationsdatei erstellen
CONFIG_FILE=$(mktemp --suffix=.conf)
trap 'rm -f "$CONFIG_FILE"' EXIT

# Konfigurationsdatei füllen
cat > "$CONFIG_FILE" << EOF
# Automatisch generierte Konfiguration
debug = true
log_level = info
max_connections = 100
timeout = 30
input_file = "$1"
output_file = "$(realpath "$2")"
EOF

echo "Temporäre Konfigurationsdatei erstellt: $CONFIG_FILE"

# Externes Programm mit der Konfigurationsdatei aufrufen
echo "Führe Programm mit temporärer Konfiguration aus..."
./my_program --config "$CONFIG_FILE"

echo "Verarbeitung abgeschlossen. Temporäre Konfiguration wird gelöscht."
exit 0

#!/bin/bash
# large_temp_files.sh - Verwalten großer temporärer Dateien

# Verfügbaren Speicherplatz prüfen
TEMP_DIR="/tmp"
REQUIRED_SPACE=1048576  # 1 GB in KB

AVAILABLE_SPACE=$(df -k "$TEMP_DIR" | awk 'NR==2 {print $4}')

if [ "$AVAILABLE_SPACE" -lt "$REQUIRED_SPACE" ]; then
    echo "Fehler: Nicht genug Speicherplatz in $TEMP_DIR"
    echo "Verfügbar: $AVAILABLE_SPACE KB, Benötigt: $REQUIRED_SPACE KB"
    exit 1
fi

# Temporäre Datei erstellen
TEMP_FILE=$(mktemp)
trap 'rm -f "$TEMP_FILE"' EXIT

echo "Generiere große Datenmenge in $TEMP_FILE..."

# Große Datei generieren (z.B. 500 MB mit zufälligen Daten)
dd if=/dev/urandom of="$TEMP_FILE" bs=1M count=500 2>/dev/null

echo "Temporäre Datei erstellt: $(du -h "$TEMP_FILE" | cut -f1)"

# Verarbeitung simulieren
echo "Verarbeite Daten..."
sleep 2  # Simuliert Verarbeitung

echo "Verarbeitung abgeschlossen. Temporäre Datei wird gelöscht."
exit 0

#!/bin/bash
# debug_temp.sh - Behält temporäre Dateien für Debugging

# Kommandozeilenargument prüfen
KEEP_TEMP=0
if [ "$1" = "--keep-temp" ]; then
    KEEP_TEMP=1
    shift
fi

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

# Nur aufräumen, wenn nicht im Debug-Modus
if [ "$KEEP_TEMP" -eq 0 ]; then
    trap 'rm -f "$TEMP_FILE"' EXIT
else
    echo "DEBUG-MODUS: Temporäre Datei wird beibehalten: $TEMP_FILE"
fi

# ... Rest des Skripts ...

if [ "$KEEP_TEMP" -eq 1 ]; then
    echo "Temporäre Datei für Inspektion: $TEMP_FILE"
fi

exit 0