3 Fragen zu Pipe

Ja, unter Unix kannst du mit Pipes (`|`) und Umleitungen (`<`, `>`) Datenströme zwischen Prozessen flexibel verbinden. Wenn du „vor den systemeigenen Schreibbefehl“ und „hinter dem eigenen Read-Befehl“ etwas dazwischenschalten möchtest, kannst du Filterprogramme oder eigene Skripte in die Pipeline einbauen. **Beispiel:** Angenommen, du hast ein Programm `prog`, das von der Standardeingabe liest und auf die Standardausgabe schreibt. Du möchtest vor dem Schreiben von `prog` noch ein Filterprogramm (z.B. `sed`) und nach dem Lesen ein weiteres (z.B. `awk`) dazwischenschalten. ```sh echo "Text" | sed 's/Text/Neuer Text/' | prog | awk '{print toupper($0)}' ``` Hier passiert Folgendes: - `echo "Text"` erzeugt die Eingabe. - `sed 's/Text/Neuer Text/'` verändert die Eingabe, **bevor** sie an `prog` geht. - `prog` liest die veränderte Eingabe. - Die Ausgabe von `prog` wird von `awk` weiterverarbeitet, **nachdem** sie von `prog` geschrieben wurde. **Allgemein:** - Alles, was du **vor** dem Programm in die Pipe schreibst, beeinflusst die Eingabe (Read). - Alles, was du **nach** dem Programm in die Pipe schreibst, beeinflusst die Ausgabe (Write). **Weitere Möglichkeiten:** - Mit `tee` kannst du Datenströme aufteilen oder mitschneiden. - Mit Prozesssubstitution (`<(...)` und `>(...)`) kannst du komplexere Datenflüsse bauen. **Fazit:** Du kannst beliebige Programme oder Filter vor und nach deinem eigenen Programm in eine Pipe einbauen, um die Datenströme zu manipulieren. Das ist ein zentrales Konzept in Unix-Systemen. Weitere Infos: - [Pipes und Umleitungen in der Bash](https://wiki.ubuntuusers.de/Shell/Pipe/) - [GNU Bash Manual: Redirections](https://www.gnu.org/software/bash/manual/html_node/Redirections.html)

Um den systemeigenen Befehl `write` (vermutlich meinst du den Unix-Befehl `write` oder einen ähnlichen Befehl zum Schreiben auf die Konsole oder in eine Datei) so zu verändern, dass er immer erst eine Pipe durchläuft, müsstest du das Verhalten des Befehls anpassen. Standardmäßig schreibt `write` direkt auf das Ziel (z.B. ein Terminal oder eine Datei), ohne eine Pipe zu verwenden. **Eine direkte Änderung des systemeigenen Befehls ist nicht vorgesehen**. Du kannst aber das gewünschte Verhalten durch ein Wrapper-Skript oder eine Alias-Lösung erreichen. ### Beispiel mit einem Wrapper-Skript Angenommen, du möchtest, dass alles, was an `write` gesendet wird, erst durch eine Pipe (z.B. durch `cat` oder ein anderes Programm) läuft, könntest du ein Skript wie folgt erstellen: ```bash #!/bin/bash # Speichere dieses Skript als "mywrite" und mache es ausführbar cat | write "$@" ``` Jetzt kannst du anstelle von `write` immer `mywrite` verwenden und alles, was du an `mywrite` sendest, läuft durch die Pipe. ### Beispiel mit einem Alias Du könntest auch einen Alias in deiner Shell setzen: ```bash alias write='cat | /usr/bin/write' ``` Beachte: Das funktioniert nur, wenn du `write` so aufrufst, dass es von einer Pipe liest, z.B.: ```bash echo "Hallo" | write user ``` ### Systemweite Änderung Eine systemweite Änderung des Befehls selbst (z.B. durch Ersetzen der Binärdatei) ist **nicht empfohlen** und kann zu Problemen führen. Stattdessen ist die Nutzung eines Wrappers oder Aliases der übliche Weg. ### Zusammenfassung - Der systemeigene Befehl kann nicht direkt so verändert werden, dass er immer durch eine Pipe läuft. - Nutze stattdessen ein Wrapper-Skript oder einen Alias, um das gewünschte Verhalten zu erreichen. Weitere Informationen zu Pipes und Shell-Skripten findest du z.B. auf [tldp.org](https://tldp.org/LDP/abs/html/pipes.html).

Is there a cold water pipe in the shaft?