Linux-Head-Befehl

Der Linux-Head-Befehl gehört wie auch der Linux-Tail-Befehl zu den es­sen­zi­el­len Werk­zeu­gen auf der Kom­man­do­zei­le. In erster Linie dient der Befehl dazu, den Anfang einer (Text)-Datei aus­zu­ge­ben, bzw. die Ausgabe eines Linux-Befehls auf einen gegebenen Umfang zu be­schrän­ken.

Der Linux-Head-Befehl ist Teil der „GNU Core Utilities“ (Coreutils). Dabei handelt es sich um eine Sammlung grund­le­gen­der Kom­man­do­zei­len-Befehle. Der Unix-Phi­lo­so­phie folgend nutzen die Befehle Text als uni­ver­sel­les Ein- und Aus­ga­be­for­mat. Die Coreutils sind unter einer Open Source Lizenz ver­öf­fent­licht und stehen für eine Vielzahl un­ter­schied­li­cher Be­triebs­sys­te­me bereit.

Der Linux-Head-Befehl wird genutzt, um die Ausgabe von Text auf der Kom­man­do­zei­le zu begrenzen. Doch warum ist dies nützlich oder er­for­der­lich? Um die Frage zu be­ant­wor­ten, werfen wir einen Blick auf die generelle Funk­ti­ons­wei­se der Linux-Kom­man­do­zei­le. 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 – ins­be­son­de­re Text­da­tei­en im ASCII-Format. Von weniger Interesse sind hierbei Bi­när­da­tei­en wie JPEG-Bilder oder Word-Dokumente.
• Standard Ein- und Ausgabe – Text, der dem Nutzer im Terminal angezeigt, bzw. von diesem dort ein­ge­ge­ben wird.
• So genannte „Pipes“ (zu Deutsch „Rohr­lei­tung“) – dabei handelt es sich um Ver­ket­tun­gen mehrerer Linux-Befehle. Die Text-Ausgabe eines Befehls wird als Text-Eingabe an den nächsten Befehl wei­ter­ge­reicht.

Ziehen wir weiterhin in Betracht, dass Dateien schier un­er­mess­li­che Mengen an Text enthalten können. Bei­spiels­hal­ber enthält eine Datei mit einer Größe von mehreren Gigabyte Mil­li­ar­den von Zeichen! Daher ist es oft nützlich, die Menge aus­ge­ge­be­nen Textes zu begrenzen bzw. gezielt nur bestimmte Zeilen oder Text­men­gen aus­zu­ge­ben. Hier eine Übersicht ge­bräuch­li­cher Linux-Befehle zur Ausgabe von Text­da­tei­en:

• Linux-CAT: Gesamte Datei ausgeben. Die Ausgabe großer Dateien über­flu­tet die Kom­man­do­zei­le.
• Linux-LESS: Gesamte Datei sei­ten­wei­se ausgeben. Bei großen Dateien nicht prak­ti­ka­bel.
• Linux-HEAD: Anfang einer Datei ausgeben, bzw. Ausgabe auf einen be­stimm­ten Bereich be­schrän­ken.
• Linux-TAIL: Ende einer Datei ausgeben, bzw. Ausgabe auf einen be­stimm­ten Bereich be­schrän­ken.

Falls sich unsere Er­klä­run­gen bisher abstrakt anhören, schauen Sie sich die un­ten­ste­hen­den prak­ti­schen Beispiele an. Anhand derer sollten sich die dar­ge­leg­ten Ideen konkret nach­voll­zie­hen lassen.

Der Aufruf des Linux-Head-Befehls erfolgt auf der Kom­man­do­zei­le. Dabei wird der Name des Befehls gefolgt von op­tio­na­len Pa­ra­me­tern ein­ge­ge­ben. Ab­ge­schlos­sen wird der Aufruf vom Namen bzw. Pfad einer oder mehrerer Dateien. Be­trach­ten wir zunächst die Schreib­wei­se des ge­ne­rel­len Falls:

Ohne Optionen ergibt sich als sim­pels­ter Aufruf des Linux-Head-Befehls das folgende Muster:

So auf­ge­ru­fen, gibt der Linux-Head-Befehl die ersten zehn Zeilen der an­ge­ge­be­nen 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' auf­ge­ru­fen. Mit einer dahinter folgenden Zahl legt man fest, wie viele Zeilen aus­ge­ge­ben werden sollen. Schauen wir uns zwei Beispiele an. Der folgende Aufruf gibt nur die erste Zeile einer Datei aus:

