Claude Code Masterkurs – KI-gestuetztes Programmieren lernen mit Anthropics Coding-Agent

. fd - Moderne File-Suche

Tool-Lektion | 35 Minuten

fd ist eine moderne Alternative zum klassischen find-Befehl, die Geschwindigkeit, Benutzerfreundlichkeit und intelligente Defaults kombiniert. Entwickelt in Rust, bietet fd eine intuitive Syntax

Lernziele

. fd - Moderne File-Suche

Berechtigung

fd ist eine moderne Alternative zum klassischen find-Befehl, die Geschwindigkeit, Benutzerfreundlichkeit und intelligente Defaults kombiniert. Entwickelt in Rust, bietet fd eine intuitive Syntax und ist dabei deutlich schneller als traditionelle Tools.

Warum fd seine Berechtigung hat:

Statistiken:

🚀 Claude Code Relevanz: fd ist der ideale Begleiter fuer Claude Code, um blitzschnell Dateien in grossen Projekten zu finden -- ob als FZF_DEFAULT_COMMAND oder zum gezielten Lokalisieren von Dateien vor der AI-gestuetzten Bearbeitung.

Zwecke

fd deckt alle Szenarien ab, in denen du Dateien finden, filtern und weiterverarbeiten musst -- von der einfachen Namenssuche bis zur automatisierten Batch-Verarbeitung.

Haupteinsatzgebiete:

Verwendung

Von der Installation ueber grundlegende Suchmuster bis zu fortgeschrittenen Filter-Optionen -- alles, was du fuer den produktiven Einsatz von fd brauchst.

Installation

Waehle den Installationsweg fuer dein System. Beachte den Namenskonflikt auf Ubuntu/Debian:

macOS (Homebrew)

Die schnellste Installation auf macOS:

brew install fd

Ubuntu/Debian

apt-get install fd-find
# Note: Binary heißt 'fdfind' wegen Name-Konflikt

# Alias erstellen
echo "alias fd='fdfind'" >> ~/.bashrc

Arch Linux

pacman -S fd

Rust (plattformunabhängig)

cargo install fd-find
💡 Tipp: Auf Ubuntu/Debian heisst das Binary fdfind statt fd wegen eines Namenskonflikts. Erstelle sofort einen Alias: alias fd='fdfind' in deiner Shell-Config.

Verifizierung

fd --version
# Output: fd 9.0.0

which fd
# Output: /usr/local/bin/fd

Quick Start

Die Grundbefehle zeigen, wie intuitiv fd ist -- kein -name oder -type f wie bei find noetig.

Basis-Suche

fd sucht standardmaessig rekursiv nach Dateinamen als Substring und zeigt farbige Ergebnisse:

# Suche nach Dateinamen (substring matching)
fd config

# Suche nach exaktem Namen
fd -g "*.json"

# Case-insensitive
fd -i readme

# Alle Files anzeigen
fd

File-Type Filtering

Mit dem -t Flag filterst du nach Dateityp -- Dateien, Verzeichnisse, Symlinks oder ausfuehrbare Programme:

# Nur Files (keine Directories)
fd -t f

# Nur Directories
fd -t d

# Nur Symlinks
fd -t l

# Nur Executables
fd -t x

# Mehrere Types
fd -t f -t d "test"

Extension Filtering

Filtere nach Dateiendungen mit -e -- mehrere Endungen koennen kombiniert werden:

# Alle JavaScript-Files
fd -e js

# Mehrere Extensions
fd -e js -e ts -e jsx -e tsx

# Mit Pattern
fd "component" -e tsx

Advanced Usage

Fortgeschrittene Filter wie Hidden Files, Groessen-Limits, Zeitfilter und verschiedene Ausgabeformate fuer komplexe Szenarien.

Regex Patterns

fd unterstuetzt sowohl Glob- als auch Regex-Modus fuer praezise Suchmuster:

# Regex-Modus aktivieren
fd -g "test-.*\.js$"

# Case-insensitive Regex
fd -i -g "readme\.md$"

