====== CLI Prompt: Eingabe, Ausgabe und Fehlerbehandlung ======

Die Kommandozeile (CLI - Command Line Interface) arbeitet mit drei Standard-Datenströmen: Eingabe (stdin), Ausgabe (stdout) und Fehlerausgabe (stderr). Das Verständnis dieser Konzepte ist fundamental für effektive Arbeit mit der Shell.

===== Voraussetzungen =====
  * Zugriff auf die Linux-Kommandozeile
  * Grundkenntnisse in [[sammlung:bash_kommandos|Bash-Kommandos]]

===== Der Prompt =====

Der Prompt zeigt an, dass die Shell bereit für Eingaben ist.

==== Typische Prompts ====
<code bash>
# Standard-User
user@hostname:~$

# Root-User
root@hostname:~#

# Mit Pfad
user@hostname:/var/log$

# Nur Pfad
~/documents$
</code>

==== Prompt-Bestandteile ====
^ Symbol ^ Bedeutung ^
| $ | Normaler Benutzer |
| # | Root-Benutzer (Administrator) |
| ~ | Home-Verzeichnis |
| / | Root-Verzeichnis |
| @ | Trennt Benutzer und Hostname |

===== Die drei Standard-Datenströme =====

^ Name ^ Beschreibung ^ Dateideskriptor ^ Symbol ^
| **stdin** | Standard-Eingabe (Tastatur) | 0 | < |
| **stdout** | Standard-Ausgabe (Bildschirm) | 1 | > |
| **stderr** | Fehler-Ausgabe (Bildschirm) | 2 | 2> |

==== Visualisierung ====
<code>
Tastatur → stdin (0) → Programm → stdout (1) → Bildschirm
                                 ↘ stderr (2) → Bildschirm
</code>

===== Ausgabe-Umleitung (Output Redirection) =====

==== Stdout umleiten ====
<code bash>
# Ausgabe in Datei schreiben (überschreibt)
ls -l > dateiliste.txt

# An Datei anhängen
echo "Neue Zeile" >> logfile.txt

# Ausgabe verwerfen
command > /dev/null

# Beispiele
date > datum.txt
cat file1.txt file2.txt > zusammen.txt
echo "Hallo Welt" > greeting.txt
</code>

==== Stderr umleiten ====
<code bash>
# Nur Fehler in Datei
command 2> fehler.log

# Fehler verwerfen
command 2> /dev/null

# Beispiel: Nur Fehler anzeigen
find / -name "*.conf" 2> /dev/null

# Fehler an Datei anhängen
command 2>> fehler.log
</code>

==== Stdout und Stderr kombinieren ====
<code bash>
# Beide in dieselbe Datei (moderne Syntax)
command &> alles.log
command > alles.log 2>&1  # Alternative

# Beide anhängen
command &>> alles.log

# Stdout in Datei, Stderr auf Bildschirm
command > ausgabe.txt

# Stdout auf Bildschirm, Stderr in Datei
command 2> fehler.txt

# Beide getrennt
command > ausgabe.txt 2> fehler.txt

# Stdout in Datei, Stderr verwerfen
command > ausgabe.txt 2> /dev/null
</code>

===== Eingabe-Umleitung (Input Redirection) =====

==== Stdin umleiten ====
<code bash>
# Eingabe aus Datei lesen
command < eingabe.txt

# Beispiele
wc -l < datei.txt
mail user@example.com < email.txt
mysql -u root -p database < dump.sql
</code>

==== Here-Document (<<) ====
<code bash>
# Mehrzeilige Eingabe
cat << EOF > datei.txt
Zeile 1
Zeile 2
Zeile 3
EOF

# Mit Variablen
cat << EOF
Benutzer: $USER
Pfad: $PWD
EOF

# In Skript verwenden
mysql -u root -p << SQL
USE database;
SELECT * FROM users;
SQL
</code>

==== Here-String (<<<) ====
<code bash>
# Einzeilige String-Eingabe
command <<< "Text"

# Beispiele
wc -w <<< "Hallo Welt"
grep "error" <<< "$LOG_OUTPUT"
</code>

===== Pipes (|) =====

Pipes leiten die Ausgabe eines Befehls als Eingabe an den nächsten weiter.

==== Grundlegendes Piping ====
<code bash>
# Einfache Pipe
command1 | command2

# Beispiele
ls -l | grep "txt"
cat datei.txt | wc -l
ps aux | grep "apache"
</code>

==== Mehrfache Pipes ====
<code bash>
# Pipe-Ketten
command1 | command2 | command3

# Beispiele
cat access.log | grep "404" | wc -l
ps aux | grep "apache" | awk '{print $2}'
ls -la | grep "^d" | sort -k5 -rn | head -10

# Sortieren, Duplikate entfernen, zählen
cat liste.txt | sort | uniq | wc -l
</code>

==== Pipe mit Umleitung kombinieren ====
<code bash>
# Pipe und Ausgabe in Datei
command1 | command2 > ergebnis.txt

# Pipe und Fehler in Datei
command1 2>&1 | grep "error" > fehler.txt

# Mehrfach speichern mit tee
command | tee ausgabe.txt | grep "wichtig"
</code>

===== tee - Ausgabe duplizieren =====

<code bash>
# Ausgabe auf Bildschirm UND in Datei
command | tee datei.txt