Wir können uns nach demselben Schema die ersten 100 Zeilen einer Datei ausgeben:

Der Kon­ven­ti­on 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äu­figs­ten genutzten Optionen gibt es ferner eine oft his­to­risch bedingte Kurzform. Wir zeigen hier eine Übersicht der nütz­lichs­ten Optionen:

Bevor wir uns die prak­ti­schen Beispiele ansehen, ein paar Worte zur Be­griff­lich­keit. Was meinen wir tat­säch­lich, wenn wir von „Zeilen“ und „Zeichen“ sprechen? Rein intuitive können Sie si­cher­lich eine Antwort auf diese Frage geben. Aber in der strikt re­gle­men­tier­ten digitalen Umgebung müssen wir es ganz genau wissen.

Intern ist eine Textdatei eine einzige, durch­ge­hen­de Zei­chen­ket­te. Das Ende einer jeden Zeile ist lediglich mit einem „Zei­len­um­bruch“ genannten Zeichen markiert. Je nach Be­triebs­sys­tem ist das ein­ge­setz­te Zeichen ggf. un­ter­schied­lich, was zu man­cher­lei seltsamen Problemen führen kann. Unter Linux markiert das „Linefeed“-Zeichen ('LF') den Zei­len­um­bruch.

Bei Nutzung der Option '-c' / '--bytes' wird davon aus­ge­gan­gen, dass ein Byte genau einem Zeichen ent­spricht. Dies funk­tio­niert für den ASCII-Zei­chen­satz, kann aber in anderen Si­tua­tio­nen zu Problemen führen. Beim heut­zu­ta­ge weit ver­brei­te­ten Unicode-Zei­chen­satz handelt es sich um eine „Multibyte“-Zei­chen­ko­die­rung. Um ein einzelnes Zeichen dar­zu­stel­len, kommen also ggf. mehrere Bytes zum Einsatz. Ver­ar­bei­ten Sie Unicode-Text­da­tei­en mit dem Linux-Head-Befehl, kann es zu seltsamen Ne­ben­ef­fek­ten kommen. So kann die Nutzung der '-c'-Option dazu führen, dass aus einem Umlaut (z.B. „ü“) der kor­re­spon­die­ren­de Vokal („u“) wird.

Um die folgenden Beispiele konkret nach­voll­zieh­bar zu machen, verwenden wir den Text des deutschen Grund­ge­set­zes in der Ori­gi­nal­fas­sung von 1949. Der Text liegt digital auf Github vor. Wir laden diesen mit dem Curl-Befehl herunter und speichern ihn als Datei 'gg.txt' auf dem Desktop. Führen Sie dafür den folgenden Code-Schnipsel auf Ihrer Kom­man­do­zei­le aus:

Das Muster für die Ausgabe der ersten Zeile einer Textdatei haben wir bereits prä­sen­tiert. Hier der ent­spre­chen­de Aufruf anhand unseres konkreten Beispiels:

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 Mi­nus­zei­chen voran:

Wie verhält es sich nun, wenn wir nur die Präambel des Grund­ge­set­zes in den Zeilen 14–26 ausgeben möchten? Um dies zu erreichen, greifen wir auf den Schwes­ter­be­fehl des Linux-Head-Befehls zurück. Der Tail-Befehl gibt analog zum Linux-Head-Befehl das Ende einer Textdatei aus. Kom­bi­nie­ren wir beide Befehle mit dem Pipe-Symbol '|', können wir einen de­fi­nier­ten Bereich aus einem Text her­aus­schnei­den:

So ist es auch möglich, nur eine bestimmte Zeile aus­zu­ge­ben. 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 un­an­tast­bar […]“ aus­zu­ge­ben, greifen wir auf das folgende Kommando zurück.

Wie Sie sehen können, wird die gesamte Zeile „(1) Die Würde des Menschen ist un­an­tast­bar. Sie zu achten und zu“ aus­ge­ge­ben. Um nur den Teil bis „un­an­tast­bar.“ aus­zu­ge­ben, fügen wir einen weiteren „gepipten“ Aufruf des Linux-Head-Befehls hinzu. Ferner machen wir uns die Option '-c' zunutze und probieren als Argument ver­schie­de­ne Werte durch, bis wir genau den passenden Bereich ab­schnei­den. In diesem Falle benötigen wir nur die ersten 44 Zeichen:

