Der Einstieg in die Programmierung auf der Kommandozeile fällt erstaunlich leicht. Mit Shell-Skripten implementieren Sie einfache Abläufe ebenso elegant wie komplexe Strukturen.

Viele Einzelschritte, die Sie mühsam in der GUI durch viel Klicken erledigen, fassen Sie im optimalen Fall in einem Shell-Skript zusammen. Mit wenigen Zeilen Code sichern Sie so etwa zuverlässig Daten, durchsuchen große Textmengen nach Zitaten oder verwalten Adressen abseits der SQL-Welt.

Grundsätzliches

Shell-Skripte dürfen einen beliebigen Namen tragen. Gleicht dieser dem Namen von bestehenden Tools, entscheidet die Variable $PATH, welches zuerst greift. Das verwirrt unter Umständen. Um hier besser abzugrenzen, empfiehlt es sich, die Endung .sh zu verwenden.

Am einfachsten schreiben Sie Ihre Skripte mit einem Texteditor. Viele bieten dabei ein Syntax-Highlighting an, das die Orientierung im Code erleichtert. Zu beliebten Kandidaten zählen Vim und Nano auf der Konsole oder aber Gedit oder Kate in der grafischen Oberfläche. Mithilfe des Editors Ihrer Wahl erstellen Sie ein kleines Skript wie in Listing 1 und speichern es unter dem Namen 1.sh ab.

#! /bin/sh
echo "Test"

Beim Betrachten dieses Mini-Listings erkennen Sie, dass die erste Zeile nach dem sogenannten Shebang #! den Pfad zum Interpreter enthält. Das funktioniert auf fast jedem Unix-ähnlichen System, wie unter Linux und den Vertretern der BSD-Familie. Überwiegend kommt in der Praxis die Zeile #!/bin/sh zum Einsatz. Welche Shell aber tatsächlich das Ausführen des Skripts übernimmt, erfahren Sie, indem Sie mittels echo $SHELL die Standard-Shell abfragen.

Möchten Sie die Vorzüge eines bestimmten auf dem System installierten Interpreters nutzen, geben Sie den absoluten Pfad ein, wie etwa #!/usr/bin/zsh für die Z-Shell.

Sie haben verschiedene Möglichkeiten, um ein Skript zu starten (siehe Tabelle “Startmethoden”). Dabei kommt es in einigen Fällen darauf an, dass die Datei die korrekten Rechte zum Ausführen erhält. Diese vergeben Sie mit dem Kommando chmod im Terminal. Das erste Beispiel aus Listing 2 zeigt, wie Sie die Rechte nur für den Benutzer setzen, die zweite Zeile setzt diese für alle.

$ chmod 700 1.sh
$ chmod 755 1.sh

Angenommen, ein Skript verfügt über die passenden Rechte, liegt im aktuellen Verzeichnis und Sie wollen es ausführen, dann greift ein spezieller Mechanismus: Der Aufruf verlangt ein vorangestelltes ./ vor dem Namen. Das verhindert Angriffe, bei denen im Verzeichnis ein bösartiges Skript liegt, das den Namen eines bekannten Shell-Kommandos trägt. Ist das Verzeichnis allerdings in der Variablen $PATH enthalten, brauchen Sie Punkt und Schrägstrich nicht voranzustellen.

Normalerweise gibt ein Shell-Skript nach dem Abarbeiten wie jedes andere Kommando einen Wert zurück. Diesen sogenannten Exit-Code legt der Interpreter in der Variablen $? ab. Im Erfolgsfall erhalten Sie den Wert 0; tritt ein Fehler auf, lautet der Exit-Code 1. Für bestimmte Zwecke lohnt es sich aber, andere numerische Werte zu verwenden. Dazu setzen Sie ein exit Wert ans Ende des Skripts beziehungsweise an die Stelle, an der Sie es abbrechen.

Variablen belegen und leeren

Sie sehen in Beispielen zur Dateneingabe immer wieder den Echo-Befehl, um das Ergebnis zu prüfen. Dabei kommt das Kommando oft in einer einfachen Form zum Einsatz. Es hilft unter anderem dabei, den Wert von Variablen zu ermitteln.

Diese belegen Sie innerhalb eines Skripts in derselben Form wie direkt in der Shell – durch Zuweisen mit dem Gleichheitszeichen (Listing 3, Zeile 1 oder Zeile 2). Möchten Sie die Ausgabe einer Sub-Shell (also quasi eines externen Kommandos) in einer Variablen ablegen, nutzen Sie die Notation aus Zeile 3. Die Variante aus Zeile 4 mit den sogenannten Backticks funktioniert zwar auch (noch), gilt aber als veraltet.

A=1
B="a bc"
C=$(Sub-Shell)
D=`Sub-Shell`

Der Einsatz einer Sub-Shell zum Belegen einer Variablen findet sich in der Literatur oft als “Kommandosubstitution”. Sie kommt etwa in For-Schleifen zum Einsatz. Die Variablensubstitution wertet dagegen den Inhalt einer Variablen aus und reagiert entsprechend. In der Tabelle “Variablensubstitution” finden Sie einige wichtige Möglichkeiten.

Die Eingabe von Daten erledigen Sie mittels der Positionsparameter beim Aufruf. Alle Shell-Interpreter erlauben, zumindest neun Werte zu verwenden. Mittels des Shift-Kommandos erweitern Sie den Umfang nach Ihren Vorstellungen.

Speziell die Bash benötigt dieses Kommando aber nicht. Positionsparameter sprechen Sie auch für Werte größer als 9 in der Form ${Position} an. Möchten Sie alle Positionsparameter zusammengefügt auf einmal verwenden, greifen Sie auf den Inhalt der Variable $@ zu.

Interaktive Abfragen

Mit dem Befehl read gestalten Sie einfache Dialoge auf der Shell – so belegen Sie etwa Variablen. Einige gebräuchliche Optionen finden Sie in der Tabelle “Read-Optionen”. Durch Umleiten der Standardeingabe oder den Einsatz weiterer Eingabekanäle lesen Sie sogar den Inhalt einer Datei zeilenweise in der Form read Variable Datei ein.

Die einfachste Form der Anwendung lautet kurz und knapp read Variable. Dabei blinkt der Prompt im Terminal. Listing 4 zeigt, wie Sie die Optionen aus der Tabelle “Read-Optionen” in der Praxis einsetzen, etwa um eine Eingabeaufforderung zu verwenden (Zeile 1), die geschützte Eingabe von Passwörtern zu ermöglichen (Zeile 2) oder den Wert einer Variablen zu editieren (Zeile 3). Die maximale Länge einer Zeichenkette nutzen Sie etwa für Menüs. In diesem Fall brauchen Anwender nicht die Eingabetaste zu bemühen, das Skript schließt die Eingabe automatisch ab (Listing 4, Zeile 4).

read -p "Bitte Text eingeben: " Variable
read -s -p "Kennwort eingeben: " Variable
read -ei $Variable -p "Text" Variable
read -n1 -p "Funktion auswählen: " Variable

Das Skript aus Listing 5 zeigt ein solches einfaches Menü. Geben Sie diesem die entsprechenden Rechte, und rufen Sie es abweichend von der bisher gezeigten Weise in der folgenden Form auf: bash 4.sh. Nutzen Sie einen anderen Interpreter, erhalten Sie bezüglich der erweiterten Optionen von read eine Fehlermeldung. Das Ergebnis sieht noch nicht so überzeugend aus, Schleifen und weitere Anweisungen könnten an dieser Stelle zum Abfangen von Fehlern dienen.

#!/bin/sh
echo "(1) Erster Punkt"
echo "(2) Zweiter Punkt"
echo "(3) Dritter Punkt"
read -s -n1 FUNK
echo "Ausgewählte Funktion: $FUNK"

Beim Skript aus Listing 6 geben Sie zunächst einen Vornamen ein. Der Code gibt dann diese Eingabe wieder aus und fordert Sie auf, einen Nachnamen hinzuzufügen. Achten Sie auch bei diesem Skript auf die gezielte Angabe des korrekten Interpreters.

#!/bin/bash
read -p "Vorname eingeben: " NAME
echo "----------------------------------"
read -ei $NAME -p "Bitte Nachnamen hinzufügen: " NAME
echo "----------------------------------"
echo $NAME

Daten aus Sub-Shells

Vielfach sehen Sie den Befehl cat im Einsatz beim Einlesen von Textdateien. Richtig eingesetzt, belegen Sie mit dem Inhalt eine Variable:

Variable=$(cat Datei)

Der Dreizeiler aus Listing 7 demonstriert das Einlesen der Datei merker.txt – sie enthält nur die Zeichenkette INFORMATION. Möchten Sie Wörter oder Zeilen einzeln auswerten, nutzen Sie dazu eine Schleife, was in diesem Fall aber nicht geschieht.

#!/bin/sh
A=$(cat merker.txt)
echo $A

Den Wert einer Variablen löschen Sie entweder mit dem Befehl unset Variable, oder indem Sie die Variable in der Form Variable="" belegen. Beachten Sie, dass Sie in beiden Fällen die Variable ohne das Dollar-Zeichen ansprechen – in der Praxis ein häufiger Fehler.

Ausgabe

Mit dem Kommando echo geben Sie Daten an verschiedene Ziele aus: Bildschirm, Dateien (durch Umlenken der Ausgabe) oder in einer sogenannten Pipe an nachfolgende Befehle. Dabei besteht die Möglichkeit, wie in echo "Name: $name" feste Werte und Variablen zu kombinieren. Wollen Sie gleichzeitig den Namen der Variablen und dessen Wert ausgeben, nutzen Sie einen der Befehle aus Listing 8.

echo "\$Variable = $Variable"
echo '$Variable =' $Variable

Mit der Option -e interpretiert die Shell Steuerzeichen in der Ausgabe, mit -E unterbinden Sie dieses Verhalten. Die Option -n unterdrückt den Zeilenumbruch nach der Ausgabe. Das benötigen Sie beispielsweise, wenn die verwendete Shell die Anzeige eines Prompts bei read nicht unterstützt. Dann verwenden Sie die folgende Kombination:

echo -n "Eingabe: "; read Variable

Mit Steuerzeichen erweitern Sie die Ausgabe auf Terminal oder einer umgelenkten Ausgabe: Auf diese Weise fügen Sie Tabulatoren oder Zeilenvorschübe ein oder unterdrücken diese. Listing 9 zeigt, wie Sie diese Zeichen einsetzen, in Abbildung 1 sehen Sie das Ergebnis. Die Tabelle “Steuerzeichen” führt die möglichen Steuerzeichen auf und erläutert deren Funktion.

#!/bin/bash
echo -e "Tabulator: abc\tdef"
echo -e "Vertikaler Tabulator: abc\vdef"
echo -e "Neue Zeile: abc\ndef"
# Neue Zeile unterdrücken (wie -n)
echo -e "Name eingeben: \c"; read NAME; echo $NAME

Abbildung 1: Steuerzeichen in Aktion (Listing 9).

Es besteht die Möglichkeit, die Ausgabe mit Farbe und diversen Attributen zu versehen, sofern das Terminal das unterstützt. So heben Sie wichtige Meldungen hervor oder gestalten Menüs ansprechender. Das Zusammenstellen der dazu genutzten sogenannten Escape-Sequenzen gestaltet sich dabei etwas kryptisch. Die Tabelle “Farben und Attribute” vermittelt einen Überblick der Möglichkeiten.