# Full-Path Matching
fd -p "src/.*component"

# Negative Pattern (ausschließen)
fd -E "*.test.js"
🚀 Beispiel: Mit fd -e tsx "Component" src/ findest du in Sekundenbruchteilen alle React-Komponenten in deinem Projekt -- ideal als Vorbereitung, bevor Claude Code ein projektweites Refactoring durchfuehrt.

Hidden & Ignored Files

Standardmaessig ignoriert fd versteckte Dateien und .gitignore-Eintraege. Mit diesen Flags aenderst du das Verhalten:

# Hidden Files einbeziehen
fd -H ".env"

# .gitignore ignorieren
fd -I "node_modules"

# Beides
fd -HI ".git"

# Nur Ignored Files
fd --no-ignore-vcs

Depth Control

Die Tiefenbegrenzung ist essenziell fuer performante Suchen in grossen Verzeichnisstrukturen. Mit -d oder --max-depth legst du fest, wie viele Verzeichnisebenen tief fd suchen soll. Stell dir vor, du suchst eine Config-Datei, die du auf der obersten oder zweiten Ebene deines Projekts erwartest -- mit -d 2 ueberspringst du tiefe Verzeichnisse wie node_modules und sparst erheblich Zeit. Die --min-depth Option ist nuetzlich, wenn du Dateien in Unterverzeichnissen suchst und die Root-Ebene ueberspringen willst. Kombiniere beide fuer praezise Suchen in einem bestimmten Bereich der Verzeichnisstruktur.

# Max-Depth limitieren
fd -d 2 "config"

# Nur im Current Directory (depth=1)
fd -d 1 "package.json"

# Mindest-Depth
fd --min-depth 3 "index"

Size Filtering

Filtere Dateien nach Groesse -- nuetzlich fuer Disk-Audits oder das Finden von ueberdimensionierten Assets:

# Files größer als 100MB
fd -S +100m

# Files kleiner als 1KB
fd -S -1k

# Files zwischen 10KB und 1MB
fd -S +10k -S -1m

# Leere Files
fd -S 0

Time-based Filtering

Finde Dateien anhand ihres Aenderungsdatums -- ideal fuer die Suche nach kuerzlich bearbeiteten Dateien:

# Geändert in letzten 24h
fd -c less-than 24h

# Älter als 30 Tage
fd -c more-than 30d

# Geändert in letzten 7 Tagen
fd --changed-within 7d

# Erstellt vor mehr als 1 Jahr
fd --changed-before 1y

Output Formatting

fd unterstuetzt verschiedene Ausgabeformate fuer unterschiedliche Anwendungsfaelle. Die Null-Separation (-0) ist essenziell fuer die sichere Weiterverarbeitung mit xargs, da Dateinamen mit Leerzeichen oder Sonderzeichen sonst falsch interpretiert werden. Absolute Pfade (-a) sind nuetzlich, wenn du die Ergebnisse in Scripts oder externen Tools verwenden willst. Stell dir vor, du willst eine Liste aller Source-Dateien fuer ein Backup-Script erstellen -- mit -a bekommst du vollstaendige Pfade, die von jedem Verzeichnis aus funktionieren. Die -l Option zeigt Details wie Groesse und Aenderungsdatum, aehnlich wie ls -l.

# Null-separated (für xargs -0)
fd -0 "test"

# Absolute Paths
fd -a "src"

# Nur Dateinamen (kein Pfad)
fd --base-path . "component"

# Mit Details (wie ls -l)
fd -l "*.log"

Integration in Claude Code Workflows

. File-Analyse für AI-Processing

# Alle TypeScript-Files für Review
fd -e ts -e tsx | head -20 | \
  xargs -I {} claude "Review {} for best practices"

# Config-Files analysieren
fd "config" -e json -e yaml | \
  xargs cat | \
  claude "Check for security issues in configs"

. Batch-Refactoring

# Alle Component-Files finden
COMPONENTS=$(fd "Component\.tsx$" src/)

# Mit Claude für jeden refactoren
echo "$COMPONENTS" | while read file; do
  claude "Refactor $file to use React hooks"
