Linux-Cat-Befehl: Bedeutung und Anwendung

Der Linux-Cat-Befehl ist einer der am häufigsten genutzten Linux-Befehle. Er wird meist dazu verwendet, den Inhalt einer Datei auf der Kommandozeile auszugeben. Es gibt jedoch eine Reihe weiterer Einsatzzwecke, die wir in diesem Artikel besprechen.

Was ist der Linux-Cat-Befehl?

Trotz des Namens hat der Linux-Cat-Befehl nichts mit Katzen zu tun. In der Tat macht der Befehl etwas ganz Profanes: Der Linux-Cat-Befehl liest Inhalte von Dateien und gibt diese auf der Kommandozeile aus. Der Ursprung des Namens stammt vom Begriff „Konkatenieren“ – mehr dazu weiter unten.

Schauen wir uns das grundlegende Muster eines Aufrufs des Linux-Cat-Befehls an. Wie Sie sehen, schreiben wir zunächst 'cat', ggf. gefolgt von Optionen, und anschließend den oder die Namen bzw. Pfade der auszugebenden Datei(en):

cat [Optionen] <dateiname(n)>

Der Linux-Cat-Befehl ist Teil der „GNU Core Utilities“ (Coreutils). Dabei handelt es sich um eine Sammlung grundlegender Kommandozeilen-Befehle. Die Coreutils sind „Free and Open Source Software“ (FOSS) und in so gut wie allen Linux-Distributionen vorhanden. Ferner steht der Linux-Cat-Befehl unter macOS sowie unter Windows bei Einsatz des „Windows Subsystem for Linux“ (WSL/WSL2) zur Verfügung.

Tipp

Um festzustellen, ob der Linux-Cat-Befehl auf Ihrem System verfügbar ist, gehen Sie wie folgt vor: Öffnen Sie eine Kommandozeile und führen Sie dort den Befehl 'which cat' aus. Ist der Linux-Cat-Befehl auf Ihrem System vorhanden, wird Ihnen der Pfad der cat-Binärdatei (z. B. '/bin/cat') angezeigt. Sollte eine Fehlermeldung angezeigt werden, ist der Linux-Cat-Befehl auf Ihrem System nicht verfügbar.

Optionen des Linux-Cat-Befehls

Wie die meisten Linux-Kommandozeilen-Befehle wird der Cat-Befehl beim Aufruf über optionale Parameter gesteuert. Diese Optionen folgen dem Namen des Befehls. Dabei ist zu beachten, dass zwischen Groß- und Kleinschreibung unterschieden wird. Für gewöhnlich gibt es für die meisten Optionen zwei Schreibweisen:

  1. Kurzform: -, z. B. 'cmd -h'

Die Kurzform ist wenig aussagekräftig. Dafür lassen sich mehrere Optionen zu einer kombinieren, z. B. 'ls -la' anstatt 'ls -l -a'. Gut geeignet ist die Kurzform für das schnelle Arbeiten mit bekannten Befehlen auf der Kommandozeile.

  1. Langform: --, z. B. 'cmd --help'

Die Langform ist leicht verständlich, benötigt jedoch mehr Zeit zu tippen und nimmt mehr Platz ein. Gut geeignet ist die Langform für das Erstellen von Skripten. Die aussagekräftigen Options-Namen dienen der Dokumentation.

Schauen wir uns die wichtigsten Optionen des Linux-Cat-Befehls an:

Option Erklärung
-h, --help Hilfe des Linux-Cat-Befehls anzeigen
-n Zeilen der Ausgabe nummerieren
-s mehrere Leerzeilen zu einer zusammenfassen
-b alle Zeilen der Ausgabe bis auf Leerzeilen nummerieren
-v unsichtbare Zeichen ausgeben
-e wie -v, inklusive Zeilenend-Marker
-t wie -v, inklusive Tab-Marker
-et Kombination von -e und -t; alle unsichtbaren Zeichen ausgeben

Was bedeutet eigentlich Konkatenieren?

Der Name des Linux-Cat-Befehls stammt von „Konkatenieren“, seinerseits abgeleitet vom lateinischen Begriff „catena“ für Kette. Das Konkatenieren ist ein wichtiges Konzept in der Informatik. Der Begriff beschreibt das Verketten, Aneinanderreihen oder Zusammenfügen von Elementen gleichartiger Container-Datenstrukturen. Insbesondere lassen sich in den meisten Sprachen mehrere Arrays oder Strings zu einem Array oder String zusammenfassen. Dabei werden die einzelnen Elemente der konkatenierten Container unter Beibehaltung der Reihenfolge in einem neuen Container zusammengefasst.