In­tui­ti­ver kann es sein, die Anzahl der ab­zu­schnei­den­den Zeichen von hinten zu zählen. Auch dies ist möglich, indem wir dem Argument der Option '-c' ein Mi­nus­zei­chen vor­an­stel­len Die Ausgabe des Befehls bleibt dabei gleich:

Zu guter Letzt möchten wir noch den führenden Teil „(1)“ sowie das darauf folgende Leer­zei­chen entfernen. Sie können es viel­leicht 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 Plus­zei­chen. Analog zum Mi­nus­zei­chen des Linux-Head-Befehls drehen wir damit die Bedeutung der Option um: Anstatt wie üblich die Ausgabe auf die letzten fünf Zeichen zu be­schrän­ken, begrenzen wir die Ausgabe auf den Rest ab dem fünften führenden Zeichen:

Viel­leicht fragen Sie sich nun, ob der Aufwand, ein so komplexes Kommando zu kon­stru­ie­ren sich tat­säch­lich lohnt. Oder geht es viel­leicht auch einfacher? In der Tat handelt es sich hier nur um ein Beispiel. Eleganter lässt sich die Operation mit dem Sed-Befehl lösen. Bei großen Dateien ist der Linux-Head-Befehl jedoch schneller als der Sed-Befehl.

Sie haben bereits gesehen, wie sich der Linux-Head-Befehl mit dem Tail-Befehl kom­bi­nie­ren lässt. Eine weitere ge­bräuch­li­che Kom­bi­na­ti­on ist das Filtern des aus­ge­ge­be­nen Textes mit dem Grep-Befehl. So können wir die Ausgabe auf Zeilen be­schrän­ken, welche den Suchterm enthalten. Zur Er­in­ne­rung: ohne Angabe der Option '-n' gibt der Linux-Head-Befehl die ersten zehn Zeilen der Datei aus. Hier geben wir die­je­ni­gen Zeilen aus den ersten zehn Zeilen des Grund­ge­setz-Textes aus, welche das Wort 1949 enthalten:

Bisher haben wir eine einzelne Datei mit dem Linux-Head-Befehl ver­ar­bei­tet. Es lassen sich jedoch auch mehrere Dateien beim Aufruf angeben. Dafür listen wir entweder mehrere Da­tei­na­men bzw. -pfade explizit auf. Oder wir geben als Quelle des Befehls ein gesamtes Ver­zeich­nis mit Dateien bzw. ein Such­mus­ter an. Letzteres zeigen wir hier ex­em­pla­risch anhand von Kon­fi­gu­ra­ti­ons­da­tei­en im Sys­tem­ver­zeich­nis '/etc/'. Die Dateien tragen die Endung '.conf', welches wir als Such­mus­ter '*.conf' angeben:

Um bei der Ver­ar­bei­tung mehrere Dateien die Ausgabe der Da­tei­na­men zu un­ter­drü­cken, nutzen wir die Option '-q':

Analog dazu können wir die Option '-v' nutzen, um die Ausgabe der Da­tei­na­men zu erzwingen. Dies ist nützlich, falls nur eine einzelne Datei dem Such­mus­ter ent­spricht:

Unter Linux dient der ls-Befehl zum Auflisten von Dateien und Ver­zeich­nis­sen. Mit der '-t'-Option versehen, sortieren wir die Liste ab­stei­gend nach dem Datum der letzten Änderung. Um die Liste ferner nach fünf Eintragen ab­zu­schnei­den, hängen wir einen Aufruf des Linux-Head-Befehls als Pipe an:

Der Linux-Befehl 'sha512sum' erzeugt einen Hash mit einer Länge von 128 Zeichen. Um zwei Hashes mit dem Auge zu ver­glei­chen, ist es oft nicht notwendig, den gesamten Hash zu be­trach­ten. Bei­spiels­hal­ber kann es aus­rei­chen, sich nur die ersten acht Zeichen an­zu­schau­en. Dieses Muster ist Ihnen evtl. von Git-Commits bekannt. Dafür rufen wir den Linux-Head-Befehl mit der '-c'-Option auf. Als Da­ten­quel­le nutzen wir hier die Bash-Funktion '$RANDOM', welche eine zufällige Zahl zu­rück­lie­fert: