# Linux-Head-Befehl Der Linux-Head-Befehl gehört wie auch der [Linux-Tail-Befehl](https://www.ionos.at/digitalguide/server/konfiguration/linux-tail-befehl/ "Linux-Tail-Befehl") zu den essenziellen Werkzeugen auf der Kommandozeile. In erster Linie dient der Befehl dazu, den **Anfang einer (Text)-Datei auszugeben**, bzw. die Ausgabe eines Linux-Befehls auf einen gegebenen Umfang zu beschränken. Der Linux-Head-Befehl ist **Teil der „GNU Core Utilities“ (Coreutils)**. Dabei handelt es sich um eine Sammlung grundlegender Kommandozeilen-Befehle. Der Unix-Philosophie folgend nutzen die Befehle Text als universelles Ein- und Ausgabeformat. Die Coreutils sind unter einer Open Source Lizenz veröffentlicht und stehen für eine Vielzahl unterschiedlicher Betriebssysteme bereit. ## Motivation des Linux-Head-Befehls Der Linux-Head-Befehl wird genutzt, um die **Ausgabe von Text auf der Kommandozeile zu begrenzen**. Doch warum ist dies nützlich oder erforderlich? Um die Frage zu beantworten, werfen wir einen Blick auf die generelle Funktionsweise der Linux-Kommandozeile. Die meisten Linux-Befehle nehmen **Text als Eingabe entgegen bzw. geben Text als Ausgabe aus**. Quelle bzw. Ziel eines Kommandos können dabei sein: - **Dateien** – insbesondere Textdateien im [ASCII](https://www.ionos.at/digitalguide/server/knowhow/ascii-american-standard-code-for-information-interchange/)-Format. Von weniger Interesse sind hierbei Binärdateien wie JPEG-Bilder oder Word-Dokumente. - **Standard Ein- und Ausgabe** – Text, der dem Nutzer im Terminal angezeigt, bzw. von diesem dort eingegeben wird. - **So genannte** „Pipes“ (zu Deutsch „Rohrleitung“) – dabei handelt es sich um Verkettungen mehrerer Linux-Befehle. Die Text-Ausgabe eines Befehls wird als Text-Eingabe an den nächsten Befehl weitergereicht. Ziehen wir weiterhin in Betracht, dass Dateien schier unermessliche Mengen an Text enthalten können. Beispielshalber enthält eine Datei mit einer Größe von mehreren Gigabyte Milliarden von Zeichen! Daher ist es oft nützlich, die Menge ausgegebenen Textes zu begrenzen bzw. gezielt nur **bestimmte Zeilen oder Textmengen auszugeben**. Hier eine Übersicht gebräuchlicher Linux-Befehle zur Ausgabe von Textdateien: - [Linux-CAT](https://www.ionos.at/digitalguide/server/konfiguration/linux-cat-befehl/): Gesamte Datei ausgeben. Die Ausgabe großer Dateien überflutet die Kommandozeile. - Linux-LESS: Gesamte Datei seitenweise ausgeben. Bei großen Dateien nicht praktikabel. - Linux-HEAD: Anfang einer Datei ausgeben, bzw. Ausgabe auf einen bestimmten Bereich beschränken. - [Linux-TAIL](https://www.ionos.at/digitalguide/server/konfiguration/linux-tail-befehl/): Ende einer Datei ausgeben, bzw. Ausgabe auf einen bestimmten Bereich beschränken. Falls sich unsere Erklärungen bisher abstrakt anhören, schauen Sie sich die untenstehenden praktischen Beispiele an. Anhand derer sollten sich die dargelegten Ideen konkret nachvollziehen lassen. ## Aufruf des Linux-Head-Befehls auf der Kommandozeile Der **Aufruf des Linux-Head-Befehls erfolgt auf der Kommandozeile**. Dabei wird der Name des Befehls gefolgt von optionalen Parametern eingegeben. Abgeschlossen wird der Aufruf vom Namen bzw. Pfad einer oder mehrerer Dateien. Betrachten wir zunächst die Schreibweise des generellen Falls: ```none head [optionen] ``` Ohne Optionen ergibt sich als **simpelster Aufruf des Linux-Head-Befehls** das folgende Muster: ```none head ``` So aufgerufen, gibt der Linux-Head-Befehl die ersten zehn Zeilen der angegebenen Datei aus. Auf diese Weise kann man **schnell einen kurzen Blick in den Anfang einer Datei werfen**. Oft verrät einem dies, worum es sich bei der Datei handelt. Im täglichen Einsatz wird der Linux-Head-Befehl häufig mit der Option '-n' aufgerufen. Mit einer dahinter folgenden Zahl legt man fest, **wie viele Zeilen ausgegeben werden sollen**. Schauen wir uns zwei Beispiele an. Der folgende Aufruf gibt nur die erste Zeile einer Datei aus: ```none head -n 1 ``` Wir können uns nach demselben Schema **die ersten 100 Zeilen einer Datei ausgeben**: ```none head -n 100 ``` ### Optionen des Linux-Head-Befehls Der Konvention folgend wird der **Linux-Head-Befehl über optionale Parameter gesteuert**. Als Teil der GNU Coreutils gibt es für jede Option eine Langform; für die am häufigsten genutzten Optionen gibt es ferner eine oft historisch bedingte Kurzform. Wir zeigen hier eine Übersicht der nützlichsten Optionen:
Option (Kurzform / Langform) Erklärung
-n / --lines Ausgabe auf die ersten n Zeilen begrenzen / Ausgabe der letzten n Zeilen unterdrücken
-c / --bytes Ausgabe auf die ersten n Bytes begrenzen / Ausgabe der letzten n Bytes unterdrücken
-q / --quiet, --silent Bei Nutzung mit mehreren Dateien Ausgabe der Dateinamen unterdrücken
-v / --verbose Bei Nutzung mit mehreren Dateien Ausgabe der Dateinamen erzwingen
--help Hilfsinformationen des Befehls ausgeben
--- ### Hinweis In den nachfolgenden Beispielen nutzen wir die Optionen in der Kurzform ('-n', statt '--lines', etc.) Wenn Sie andere Dokumentationen oder Code-Beispiele lesen, werden Sie weitaus häufiger auf diese Verwendung stoßen. --- ### Exkurs: wie sind Zeilen und Zeichen zu verstehen? Bevor wir uns die praktischen Beispiele ansehen, **ein paar Worte zur Begrifflichkeit**. Was meinen wir tatsächlich, wenn wir von „Zeilen“ und „Zeichen“ sprechen? Rein intuitive können Sie sicherlich eine Antwort auf diese Frage geben. Aber in der strikt reglementierten digitalen Umgebung müssen wir es ganz genau wissen. Intern ist eine **Textdatei eine einzige, durchgehende Zeichenkette**. Das Ende einer jeden Zeile ist lediglich mit einem „Zeilenumbruch“ genannten Zeichen markiert. Je nach Betriebssystem ist das eingesetzte Zeichen ggf. unterschiedlich, was zu mancherlei seltsamen Problemen führen kann. Unter Linux markiert das „Linefeed“-Zeichen ('LF') den Zeilenumbruch. Bei Nutzung der Option '-c' / '--bytes' wird davon ausgegangen, dass **ein Byte genau einem Zeichen entspricht**. Dies funktioniert für den ASCII-Zeichensatz, kann aber in anderen Situationen zu Problemen führen. Beim heutzutage weit verbreiteten [Unicode](https://www.ionos.at/digitalguide/websites/webseiten-erstellen/unicode/ "Unicode")-Zeichensatz handelt es sich um eine „Multibyte“-Zeichenkodierung. Um ein einzelnes Zeichen darzustellen, kommen also ggf. mehrere Bytes zum Einsatz. Verarbeiten Sie Unicode-Textdateien mit dem Linux-Head-Befehl, kann es zu seltsamen Nebeneffekten kommen. So kann die Nutzung der '-c'-Option dazu führen, dass aus einem Umlaut (z.B. „ü“) der korrespondierende Vokal („u“) wird. ## Praktische Beispiele für den Einsatz des Linux-Head-Befehls Um die folgenden Beispiele konkret nachvollziehbar zu machen, verwenden wir den **Text des deutschen Grundgesetzes in der Originalfassung** von 1949. Der Text liegt digital auf Github vor. Wir laden diesen mit dem [Curl-Befehl](https://www.ionos.at/digitalguide/server/tools/einstieg-in-curl-in-linux/ "Einstieg in cURL in Linux") herunter und speichern ihn als Datei 'gg.txt' auf dem Desktop. Führen Sie dafür den folgenden Code-Schnipsel auf Ihrer Kommandozeile aus: ```none curl https://raw.githubusercontent.com/munichrocker/grundgesetz_changes/master/data/gg_2019.txt > ~/Desktop/gg.txt ``` ### Mit dem Linux-Head-Befehl nur die erste Zeile ausgeben Das Muster für die **Ausgabe der ersten Zeile einer Textdatei** haben wir bereits präsentiert. Hier der entsprechende Aufruf anhand unseres konkreten Beispiels: ```none head -n 1 ~/Desktop/gg.txt ``` --- ### Tipp Das Ausgeben der ersten Zeile ist insbesondere interessant, um die sogenannte „Hashbang“ einer Skript-Datei auszugeben. Diese enthält eine Angabe über den zur Ausführung des Skripts genutzten Interpreters und dessen Pfad. --- ### Mit dem Linux-Head-Befehl alles bis auf die letzte Zeile ausgeben Analog zur ersten Zeile lässt sich mit dem Linux-Head-Befehl auch der gesamte Text **bis auf die letzte Zeile** ausgeben. Dafür nutzen wir die '-n'-Option und stellen dem Argument ein Minuszeichen voran: ```none head -n -1 ~/Desktop/gg.txt ``` ### Den Linux-Head-Befehl mit dem Tail-Befehl kombinieren, um bestimmte Textbereiche auszugeben Wie verhält es sich nun, wenn wir nur die Präambel des Grundgesetzes in den Zeilen 14–26 ausgeben möchten? Um dies zu erreichen, greifen wir auf den **Schwesterbefehl des Linux-Head-Befehls** zurück. Der Tail-Befehl gibt analog zum Linux-Head-Befehl das Ende einer Textdatei aus. Kombinieren wir beide Befehle mit dem Pipe-Symbol '|', können wir einen definierten Bereich aus einem Text herausschneiden: ```none head -n 26 ~/Desktop/gg.txt | tail -n 14 ``` So ist es auch möglich, **nur eine bestimmte Zeile auszugeben**. Dazu nutzen wir den Tail-Befehl mit der Option '-n 1'. Um z.B. nur die berühmte Zeile 34 „(1) Die Würde des Menschen ist unantastbar \[…\]“ auszugeben, greifen wir auf das folgende Kommando zurück. ```none head -n 34 ~/Desktop/gg.txt | tail -n 1 ``` Wie Sie sehen können, wird die gesamte Zeile „(1) Die Würde des Menschen ist unantastbar. Sie zu achten und zu“ ausgegeben. Um nur den Teil bis „unantastbar.“ auszugeben, fügen wir einen weiteren „gepipten“ Aufruf des Linux-Head-Befehls hinzu. Ferner **machen wir uns die Option '-c' zunutze** und probieren als Argument verschiedene Werte durch, bis wir genau den passenden Bereich abschneiden. In diesem Falle benötigen wir nur die ersten 44 Zeichen: ```none head -n 34 ~/Desktop/gg.txt | tail -n 1 | head -c 44 ``` Intuitiver kann es sein, die **Anzahl der abzuschneidenden Zeichen von hinten zu zählen**. Auch dies ist möglich, indem wir dem Argument der Option '-c' ein Minuszeichen voranstellen Die Ausgabe des Befehls bleibt dabei gleich: ```none head -n 34 ~/Desktop/gg.txt | tail -n 1 | head -c -20 ``` Zu guter Letzt möchten wir noch den führenden Teil „(1)“ sowie das darauf folgende Leerzeichen entfernen. Sie können es vielleicht schon erahnen: um dies zu erreichen, hängen wir einen weiteren Aufruf des Tail-Befehls an. Dabei versehen wir das Argument der '-c'-Option mit einem Pluszeichen. **Analog zum Minuszeichen des Linux-Head-Befehls** drehen wir damit die Bedeutung der Option um: Anstatt wie üblich die Ausgabe auf die letzten fünf Zeichen zu beschränken, begrenzen wir die Ausgabe auf den Rest ab dem fünften führenden Zeichen: ```none head -n 34 ~/Desktop/gg.txt | tail -n 1 | head -c -22 | tail -c +5 ``` Vielleicht fragen Sie sich nun, ob der Aufwand, ein so komplexes Kommando zu konstruieren sich tatsächlich lohnt. Oder geht es vielleicht auch einfacher? In der Tat handelt es sich hier nur um ein Beispiel. Eleganter lässt sich die Operation mit dem [Sed-Befehl](https://www.ionos.at/digitalguide/server/konfiguration/linux-sed-befehl/ "Linux-SED-Befehl") lösen. Bei großen Dateien ist der Linux-Head-Befehl jedoch schneller als der Sed-Befehl. ### Die Ausgabe des Linux-Head-Befehls mit dem grep-Befehl filtern Sie haben bereits gesehen, wie sich der Linux-Head-Befehl mit dem Tail-Befehl kombinieren lässt. Eine weitere gebräuchliche Kombination ist das Filtern des ausgegebenen Textes mit dem Grep-Befehl. So können wir die **Ausgabe auf Zeilen beschränken, welche den Suchterm enthalten**. Zur Erinnerung: ohne Angabe der Option '-n' gibt der Linux-Head-Befehl die ersten zehn Zeilen der Datei aus. Hier geben wir diejenigen Zeilen aus den ersten zehn Zeilen des Grundgesetz-Textes aus, welche das Wort 1949 enthalten: ```none head ~/Desktop/gg.txt | grep 1949 ``` ### Mehrere Dateien mit dem Linux-Head-Befehl verarbeiten Bisher haben wir eine einzelne Datei mit dem Linux-Head-Befehl verarbeitet. Es lassen sich jedoch auch **mehrere Dateien beim Aufruf angeben**. Dafür listen wir entweder mehrere Dateinamen bzw. -pfade explizit auf. Oder wir geben als Quelle des Befehls ein gesamtes Verzeichnis mit Dateien bzw. ein Suchmuster an. Letzteres zeigen wir hier exemplarisch anhand von Konfigurationsdateien im Systemverzeichnis '/etc/'. Die Dateien tragen die Endung '.conf', welches wir als Suchmuster '\*.conf' angeben: ```none head -n 1 /etc/*.conf ``` Um bei der Verarbeitung mehrere Dateien die **Ausgabe der Dateinamen zu unterdrücken**, nutzen wir die Option '-q': ```none head -q -n 1 /etc/*.conf ``` Analog dazu können wir die Option '-v' nutzen, um die **Ausgabe der Dateinamen zu erzwingen**. Dies ist nützlich, falls nur eine einzelne Datei dem Suchmuster entspricht: ```none head -v /etc/host*.conf ``` ### Mit dem Linux-Head-Befehl die fünf zuletzt geänderten Dateien auflisten Unter Linux dient der ls-Befehl zum Auflisten von Dateien und Verzeichnissen. Mit der '-t'-Option versehen, sortieren wir die Liste absteigend nach dem Datum der letzten Änderung. Um die Liste ferner **nach fünf Eintragen abzuschneiden**, hängen wir einen Aufruf des Linux-Head-Befehls als Pipe an: ```none ls -t | head -n 5 ``` ### Mit dem Linux-Head-Befehl einen zufälligen Hash mit gegebener Länge ausgeben Der Linux-Befehl 'sha512sum' erzeugt einen Hash mit einer Länge von 128 Zeichen. Um zwei Hashes mit dem Auge zu vergleichen, ist es oft nicht notwendig, den gesamten Hash zu betrachten. Beispielshalber kann es ausreichen, sich **nur die ersten acht Zeichen anzuschauen**. Dieses Muster ist Ihnen evtl. von Git-Commits bekannt. Dafür rufen wir den Linux-Head-Befehl mit der '-c'-Option auf. Als Datenquelle nutzen wir hier die Bash-Funktion '$RANDOM', welche eine zufällige Zahl zurückliefert: ```none echo $RANDOM | sha512sum | head -c 8 ``` This is a markdown version of: [https://www.ionos.at/digitalguide/server/konfiguration/linux-head-befehl/](https://www.ionos.at/digitalguide/server/konfiguration/linux-head-befehl/) for AI/LLM consumption.