Ein simples Beispiel in Pseudocode – wir übergeben der cat-Funktion mehrere Strings, die zu einem einzigen String kombiniert werden:

cat("Peter ", "und ", "Paul") -> "Peter und Paul"

Der Linux-Cat-Befehl macht konzeptuell dasselbe: Als Elemente verarbeitet er innerhalb von Dateien gruppierte Zeilen.

Unterschiedliche Programmiersprachen nutzen verschiedene Symbole für den String-Konkatenierungs-Operator. Schauen wir uns ein paar Beispiele beliebter Programmiersprachen an. In allen Fällen ist das Ergebnis der Konkatenation der String "Peter und Paul":

Operator Sprache(n) Beispiel
+ Java, JavaScript, Python "Peter " + "und" + " Paul"
. PHP, Perl "Peter " . "und" . " Paul"
.. Lua "Peter " .. "und" .. " Paul"
~ Twig "Peter " ~ "und" ~ " Paul"
& VisualBasic "Peter " & "und" & " Paul"

Bei manchen Sprachen, insbesondere Python, kommt derselbe Operator für die Konkatenierung anderer Container-Datenstrukturen wie Listen zum Einsatz:

# Listen konkatenieren
[1, 2, 3] + [45, 56, 67]
# -> [1, 2, 3, 45, 56, 67]
# wohlgemerkt NICHT:
# [[1, 2, 3], [45, 56, 67]]
# Tupel konkatenieren
(1, 2) + (33, 44)
# -> (1, 2, 33, 44)

Interessant ist die Statistik-Sprache „R“ – sie kennt keinen Konkatenierungs-Operator. Stattdessen kommt die Funktion 'c()' zum Einsatz. Dreimal dürfen Sie raten, wofür das „c“ steht – richtig: „concatenate“. Hier dargestellt die verschachtelte Konkatenierung mehrerer Werte:

c(c(1, 2, 3), c(45, 56, 67))
# -> 1, 2, 3, 45, 56, 67

Wie wird der Linux-Cat-Befehl in der Praxis eingesetzt?

Der eigentliche Nutzen des Linux-Cat-Befehls ist limitiert. Dies folgt der UNIX-Philosophie „do one thing, and do it well“. Die meisten Einsatzszenarien ergeben sich aus dem Verketten des Befehls mit anderen Befehlen. Dabei kommen Umleitungen der Standard-Ein- und -Ausgabe zum Einsatz. Spezifisch handelt es sich um sogenannte Pipes und Redirects. Diese werden von der Shell bereitgestellt; ihr Einsatz erstreckt sich über alle Befehle hinweg:

Umleitung Symbol Einsatz Erklärung
Pipe | cmd1 | cmd2 Ausgabe des Befehls cmd1 an Eingabe des Befehls cmd2 weiterleiten
Input-Redirect < cmd < data Eingabe an Befehl cmd aus Datei data lesen
Output-Redirect > cmd > data Ausgabe des Befehls cmd in Datei data schreiben; ggf. existierende Datei wird überschrieben
Output-Redirect >> cmd >> data Ausgabe des Befehls cmd in Datei data schreiben; ggf. existierende Datei wird erweitert

Der Linux-Cat-Befehl wird häufig mit einer Reihe weiterer Linux-Befehle eingesetzt. Schauen wir uns einige der gebräuchlichsten an:

Linux-Befehl Erklärung
split eine Datei in Stücke spalten; Operation lässt sich mit cat umdrehen
uniq mehr als einmal auftretende Zeilen der Eingabe entfernen
sort Zeilen der Eingabe alphanumerisch sortieren
head, tail Ausgabe auf Zeilen am Anfang/Ende begrenzen

Gehen wir nun über zu üblichen Einsatzszenarien des Linux-Cat-Befehls.

Mit dem Linux-Cat-Befehl Dateien auf der Kommandozeile ausgeben