Sie leiten die Angaben mit einem ESC-Zeichen ein (\033) gefolgt von [. Nun folgen die gewünschten Effekte und Farben, jeweils getrennt durch ein Semikolon. Der Buchstabe m schließt die Sequenz ab. So sorgt beispielsweise folgender Befehl im Terminal für blaue Schrift:

$ echo -e "\033[0;34m"

Dabei leitet \033 die Sequenz mit dem ESC-Zeichen ein. Die Null vor dem Semikolon zeigt an, dass Sie keine Effekte wünschen. Nach dem Semikolon steht die 3 für den Vordergrund, also die Schriftfarbe, wobei diese blau erscheint (4). Mit reset setzen Sie das Terminal wieder zurück.

Listing 10 erzeugt eine kleine Maske zur Eingabe von Daten: Die Überschrift erscheint dabei unterstrichen, die Feldnamen blau, die Eingaben fett und in Schwarz, anschließend zeigt das Skript diese invers und setzt danach die Einstellungen zurück (Abbildung 2).

#!/bin/bash
echo ""
echo -e "\033[4;31mDateneingabe"
echo -e "\033[24;34m"
echo -e "Vorname: \t\033[1;39m\c"; read VN
echo -e "\033[22;m\033[24;34mNachname: \t\033[1;39m\c"; read NN
echo -e "\033[1;7m$VN $NN"
echo -e "\033[0;27m"

Abbildung 2: Jetzt wird es bunt (Listing 10).

Ausgabe mit Printf

Der Befehl Printf erlaubt weitgehende Anweisungen zum Formatieren der Ausgabe. Sie erzeugen auf diese Weise etwa tabellarische Datenausgaben, deren Spalten korrekt übereinanderstehen. Im Gegensatz zu Echo unterscheidet Printf verschiedene Datentypen. Dabei steht %s für eine Zeichenkette, %c für ein einzelnes Zeichen, %d für eine Ganzzahl und %f für eine Fließkommazahl.

Mit der Option -v Variable weisen Sie das formatierte Ergebnis als Wert direkt einer Variablen zu.

Es gibt noch weitere Anweisungen. Für die Ausgabe von Fließkommazahlen benötigen Sie zwei Angaben: die gesamte Länge der Ausgabe, also inklusive dem Komma und den Nachkommastellen sowie die Zahl der Nachkommastellen selbst. Das Minuszeichen sorgt für eine linksbündige Ausgabe. man 3 printf gibt Aufschluss über die Operatoren zum Formatieren.

Im Listing 11 finden Sie die meisten für den Alltag notwendigen Anweisungen (Abbildung 3). So formatiert Zeile 8 den Text so, das der Gesamtplatz 8 Stellen einnimmt und die Zeichenkette 3 Stellen, die rechtsbündig ausgerichtet ist. Das Beispiel der folgenden Zeile ist vom Platz gleich gestaltet, aber linksbündig ausgerichtet.

#! /bin/bash
TEXT="Mustertext"
NR1=12,345
NR2=-3,4
NR3=-45
printf "Beispiel 1 (Text): %8.3s \n" $TEXT
printf "Beispiel 2 (Text): %-8.3s \n" $TEXT
printf "Beispiel 3 (Text): %-15s \n" $TEXT
printf "Beispiel 4 (Text): %15s \n" $TEXT
printf "Beispiel 5 (Zahl 1): %10.2f \n" $NR1
printf "Beispiel 6 (Zahl 2): %10.2f \n" $NR2
printf "Beispiel 7 (Zahl 3): %d \n" $NR3
printf "Beispiel 8 (Zahl 3): %.5d \n" $NR3
printf -v f "%.3s \n" $TEXT
echo -e "Beispiel 9: Wert der Variablen \$F: $F"
printf "Text: %-.3s  Zahl1: %.2f  Zahl2: %.2f\n\n" $TEXT $NR1 $NR2

Abbildung 3: Gebräuchliche Formatierungen mit Printf (Listing 11).

In den Beispielen 1 bis 4 nimmt der Text einen Platz von 8 beziehungsweise 15 Stellen ein, jeweils linksbündig und rechtsbündig formatiert. Die folgenden Zeilen zeigen Beispiele für Fließkommazahlen mit zehnstelliger Breite mit zwei Stellen nach dem Komma sowie dem Pendant mit negativen Werten.

Die Beispiele 7 und 8 zeigen die Ausgabe einer ganzen, negativen Zahl – einmal ohne besondere Formatierungen, einmal mit 5 Stellen Platz. Die vorletzten Zeilen demonstrieren das Zuweisen einer Variablen. In der letzten Zeile sehen Sie die gleichzeitige Ausgabe mehrerer Werte. Dabei ist es wichtig, die Anweisungen und Variablen in der gleichen Reihenfolge zu platzieren.

Pipes und Umleitungen

In der Shell haben Sie die Möglichkeit, die Ausgabe eines Programms mittels einer Pipe (|) direkt an nachfolgende Kommandos zu übergeben. Dabei verknüpfen Sie in der Regel die Standardausgabe (STDOUT) mit der Standardeingabe (STDIN). Die Standardausgabe für Fehler (STDERR) liefert die Angaben zu Problemen.

Diese Eingaben und Ausgaben leiten Sie bei Bedarf nicht nur zwischen Befehlen um, sondern schreiben Sie direkt in Dateien (Tabelle “Umleitungen”). Listing 12 verdeutlicht diese Fälle. Beachten Sie, dass dieses Skript nur mit der Bash als Shell vollständig funktioniert.

#! /bin/bash
# Beispiel 1: Standardausgabe umleiten,
# ggf. vorhandene Zieldatei überschreiben
echo "Zeile 1" > datei1.txt
# Beispiel 2: Standardausgabe umleiten,
# Inhalt an ggf. vorhandene Zieldatei anfügen
echo "Zeile 2" >> datei1.txt
# Ausgabe:
cat datei1.txt
# Beispiel 3: Standard- und
# Standardfehlerausgabe umleiten
find liste1.txt >& fehler.log
# Ausgabe:
cat fehler.log
# Beispiel 4: Standard- und Standardfehlerausgabe
# in jeweils getrennte Dateien umleiten
cat datei*.txt > ergebnis.txt 2> fehlerlog.txt
# Ausgabe
cat ergebnis.txt
echo "------------------------"
cat fehlerlog.txt

Ein-/Ausgabekanäle anlegen

Bei Bedarf erweitern Sie die standardmäßig vorhandenen Kanäle 0 (STDIN, Standardeingabe), 1 (STDOUT, Standardausgabe) und 2 (STDERR, Standardfehlerausgabe) um weitere. Dafür stehen die Kanäle 3 bis 9 bereit.

In der Praxis leiten Sie so komfortabel Daten in verschiedene Dateien oder Geräte um. Tabelle “File-Deskriptoren” zeigt die Regeln für die zusätzlichen Kanäle. Bei Kanälen zum Lesen und Schreiben gilt es, beide Schritte zum Aufheben vorzunehmen.

Hier hängen Sie Ausgaben ebenfalls an bestehende Dateien an, indem Sie das Zeichen > doppelt verwenden. Nicht mehr benötigte Deskriptoren sollten Sie unbedingt wieder aufheben. Ein selbsterklärendes Anwendungsbeispiel finden Sie in Listing 13.

#! /bin/bash
# Testdateien erzeugen
echo -e "erste\nzweite\ndritte\n" > eingabe.txt
echo -e "eins\nzwei\ndrei\n" > puffer.txt
echo "Das ist lesbar"
# Anlegen Ausgabekanal 3:
exec 3>zieldatei2.txt
# Anlegen Eingabekanal 4:
exec 4<eingabe.txt
# Anlegen Ein-/Ausgabekanal 5:
exec 5<>puffer.txt
# Setzen Umleitung stdout und stderr
exec >zieldatei1.txt 2>fehlerlog
echo "Das kommt in die Datei"
# Ausgabe über Kanal 3
echo "Das kommt in die andere Datei" >&3
echo "Die einzelne Anweisung zur Umleitung ist nicht nötig!"
# Erzeugen einer Fehlermeldung
ls neuedatei.txt
# Auslesen aus Kanal 4 und schreiben auf Kanal 3:
read A <&4
echo $A >&3
# Benutzung der Datei puffer.txt
tail -1 <&5
echo "Neue Zeile" >&5
# Schließen zusätzlicher Kanäle:
exec 3>&-
exec 4<&-
exec 5<&-
exec 5>&-

Tests für die Shell

Das Paket coreutils enthält ein Werkzeug namens Test, um Entscheidungen auf der Basis von Tests zu treffen. Es wertet das Zutreffen bestimmter Bedingungen aus; als Kriterien kommen Vergleiche von Zahlen, Zeichenketten oder Eigenschaften von Objekten im Verzeichnisbaum des Rechners infrage.

Der Befehl kennt zwei unterschiedliche Formen der Syntax. In der Klammerform, die in der Praxis häufig vorkommt, steht die Anweisung innerhalb eckiger Klammern (if [ $? -eq 0 ]). Beachten Sie, dass zwischen der eckigen Klammer und dem Inhalt ein Leerzeichen stehen muss. In der ausgeschriebenen Form fallen die eckigen Klammern weg (if test $? -eq 0).

Der Befehl gibt einen Exit-Code aus. Die 0 steht dabei für “wahr”, die 1 für “falsch”. Es gibt die Möglichkeit, Ausdrücke zu negieren. Das signalisieren Sie durch ein mit Leerzeichen abgetrenntes, vorangestelltes Ausrufezeichen ([ ! -e Datei ]). Die Tabelle “Test-Varianten” liefert eine Übersicht über die Möglichkeiten des Tools.

Fazit

Wer die Möglichkeiten einer Shell wie der Bash voll ausreizt, kommt meist im ersten Anlauf ohne eine weitere Programmiersprache aus. Einfache Abläufe und Abfragen (selbst mit Benutzerinteraktion) sowie komplexe Operationen auf Dateien gelingen ohne zusätzliche Tools. Beim Arbeiten mit den Skripten erleben Sie außerdem die grundlegenden Funktionsprinzipien eines Linux-Systems in Aktion. Das vermittelt wertvolle Aufschlüsse, die Ihnen dann an anderen Stellen weiterhelfen.