done

. Project-Structure Analysis

# File-Tree generieren
fd -t f | \
  head -100 | \
  claude "Analyze project structure and suggest improvements"

# Identify inconsistent naming
fd | claude "Find files with inconsistent naming conventions"

. Dependency Audit

# Alle package.json Files
fd "package.json" --exec cat {} | \
  jq '.dependencies' | \
  claude "Identify outdated or duplicate dependencies"

Best Practices

Bewaehrte Muster fuer den taeglichen Einsatz von fd -- von Aliassen ueber Tool-Kombinationen bis zu Ignore-Patterns.

. Aliase für häufige Patterns

Diese Aliase decken die gaengigsten Suchvarianten ab und sparen dir wiederholtes Tippen:

# ~/.bashrc oder ~/.zshrc
alias fdh='fd -H'              # Include hidden
alias fdi='fd -I'              # Include ignored
alias fdd='fd -t d'            # Only directories
alias fdf='fd -t f'            # Only files
alias fdl='fd -S +10m'         # Large files
alias fdr='fd --changed-within 24h'  # Recent files

. Kombiniere mit fzf

fd als Datei-Lister und fzf als interaktiver Filter -- diese Kombination ersetzt den gesamten "Datei suchen und oeffnen"-Workflow:

# Interaktive File-Selection
file=$(fd -t f | fzf --preview 'bat --color=always {}')
[[ -n "$file" ]] && vim "$file"

# Als Function
fv() {
  local file=$(fd -t f -e "$1" | fzf --preview 'bat --color=always {}')
  [[ -n "$file" ]] && vim "$file"
}

# Usage: fv tsx

. Integration mit ripgrep

# Finde Files, dann suche Content
fd -e js | xargs rg "TODO"

# Als Function
search_in() {
  local ext=$1
  shift
  fd -e "$ext" -0 | xargs -0 rg "$@"
}

# Usage: search_in js "function"
⚠️ Warnung: Bei fd -0 | xargs -0 rm werden Dateien unwiderruflich geloescht. Fuehre immer zuerst einen Trockenlauf ohne rm aus, um die betroffenen Dateien zu pruefen.

. Batch-Operations mit xargs

fd mit xargs kombiniert ermoeglicht Massenoperationen auf gefundenen Dateien. Nutze -0 fuer sichere Verarbeitung von Dateinamen mit Sonderzeichen:

# Alle .log Files älter als 7 Tage löschen
fd -e log --changed-before 7d -0 | xargs -0 rm

# Alle .js Files nach .bak kopieren
fd -e js -0 | xargs -0 -I {} cp {} {}.bak

# Permissions setzen
fd -t x -0 | xargs -0 chmod +x

. Ignore-File für Projekte

Eine .fdignore-Datei im Projekt-Root definiert Verzeichnisse und Dateien, die fd immer ueberspringen soll:

# .fdignore im Project-Root
node_modules/
dist/
build/
.cache/
*.log
*.tmp
.DS_Store

Beispiele

. React Project: Alle Components finden

# Alle Component-Files
fd "Component\.(tsx|jsx)$"

# Gruppiert nach Directory
fd -t f "Component" -e tsx -e jsx --exec echo "Found: {}"

# Mit Stats
fd "Component" -e tsx | wc -l
echo "Total Components: $(fd "Component" -e tsx | wc -l)"

# Analysiere mit Claude
fd "Component" -e tsx | \
  head -10 | \
  xargs cat | \
  claude "Identify common patterns in these React components"

. Cleanup: Temporäre Files löschen

# Preview: Welche Files würden gelöscht?
fd -e tmp -e bak -e swp --changed-before 30d

# Count
echo "Files to delete: $(fd -e tmp -e bak -e swp --changed-before 30d | wc -l)"

# Mit User-Confirmation
fd -e tmp -e bak --changed-before 30d -0 | \
  xargs -0 -p rm

# Oder mit trash (sicherer)
fd -e tmp --changed-before 7d -0 | \
  xargs -0 trash

. Find Large Files (Disk-Space Audit)

# Top 10 größte Files
fd -t f -S +10m -x ls -lh {} | \
  sort -hrk5 | \
  head -10

# Als formatted Report
fd -t f -S +10m --exec stat -f "%z %N" {} | \
  sort -rn | \
  head -20 | \
  awk '{print $1/1024/1024 " MB\t" $2}'

# Finde große Log-Files
fd -e log -S +100m -x du -h {} | \
  sort -rh

. Find Duplicate File-Names

# Files mit gleichem Namen finden
fd -t f --base-path . | \
  sort | \
  uniq -d

# Mit Full-Path
fd | \
  rev | \
  cut -d/ -f1 | \
  rev | \
  sort | \
  uniq -d

# Gruppiert darstellen
fd | while read file; do
  basename "$file"
done | sort | uniq -c | sort -rn | head -20
💡 Tipp: Setze FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git' in deiner Shell-Config -- damit nutzen sowohl fzf als auch Ctrl+T automatisch fd statt find und sind deutlich schneller.

. Recent Changes (Git-Workflow)

# Geändert in letzten 2 Stunden
fd --changed-within 2h -t f

# Für Git Add
fd --changed-within 1h -e js -e ts -0 | \
  xargs -0 git add

# Review recent changes
fd --changed-within 24h | \
  xargs -I {} git diff {} | \
  claude "Summarize changes in last 24h"

. Test Coverage: Fehlende Test-Files

# Alle Source-Files
SOURCES=$(fd -e tsx src/ -E "*.test.tsx")

# Check für entsprechende Test-Files
echo "$SOURCES" | while read file; do
  test_file="${file%.tsx}.test.tsx"
  if [[ ! -f "$test_file" ]]; then
    echo "Missing test: $test_file"
  fi
done

# Als Function
check_test_coverage() {
  fd -e ts -e tsx src/ -E "*.test.*" | while read src; do
    test="${src%.*}.test.${src##*.}"
    [[ ! -f "$test" ]] && echo "❌ Missing: $test"
  done
}

. Config-Files Inventory

# Alle Config-Files finden
fd -I \
   -e json \
   -e yaml \
   -e yml \
   -e toml \
   -e ini \
   -e conf \
   -g "*config*"

# Als structured Report
{
  echo "# Configuration Files Inventory"
  echo ""
  echo "## JSON Configs"
  fd -e json -g "*config*"
  echo ""
  echo "## YAML Configs"
  fd -e yaml -e yml -g "*config*"
  echo ""
  echo "## Other Configs"
  fd -e toml -e ini
} > config-inventory.md

. Rename Pattern (Dry-Run)

# Preview: umbenennen *.jsx -> *.tsx
fd -e jsx | while read file; do
  new="${file%.jsx}.tsx"
  echo "Would rename: $file -> $new"
done

# Tatsächlich umbenennen (mit Bestätigung)
fd -e jsx | while read file; do
  new="${file%.jsx}.tsx"
  echo "Rename $file to $new? (y/n)"
  read answer
  [[ "$answer" == "y" ]] && mv "$file" "$new"
done

# Oder mit Backup
fd -e jsx -0 | xargs -0 -I {} sh -c 'mv {} {}.bak && mv {}.bak ${0%.jsx}.tsx' {}

. Generate File-Tree für Documentation

# Simple Tree
fd -t d | sed 's|[^/]*/|  |g'

# Als Markdown
{
  echo "# Project Structure"
  echo '`'
  fd -t d | sort | sed 's|[^/]*/|  |g'
  echo '`'
} > STRUCTURE.md

# Mit File-Counts
fd -t d | while read dir; do
  count=$(fd -t f "$dir" -d 1 | wc -l)
  echo "$dir: $count files"
done

. Security: Find Secrets

# Potenzielle Secret-Files
fd -I -H \
   -e env \
   -e key \
   -e pem \
   -e p12 \
   -e pfx \
   -g "*secret*" \
   -g "*password*" \
   -g "*credential*"

# Exclude Examples
fd -e env -E "*.example" -E "*.sample"

# Mit Content-Check
fd -e env -0 | \
  xargs -0 rg -i "password|secret|key" | \
  claude "Identify potential security risks"

Claude Code Integration

Workflow 1: Grosse Dateien finden

Uebermaessig grosse TypeScript-Dateien sind oft ein Zeichen fuer fehlende Modularisierung und sollten aufgeteilt werden. Dieser Befehl findet alle TypeScript-Dateien ueber 100 KB und zeigt ihre Groesse in menschenlesbarem Format an. Stell dir vor, du willst Claude Code beauftragen, grosse Dateien zu refactoren -- zuerst identifizierst du die Kandidaten mit fd. Die Kombination von Extension-Filter (-e) und Groessen-Filter (--size) macht die Suche sehr praezise. Das Ergebnis zeigt dir sofort, welche Dateien am dringendsten aufgeteilt werden sollten.

fd -e ts -e tsx --size +100k --exec ls -lh {}

Workflow 2: Verwaiste Test-Dateien aufspueren

Verwaiste Test-Dateien sind Tests, fuer die keine zugehoerige Source-Datei mehr existiert -- sie belasten die Test-Suite unnoetig und verursachen oft Verwirrung. Dieser Befehl findet alle Test-Dateien und prueft, ob die entsprechende Source-Datei existiert. Stell dir vor, du hast eine Komponente geloescht, aber die Test-Datei vergessen -- dieser Befehl deckt solche Waisen auf. Claude Code kann dir dann helfen, die verwaisten Tests entweder zu loeschen oder die fehlenden Source-Dateien wiederherzustellen. Fuehre diesen Check regelmaessig aus, um deine Test-Suite sauber zu halten.

fd "\.test\.(ts|tsx)$" --exec sh -c 'test -f "${0%.test.*}.${0##*.}" || echo "Kein Source: $0"'

Workflow 3: Projektstruktur bereinigen

Systemdateien wie .DS_Store (macOS), Thumbs.db (Windows) und .pyc-Kompilate (Python) verunreinigen das Repository und gehoeren nicht in die Versionskontrolle. Dieser Befehl findet und loescht all diese unerwuenschten Dateien in einem Durchlauf. Die Flags -H (Hidden) und -I (Ignore) stellen sicher, dass auch versteckte und normalerweise ignorierte Dateien gefunden werden. Stell dir vor, du klonst ein Repository eines Kollegen, der auf macOS arbeitet, und findest ueberall .DS_Store-Dateien -- mit diesem Befehl bereinigst du das Projekt in Sekunden. Fuege diese Dateipatterns auch in deine .gitignore ein, um kuenftige Verunreinigungen zu verhindern.

fd -H -I "\.DS_Store|Thumbs.db|*.pyc" --exec rm {}
💡 Tipp: Nutze fd um Claude Code die relevanten Dateien fuer eine Aufgabe zu zeigen.

Troubleshooting

Haeufige Probleme mit fd drehen sich meist um versteckte Dateien, Ignore-Regeln und Performance bei grossen Repositories.

Problem: fd findet Hidden Files nicht

fd ignoriert standardmaessig versteckte Dateien (die mit Punkt beginnen), da dies in den meisten Faellen gewuenscht ist.

Symptom: .env Files werden nicht gefunden

fd ".env"  # Findet nichts

Lösung: Hidden-Flag verwenden

# Explizit Hidden Files
fd -H ".env"

# Oder Global in Alias
alias fd='fd -H'

# Check ob File existiert
ls -la | grep ".env"

Problem: Ignored Files werden übersprungen

fd respektiert automatisch .gitignore-Regeln, was normalerweise gewuenscht ist, aber manchmal gezielt deaktiviert werden muss.

Symptom: node_modules wird nicht durchsucht

fd "package.json"  # Fehlt node_modules/

Lösung: Ignore deaktivieren

# .gitignore ignorieren
fd -I "package.json"

# Oder beides (Hidden + Ignored)
fd -HI "package.json"