# An Datei anhängen
command | tee -a datei.txt

# In mehrere Dateien
command | tee datei1.txt datei2.txt

# Beispiele
echo "Test" | tee log.txt
ls -la | tee verzeichnis.txt
make 2>&1 | tee build.log
</code>

===== Praktische Beispiele =====

==== Log-Analyse ====
<code bash>
# Fehler in Logdatei finden
grep "ERROR" /var/log/syslog > fehler.txt

# Fehler zählen
grep "ERROR" /var/log/syslog | wc -l

# Nach Datum filtern
grep "2024-01-15" /var/log/syslog | grep "ERROR" > heute-fehler.txt

# Nur eindeutige Fehler
grep "ERROR" /var/log/syslog | sort | uniq > eindeutige-fehler.txt
</code>

==== Prozess-Verwaltung ====
<code bash>
# Prozesse filtern und PIDs extrahieren
ps aux | grep "apache" | awk '{print $2}'

# Prozess-IDs in Datei
ps aux | grep "apache" | awk '{print $2}' > apache-pids.txt

# Speichernutzung der Top-10 Prozesse
ps aux --sort=-%mem | head -11 | tee top-memory.txt
</code>

==== Dateiverwaltung ====
<code bash>
# Große Dateien finden
find /home -type f -size +100M 2> /dev/null | tee grosse-dateien.txt

# Dateien zählen nach Typ
find . -type f | sed 's/.*\.//' | sort | uniq -c | sort -rn

# Backup mit Log
tar -czf backup.tar.gz /data 2>&1 | tee backup.log
</code>

==== System-Informationen sammeln ====
<code bash>
# System-Report erstellen
{
    echo "=== Hostname ==="
    hostname
    echo "=== Datum ==="
    date
    echo "=== Uptime ==="
    uptime
    echo "=== Disk Usage ==="
    df -h
    echo "=== Memory ==="
    free -h
} > system-report.txt
</code>

===== Fehlerbehandlung in Skripten =====

==== Exit-Codes ====
<code bash>
# Exit-Code des letzten Befehls
echo $?

# 0 = Erfolg, alles andere = Fehler
command
if [ $? -eq 0 ]; then
    echo "Erfolgreich"
else
    echo "Fehler aufgetreten"
fi

# Kurzform mit && und ||
command && echo "Erfolg" || echo "Fehler"
</code>

==== Fehlerbehandlung ====
<code bash>
# Bei Fehler abbrechen
set -e
command1
command2  # Stoppt hier wenn command1 fehlschlägt

# Fehler protokollieren
command 2>&1 | tee -a error.log

# Nur bei Erfolg weiter
command1 && command2 && command3

# Bei Fehler Alternative
command1 || command2
</code>

===== Nützliche Kombinationen =====

==== Statistiken erstellen ====
<code bash>
# Top 10 häufigste Befehle
history | awk '{print $2}' | sort | uniq -c | sort -rn | head -10

# Zugriffe pro IP
cat access.log | awk '{print $1}' | sort | uniq -c | sort -rn

# Dateigrößen summieren
find . -type f | xargs du -ch | tail -1
</code>

==== Live-Monitoring ====
<code bash>
# Log live verfolgen und filtern
tail -f /var/log/syslog | grep --line-buffered "ERROR"

# Mit Zeitstempel
tail -f /var/log/app.log | while read line; do
    echo "$(date '+%H:%M:%S') $line"
done
</code>

==== Batch-Verarbeitung ====
<code bash>
# Alle Dateien verarbeiten
find . -name "*.txt" | while read file; do
    wc -l "$file"
done > zeilen-anzahl.txt

# Mit Fehlerprotokoll
find . -name "*.jpg" -exec convert {} -resize 50% {}.small \; 2> convert-errors.log
</code>

===== Spezielle Umleitungen =====

==== File Descriptors ====
<code bash>
# Eigene File Descriptors
exec 3> custom.log
echo "Nachricht" >&3
exec 3>&-  # Schließen

# Beide Streams tauschen
command 3>&1 1>&2 2>&3
</code>

==== Process Substitution ====
<code bash>
# Ausgabe als Datei behandeln
diff <(command1) <(command2)

# Beispiele
diff <(ls dir1) <(ls dir2)
comm -12 <(sort file1.txt) <(sort file2.txt)
</code>

===== Best Practices =====

  * **Fehler nicht verbergen**: ''2> /dev/null'' nur wenn wirklich nötig
  * **Logs mit Zeitstempel**: Immer Datum/Zeit bei wichtigen Logs
  * **Exit-Codes prüfen**: In Skripten immer Erfolg/Fehler behandeln
  * **tee für wichtige Ausgaben**: Gleichzeitig anzeigen und speichern
  * **Pipes statt temporäre Dateien**: Effizienter und sauberer
  * **Fehler in separate Datei**: ''command > output.log 2> error.log''

===== Siehe auch =====
  * [[sammlung:bash_kommandos|Bash Kommandos]]
  * [[sammlung:grep|grep - Text durchsuchen]]
  * [[sammlung:bash_profile_bashrc|Shell-Konfiguration]]
  * [[sammlung:cat_less_more_head_tail|Dateien anzeigen]]

{{tag>linux bash shell io redirection pipe stdin stdout stderr}}