Der wohl häufigste Einsatz des Linux-Cat-Befehls besteht darin, den gesamten Inhalt einer Datei auf der Kommandozeile auszugeben. Dies ist nützlich, um schnell einen Blick in eine Datei zu werfen. Anders als beim Öffnen der Datei in einem Editor brauchen Sie dabei nicht befürchten, die Datei aus Versehen zu verändern. Hier ein Beispiel für das Ausgeben einer Datei auf der Kommandozeile:

cat ./path/to/file.txt

Schauen wir uns ein paar gebräuchliche Szenarien an. Stellen Sie sich vor, Sie sind per SSH auf einem Server eingeloggt, auf dem WordPress läuft. Sie befinden sich im WordPress-Stammverzeichnis und möchten den Inhalt der Konfigurationsdatei 'wp-config.php' anzeigen. Dann genügt der folgende Aufruf des Linux-Cat-Befehls:

cat wp-config.php

Oft genügt die Ausgabe einer Datei auf der Kommandozeile. In manchen Fällen möchten wir jedoch den Inhalt der Datei in die Zwischenablage kopieren. Ferner kann die sichtbare Ausgabe auf der Kommandozeile bei sensiblen Daten ein Risiko darstellen. In beiden Fällen bietet es sich an, die Ausgabe des Linux-Cat-Befehls an ein Programm weiterzuleiten, das die Daten in die Zwischenablage schreibt. Unter macOS gibt es für diesen Zweck das Kommandozeilen-Tool 'pbcopy'; unter Windows mit WSL/2 und den verschiedenen Linux-Distributionen stehen äquivalente Tools wie 'clip' bzw. 'xclip' zur Verfügung.

Betrachten wir folgendes Beispiel: Wir möchten zum Einrichten eines GitHub Repository unseren öffentlichen SSH-Schlüssel kopieren. Nehmen wir ferner an, dass sich der Schlüssel mit Namen 'id_rsa.pub' im Verzeichnis '.ssh/' in unserem Benutzerverzeichnis befindet. Dann gelingt uns der Trick unter macOS mit dem folgenden Aufruf des Linux-Cat-Befehls:

cat ~/.ssh/id_rsa.pub > pbcopy

Wie der Name des Linux-Cat-Befehls andeutet, lassen sich mehrere Dateien kombinieren und auf einmal ausgeben. Stellen wir uns vor, wir hätten Listen von Früchten, Gemüsen und Milchprodukten in drei Dateien im Verzeichnis 'food/' gespeichert. Mit dem folgenden Aufruf des Linux-Cat-Befehls kombinieren wir alle drei Listen zu einer einzigen und schreiben diese in die Datei 'food.txt':

cat ./food/fruit.txt ./food/veggies.txt ./food/dairy.txt > food.txt

Wie auf der Kommandozeile üblich, können wir den Platzhalter '*' verwenden, um alle Dateien eines Verzeichnisses auszuwählen:

cat ./food/*.txt > food.txt

Mit dem Linux-Cat-Befehl Text in eine Datei schreiben

Unter Nutzung der oben erwähnten Ausgabe-Umleitungen können Sie mit dem Linux-Cat-Befehl Text in eine Datei schreiben. Dies lässt sich auf dreierlei Weise nutzen:

  1. Eine neue Datei anlegen, in die der eingegebene Text geschrieben wird.
  2. Eine existierende Datei mit dem eingegebenen Text überschreiben.
  3. Den eingegebenen Text an eine existierende Datei anhängen.

Schauen wir uns die drei Szenarien an. Zunächst schreiben wir Text von der Kommandozeile in eine nicht existierende Datei:

  1. Linux-Cat-Befehl aufrufen und Ausgabe an eine nicht existierende Datei weiterleiten. Der Befehl nimmt Daten von der Standardeingabe entgegen, bis das Dateiende-Zeichen („End-of-file“, EOF) gelesen wird:
cat > new.txt
  1. Gewünschten Text auf der Kommandozeile eingeben.
  2. Die Eingabe durch Drücken der Tastenkombination [Ctrl] + [D] beenden. Diese Tastenkombination entspricht dem Dateiende-Zeichen.

Der eingegebene Text befindet sich nun in der Datei 'new.txt'. Wir überprüfen dies durch Aufruf des Befehls 'cat new.txt'.

Nutzen wir nun denselben Ansatz, um den eingegebenen Text an eine existierende Datei anzuhängen:

  1. Linux-Cat-Befehl aufrufen und Ausgabe an existierende Datei weiterleiten:
cat >> existing.txt
  1. Gewünschten Text auf der Kommandozeile eingeben.
  2. Die Eingabe durch Drücken der Tastenkombination [Ctrl] + [D] beenden.

Nutzen wir statt der Ausgabe-Weiterleitung '>>' das Symbol '>', wird die existierende Datei mit dem eingegebenen Text überschrieben. Vorsicht damit: Der vorherige Inhalt der Datei geht dabei unwiderruflich verloren!

Mit dem Linux-Cat-Befehl Daten für weitere Verarbeitung vorbereiten

Ein häufiger Einsatzzweck des Linux-Cat-Befehls besteht darin, Daten aus mehreren Dateien zu kombinieren. Oft werden die zusammengefassten Daten durch Filter geleitet, um sie für die weitere Verarbeitung vorzubereiten. Dieses Muster findet sich immer dann, wenn ähnliche Daten über mehrere Dateien verteilt vorliegen. Jede der Dateien enthält einen Eintrag pro Zeile. Denken Sie beispielsweise an Listen von Namen, IP-Adressen oder dergleichen.

Um eine Übersicht sämtlicher Ausprägungen der Daten zu bekommen, stellt sich folgende Aufgabe: Wir möchten alle Einträge kombinieren und dabei etwaige doppelte Einträge entfernen. Zuallerletzt sollen die Einträge sortiert und in eine neue Datei geschrieben werden. Stellen wir uns als konkretes Beispiel vor, wir hätten eine Menge von Textdateien. Jede Datei enthält die Namen der Akteure einer bestimmten Folge der Comic-Serie „Die Simpsons“. Wenn wir die Einträge aller Dateien wie beschrieben zusammenfassen, erhalten wir eine Liste aller Simpsons-Akteure.

Die in unserem Beispiel beschriebenen Dateien mit Simpsons-Akteuren der einzelnen Folgen sähen schematisch in etwa so aus:

simpsons-1.txt simpsons-2.txt simpsons-3.txt
Lisa Marge Homer Flanders Bart Lisa Homer Milhouse Bart Maggie Nelson

Nehmen wir ferner an, dass sich die einzelnen Textdateien im Verzeichnis 'simpsons/' befinden. Dann genügt der folgende Aufruf des Linux-Cat-Befehls, verkettet mit den Befehlen 'uniq' und 'sort', um die Liste aller Simpsons-Akteure in die Datei 'simpsons.txt' zu schreiben:

cat ./simpsons/*.txt | uniq | sort > simpsons.txt

Mit dem Linux-Cat-Befehl Zeilen einer Textdatei nummerieren

Ein gebräuchlicher Nutzen des Linux-Cat-Befehls besteht darin, die Zeilen einer Textdatei zu nummerieren. Stellen wir uns vor, wir hätten eine Textdatei mit Einträgen, je ein Eintrag pro Zeile. Nun möchten wir jeder Zeile die Zeilennummer voranstellen. Dies ist z. B. dann nützlich, wenn wir die resultierende Datei zur Durchsicht an eine andere Partei geben. So können beide Seiten sich in der Korrespondenz auf bestimmte Zeilen beziehen.

Mit dem Linux-Cat-Befehl geht das Nummerieren ganz einfach. Wir benutzen die '-n'-Option und eine Ausgabe-Umleitung:

cat -n doc.txt > doc.numbered.txt

Im beschriebenen Szenario kann es sinnvoll sein, alle Zeilen bis auf Leerzeilen zu nummerieren. Ferner fassen wir mehrere Leerzeilen zu einer einzigen zusammen. Dazu nutzen wir die Kombination der Optionen '-s' und '-b':

cat -sb doc.txt > doc.numbered.txt

Mit dem Linux-Cat-Befehl Template-Dateien kombinieren

Ein bekanntes Muster aus der Webprogrammierung besteht darin, Dokumente aus Versatzstücken zusammenzusetzen. Aus der Kombination der sogenannten Template-Parts mit einzigartigen Teilen ergeben sich vielfältige Dokumente mit konsistenter Struktur. Normalerweise nutzt man dafür PHP mit der 'include'-Anweisung oder eine spezielle Template-Sprache wie Twig. Dasselbe Prinzip lässt sich aber auch mit dem Linux-Cat-Befehl umsetzen.

Stellen wir uns vor, wir hätten mehrere Template-Parts im Verzeichnis 'parts/'. Bei allen erzeugten Dokumenten sollen Kopf- und Fußzeile identisch sein. Struktur und Inhalt der Kopf- und Fußzeile sind in den Dateien 'header.html' und 'footer.html' definiert. Ferner liegen mehrere Dateien mit den eigentlichen Inhalten der Dokumente im Verzeichnis 'main/' vor. Die fertigen Dokumente werden im Ausgabeverzeichnis 'www/' gespeichert. Zum Erzeugen eines Dokuments genügt der folgende Aufruf des Linux-Cat-Befehls:

cat ./parts/header.html ./main/home.html ./parts/footer.html > ./www/index.html

Ein weiteres Einsatzszenario: Eine Codebase soll zur Veröffentlichung mit einem Lizenz-Text versehen werden. Dabei soll die Lizenz am Anfang jeder Code-Datei eingefügt werden. Stellen wir uns das folgende Verzeichnis-Layout vor:

  • Python Quelltext-Dateien mit Endung '.py' im Verzeichnis 'src/'
  • eine Lizenzdatei 'license.py' im Verzeichnis 'inc/'
  • ein anfangs leeres Verzeichnis 'dist/' zur Ablage der verarbeiteten Dateien

Wir nutzen den Linux-Cat-Befehl innerhalb einer for-Schleife. Bei jedem Durchlauf des Schleifenkörpers wird dieselbe Lizenzdatei mit einer der Quelltext-Datei konkateniert. Das Ergebnis wird in eine neue Quelltext-Datei mit selbem Namen geschrieben:

for file in ./src/*.py ; do
    cat ./inc/license.py "$file" > "./dist/${file}"
done

Mit dem Linux-Cat-Befehl gespaltene Dateien zusammenfügen

Meist wird der Linux-Cat-Befehl für die Verarbeitung von Plain-Text-Dateien genutzt. Jedoch funktioniert der Befehl auch mit Binärdateien. Dies ist in einigen Szenarien nützlich. Zum einen lassen sich mit den Linux-Befehlen 'split' bzw. 'csplit' in mehrere Teile zerlegte Dateien wieder zusammenfügen. Wir zeigen hier den generellen Ansatz:

# Dateiname der zu zerlegenden Datei
file_name="./path/to/file"
# wir geben die Dateiendung explizit an, um diese nach dem Zusammenfügen anzuhängen
extension="txt"
# Original-Datei in 10-Kilobyte große Stücke mit Prefix 'part_' zerlegen
split -b 10k "${file_name}.${extension}" part_
# einzelne Stücke zu einer neuen Datei zusammenfügen
cat part_* > combined
# ursprüngliche Dateiendung wiederherstellen
mv combined "combined.${extension}"

Zum anderen bietet sich der Linux-Cat-Befehl an, um partielle Downloads zu kombinieren. Viele Tools können Downloads unterbrechen und später fortsetzen. Dies lohnt sich insbesondere beim Download einer großen Datei über eine schwache Netzwerkverbindung. Probieren Sie das Beispiel ruhig auf dem eigenen System aus:

# Test-Ordner auf dem Desktop anlegen
mkdir ~/Desktop/cat-test/
# in den Test-Ordner wechseln
cd ~/Desktop/cat-test/
# gemeinfreies Katzen-Bild von WikiMedia
image=https://upload.wikimedia.org/wikipedia/commons/f/fa/Cat_using_computer.jpg
# Bild mit 'curl' in zwei Teilen herunterladen
curl -s -r 0-500000 "$image" -o first-half &
curl -s -r 500001- "$image" -o second-half &
wait
# Teile kombinieren und in JPEG-Datei schreiben
cat first-half second-half > image.jpg

Mit dem Linux-Cat-Befehl Datenströme kombinieren

Der Linux-Cat-Befehl lässt sich nutzen, um in der Videoverarbeitung Datenströme zu kombinieren. Wir zeigen hier das generelle Muster. Zunächst erzeugen wir mit dem ffmpeg-Befehl aus einem JPEG-Bild mehrere kurze Videostreams. Im Anschluss kombinieren wir diese zu einem durchgängigen Video:

# vom Bild eine Schleife erzeugen
ffmpeg -y -loop 1 -i image.jpg -t 3 \
    -c:v libx264 -vf scale=w=800:h=-1 \
    still.ts
# vom Bild eine Aufblende erzeugen
ffmpeg -y -loop 1 -i image.jpg -t 3 \
    -c:v libx264 -vf scale=w=800:h=-1,fade=in:0:75 \
    fadein.ts
# vom Bild eine Abblende erzeugen
ffmpeg -y -loop 1 -i image.jpg -t 3 \
    -c:v libx264 -vf scale=w=800:h=-1,fade=out:0:75 \
    fadeout.ts
# Aufblende, Schleife und Abblende kombinieren
cat fadein.ts still.ts fadeout.ts > video.ts

Wann sollte man den Linux-Cat-Befehl nicht benutzen?

Die unnötige Nutzung des Linux-Cat-Befehls ist ein bekanntes „Anti-Pattern“. Dieses wird in zahlreichen Artikel beschrieben; es gibt sogar einen „Useless Use of Cat Award“. Als goldene Regel gilt: Der Linux-Cat-Befehl sollte dann genutzt werden, wenn es darum geht, mehrere Dateien zu kombinieren. Möchte man eine einzelne Datei verarbeiten, geht dies meist auch ohne cat.

Schauen wir uns den generellen Ansatz an, mit dessen Hilfe wir die überflüssige Nutzung des Linux-Cat-Befehls minimieren können. In Forenbeiträgen und Blogartikeln findet sich oft das folgende Muster:

cat example.txt | less

Der Linux-Cat-Befehl wird aufgerufen, um eine einzelne Datei auszulesen. Die Ausgabe wird per Pipe-Umleitung an den less-Befehl weitergegeben, um den Inhalt der Datei Seitenweise anzuzeigen. Jedoch geht das auch einfacher:

less < example.txt

Wir rufen den less-Befehl auf und nutzen die Eingabe-Umleitung der Shell, um die Datei einzulesen. Und selbst dieser Ansatz lässt sich noch weiter vereinfachen:

less example.txt

Anstatt eine Eingabe-Umleitung zu nutzen, übergeben wir dem less-Befehl die zu verarbeitende Datei. Denn fast alle Linux-Befehle nehmen den oder die Dateinamen als Parameter entgegen.

Welche Alternativen zum Linux-Cat-Befehl gibt es?

Wie oben beschrieben, wird der Linux-Cat-Befehl oft unnötigerweise eingesetzt. Für einige der häufigsten Einsatzszenarien existieren Alternativen. Drei Exemplare zeigen wir hier:

Befehl Alternativer Nutzen Beispiel
less / more Datei-Inhalt seitenweise auf Kommandozeile ausgeben less file.txt, more file.txt
touch Neue, leere Datei anlegen touch new.txt
echo Text in Datei schreiben echo "Text" > file.txt

Welche dem Linux-Cat-Befehl ähnlichen Befehle gibt es?

Es gibt eine Reihe von Linux-Befehlen, die dem cat-Befehl ähnlich sind. Als kleiner Insider-Scherz sind die Namen dieser Befehle oft an cat angelehnt. Zunächst gibt es den tac-Befehl, dessen Name einfach cat umgedreht ist. Und so funktioniert der tac-Befehl auch: wie der Linux-Cat-Befehl, nurmit umgekehrter Ausgabe. Beim Aufruf des tac-Befehls mit einer einzelnen Datei wird also zuerst die letzte Zeile ausgegeben, anstatt wie bei cat die erste.

Ein weiterer Befehl mit Namensähnlichkeit zum Linux-Cat-Befehl ist der nc-Befehl, abgekürzt für „Netcat“. Der Befehl wird oft als „Schweizer Taschenmesser für TCP/IP“ bezeichnet. Anstatt wie cat auf lokalen Dateien zu operieren, liest und schreibt Netcat Daten über Netzwerkverbindungen. Mehr erfahren Sie in unserem Artikel zum Thema.

Als neuere Alternative zum Linux-Cat-Befehl ist der bat-Befehl hinzugekommen. Auf der GitHub-Seite des Befehls wird dieser als „ein cat-Klon mit Flügeln“ („A cat clone with wings“) bezeichnet. Der bat-Befehl behält die prinzipielle Funktionsweise des Linux-Cat-Befehls bei, liefert allerdings einige Komfort-Funktionen. Insbesondere wird die Ausgabe von Quelltext-Dateien durch den bat-Befehl mit Syntax-Highlighting versehen.

War dieser Artikel hilfreich?