# Spezifischer Pfad
fd "package.json" node_modules/

Problem: Zu viele Results

Zu allgemeine Suchbegriffe liefern unueberschaubar viele Ergebnisse, besonders in grossen Projekten.

Symptom: Tausende Matches bei generischem Pattern

fd "test"  # 10000+ Files

Lösung: Filtern und limitieren

# Nur bestimmte Extension
fd "test" -e js

# Depth limitieren
fd "test" -d 3

# Nur in spezifischem Directory
fd "test" src/

# First 10 Results
fd "test" | head -10

Problem: Performance bei sehr großen Repos

Bei sehr grossen Dateisystemen kann fd langsam werden, wenn es jedes Verzeichnis traversieren muss.

Symptom: fd langsam bei >100k Files

fd  # Dauert >5 Sekunden

Lösung: Optimierungen

# Depth limitieren
fd -d 3

# Exclude große Directories
fd -E node_modules -E .git

# Threading kontrollieren
fd --threads 4

# Nur spezifische Paths
fd src/ app/ lib/

Problem: Regex funktioniert nicht

fd nutzt standardmaessig Regex fuer Pattern-Matching, nicht Glob-Wildcards. Verwechslung der beiden Modi ist eine haeufige Fehlerquelle.

Symptom: Pattern matched nicht wie erwartet

fd "test-\d+"  # Findet nichts

Lösung: Glob vs. Regex Mode

# Glob-Mode (Standard) - nutzt Wildcards
fd -g "test-*"

# Regex-Mode - nutzt echte Regex
fd "test-\d+"  # Sollte funktionieren

# Full-Path Regex
fd -p "src/.*test"

# Check Escaping
fd "test-[0-9]+"

Problem: Symlinks werden nicht gefolgt

fd folgt standardmaessig keinen Symlinks, um unendliche Schleifen zu vermeiden.

Symptom: Linked Directories fehlen

fd "file"  # Folgt nicht Symlinks

Lösung: Follow-Flag

# Symlinks folgen
fd -L "file"

# Mit Hidden
fd -HL "config"

# Aber Vorsicht vor Cycles!
fd -L --max-depth 10

Vergleich: fd vs. Alternativen

| Feature | fd | find | locate | fzf |
|---------|----|----- |--------|-----|
| Performance | ⭐⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| Syntax | Intuitiv | Komplex | Einfach | Interaktiv |
| Smart Defaults | ✅ .gitignore | ❌ | ❌ | ⚠️ |
| Colored Output | ✅ | ❌ | ❌ | ✅ |
| Regex Support | ✅ Native | ✅ -regex | ❌ | ⚠️ Filter |
| Parallel Search | ✅ | ❌ | N/A | ❌ |
| Cross-Platform | ✅ | ✅ | ⚠️ Unix | ✅ |
| Real-Time | ✅ | ✅ | ❌ DB | ✅ |
| Size Filtering | ✅ | ✅ | ❌ | ❌ |
| Time-based | ✅ | ✅ -mtime | ⚠️ | ❌ |

Wann welches Tool?

fd:

find:

locate:

fzf:

Links & Ressourcen

Offizielle Dokumentation

Tutorials & Guides

Integration

Alternatives & Comparisons

Pro-Tipps

. fd als find-Replacement

Wenn du fd als direkten Ersatz fuer find nutzen willst, kannst du einen Alias erstellen, der den find-Befehl auf fd umleitet. Das ist besonders praktisch, wenn du aus Gewohnheit find tippst, aber die Vorteile von fd (Geschwindigkeit, Farben, .gitignore-Respekt) nutzen willst. Beachte, dass die Syntax von fd und find unterschiedlich ist -- ein einfacher Alias reicht fuer interaktive Nutzung, aber in Scripts solltest du weiterhin das Original verwenden. Stell dir vor, du tippst automatisch find . -name "*.js" -- mit dem Alias wird stattdessen fd aufgerufen, das deutlich schneller ist. Ein Symlink als Alternative wird nicht empfohlen, da er System-Scripts stoeren koennte.

# In ~/.bashrc oder ~/.zshrc
alias find='fd'
# Oder symlink
# ln -s $(which fd) /usr/local/bin/find

. Custom Ignore-Patterns

Eine globale .fdignore-Datei in deinem Home-Verzeichnis definiert Verzeichnisse und Dateien, die fd in jedem Projekt ueberspringen soll. Das ist nuetzlich fuer systemweite Ausschluesse wie .git, node_modules und Build-Verzeichnisse, die du nie durchsuchen willst. Stell dir vor, du arbeitest an verschiedenen Projekten mit unterschiedlichen Technologien, aber alle haben node_modules und .git -- mit einer globalen Ignore-Datei musst du diese Ausschluesse nicht in jedem Projekt neu definieren. Die Umgebungsvariable FD_IGNORE_FILE zeigt fd, wo die globale Ignore-Datei liegt. Projektspezifische Ignore-Patterns koennen zusaetzlich in einer .fdignore im Projekt-Root definiert werden.

# Global .fdignore in $HOME
cat > ~/.fdignore << 'EOF'
node_modules/
.git/
dist/
build/
*.log
*.tmp
.DS_Store
Thumbs.db
EOF

export FD_IGNORE_FILE="$HOME/.fdignore"

. Integration mit fzf für File-Navigation

Diese Kombination von fd und fzf ist eine der wichtigsten Konfigurationen fuer deinen Terminal-Workflow. fd liefert die schnelle, .gitignore-respektierende Dateiliste, und fzf macht sie interaktiv filterbar. Die drei Umgebungsvariablen konfigurieren fd als Backend fuer Ctrl+T (Dateisuche), Alt+C (Verzeichniswechsel) und die Standard-Dateiliste. Stell dir vor, du drueckst Ctrl+T und bekommst sofort eine blitzschnelle, interaktive Dateiauswahl mit bat-Vorschau -- das ist der Workflow, den diese Konfiguration ermoeglicht. Ohne fd als Backend waere fzf auf das langsame find angewiesen und wuerde auch Dateien in node_modules und .git anzeigen.

# ~/.bashrc / ~/.zshrc
export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"
export FZF_ALT_C_COMMAND='fd --type d --hidden --follow --exclude .git'

# Custom fzf-preview
export FZF_CTRL_T_OPTS="--preview 'bat --color=always --line-range :500 {}'"

. Powerful Functions

Diese drei Shell-Funktionen decken die haeufigsten interaktiven Dateioperationen ab: fe oeffnet eine Datei nach Fuzzy-Suche, fcd wechselt interaktiv in ein Verzeichnis, und recent zeigt kuerzlich geaenderte Dateien. Jede Funktion nutzt fzf mit einer Preview-Ansicht, damit du vor der Auswahl siehst, was du bekommst. Stell dir vor, du willst eine Datei oeffnen, die du heute bearbeitet hast, aber du erinnerst dich nicht an den genauen Namen -- recent 1d zeigt alle heute geaenderten Dateien mit bat-Vorschau. Die fcd-Funktion zeigt eine Baumansicht des Verzeichnisses, damit du weisst, wohin du wechselst.

# Quick-Edit: Finde und öffne File
fe() {
  local file=$(fd -t f | fzf --preview 'bat --color=always {}')
  [[ -n "$file" ]] && ${EDITOR:-vim} "$file"
}

# Directory-Jump mit fzf
fcd() {
  local dir=$(fd -t d | fzf --preview 'tree -L 1 {}')
  [[ -n "$dir" ]] && cd "$dir"
}

# Recent Files
recent() {
  fd --changed-within ${1:-1d} -t f | fzf --preview 'bat --color=always {}'
}

. Backup-Strategie

Diese Funktion erstellt automatische Backups aller wichtigen Konfigurationsdateien, die in den letzten 7 Tagen geaendert wurden. Sie nutzt fd mit Extension- und Zeitfilter, um nur relevante Dateien zu finden, und kopiert sie in ein datiertes Backup-Verzeichnis. Stell dir vor, du aenderst regelmaessig Config-Dateien und willst sichergehen, dass du im Notfall auf eine frueherer Version zurueckgreifen kannst -- diese Funktion laeuft als Cron-Job oder wird manuell vor groesseren Aenderungen ausgefuehrt. Das Ergebnis ist ein geordnetes Backup-Verzeichnis, sortiert nach Datum, mit allen relevanten Konfigurationen.

# Erstelle Backup von wichtigen Files
backup_important() {
  local backup_dir="$HOME/backups/$(date +%Y-%m-%d)"
  mkdir -p "$backup_dir"

  fd -e conf -e json -e yaml --changed-within 7d | \
    xargs -I {} cp {} "$backup_dir/"

  echo "Backed up to $backup_dir"
}

. Performance-Monitoring

Diese Funktion vergleicht die Ausfuehrungsgeschwindigkeit von fd und find fuer dieselbe Aufgabe. Das ist nuetzlich, um das Performanceverhaeltnis auf deinem System und in deinem konkreten Projekt zu messen. Stell dir vor, ein Kollege fragt, warum du fd statt find empfiehlst -- mit dieser Funktion kannst du den Geschwindigkeitsunterschied direkt demonstrieren. In den meisten Faellen ist fd 2-5x schneller als find, besonders bei grossen Verzeichnisbaeumen. Die Umleitung nach /dev/null stellt sicher, dass nur die Ausfuehrungszeit gemessen wird, nicht die Ausgabezeit.

# Benchmark fd vs. find
hyperbench() {
  echo "=== fd ===="
  time fd -e js > /dev/null

  echo ""
  echo "=== find ==="
  time find . -name "*.js" > /dev/null
}

. Smart-Excludes per Project-Type

Diese Funktion erstellt automatisch eine .fdignore-Datei mit den richtigen Exclude-Patterns basierend auf dem Projekttyp. Jeder Projekttyp hat seine eigenen Build-Verzeichnisse und generierte Dateien, die bei der Suche stoeren. Stell dir vor, du startest ein neues Python-Projekt -- statt manuell venv, __pycache__ und .pyc-Dateien auszuschliessen, fuehrst du setup_fd_ignores python aus und die .fdignore wird automatisch erstellt. Das sorgt dafuer, dass fd und fzf von Anfang an nur relevante Dateien anzeigen. Du kannst diese Funktion um weitere Projekttypen wie Java (target/), Go (vendor/) oder Ruby (bundle/) erweitern.

# Function: Setup fd für Project-Type
setup_fd_ignores() {
  case "$1" in
    node)
      echo "node_modules/" > .fdignore
      echo "dist/" >> .fdignore
      ;;
    python)
      echo "venv/" > .fdignore
      echo "__pycache__/" >> .fdignore
      echo "*.pyc" >> .fdignore
      ;;
    rust)
      echo "target/" > .fdignore
      echo "Cargo.lock" >> .fdignore
      ;;
  esac
  echo "Created .fdignore for $1 project"
}

# Usage: setup_fd_ignores node

Zusammenfassung

fd ist der moderne Standard für File-Finding und hat find für Development-Workflows praktisch ersetzt:

Kern-Vorteile:

✅ Intuitive Syntax Kein Memorieren komplexer Flags
✅ Geschwindigkeit 2-5x schneller durch Parallelisierung
✅ Smart Defaults .gitignore Respekt, Auto-Color
✅ Modern Regex, Unicode, Cross-Platform
✅ Integration Perfekt mit fzf, ripgrep, xargs

Typische Use Cases:

Ergänzt perfekt:

Nächste Schritte:

Bottom Line: fd macht File-Finding einfach, schnell und intuitiv. Zero-Config, sofortige Produktivität, perfekt für moderne Workflows.

Weiter zu: [15. tig - Git Browser](./15-tig.md) Zurück zu: [13. ripgrep - Code-Suche](./13-ripgrep.md) Übersicht: [Tools & Extensions](../TOOLS-EXTENSIONS-INDEX.md)