3.1 Grundsätzliches

Zunächst soll die Frage geklärt werden, wie man überhaupt ein ausführbares Shell-Skript schreibt. Dabei wird vorausgesetzt, dass dem Benutzer der Umgang mit mindestens einem Texteditor ( vi,  emacs etc.) bekannt ist.

3.2 Variablen

In einem Shell-Skript hat man - genau wie bei der interaktiven Nutzung der Shell - Möglichkeiten, über Variablen zu verfügen. Anders als in den meisten modernen Programmiersprachen gibt es aber keine Datentypen wie Ganzzahlen, Fließkommazahlen oder Strings. Alle Variablen werden als String gespeichert. Wenn die Variable die Funktion einer Zahl übernehmen soll, dann muss das verarbeitende Programm die Variable entsprechend interpretieren. (Für arithmetische Operationen steht das Programm expr zur Verfügung, siehe Zählschleifen-Beispiel unter  while)

Man muss bei der Benutzung von Variablen sehr aufpassen, wann die Variable expandiert wird und wann nicht. (Mit Expansion ist das Ersetzen des Variablennamens durch den Inhalt gemeint). Grundsätzlich werden Variablen während der Ausführung des Skriptes immer an den Stellen ersetzt, an denen sie stehen. Das passiert in jeder Zeile, unmittelbar bevor sie ausgeführt wird. Es ist also auch möglich, in einer Variable einen Shell-Befehl abzulegen. Im Folgenden kann dann der Variablenname an der Stelle des Befehls stehen. Um die Expansion einer Variable zu verhindern, benutzt man das Quoting (siehe unter  Quoting).

Wie aus diversen Beispielen hervorgeht, belegt man eine Variable, indem man dem Namen mit dem Gleichheitszeichen einen Wert zuweist. Dabei darf zwischen dem Namen und dem Gleichheitszeichen keine Leerstelle stehen, ansonsten erkennt die Shell den Variablennamen nicht als solchen und versucht, ein gleichnamiges Kommando auszuführen - was meistens durch eine Fehlermeldung quittiert wird.

Wenn man auf den Inhalt einer Variablen zugreifen möchte, leitet man den Variablennamen durch ein $-Zeichen ein. Alles was mit einem $ anfängt wird von der Shell als Variable angesehen und entsprechend behandelt (expandiert).

3.3 Vordefinierte Variablen

Es gibt eine Reihe von vordefinierten Variablen, deren Benutzung ein wesentlicher Bestandteil des Shell-Programmierens ist. Die wichtigsten eingebauten Shell-Variablen sind:

3.4 Variablen-Substitution

Unter Variablen-Substitution versteht man verschiedene Methoden um die Inhalte von Variablen zu benutzen. Das umfaßt sowohl die einfache Zuweisung eines Wertes an eine Variable als auch einfache Möglichkeiten zur Fallunterscheidung. In den fortgeschritteneren Shell-Versionen (bash, ksh)existieren sogar Möglichkeiten, auf Substrings von Variableninhalten zuzugreifen. In der Standard-Shell benutzt man für solche Zwecke üblicherweise den Stream-Editor sed. Einleitende Informationen dazu finden sich im Kapitel über die  Mustererkennung).

Die folgenden Mechanismen stehen in der Standard-Shell bereit, um mit Variablen zu hantieren. Bei allen Angaben ist der Doppelpunkt optional. Wenn er aber angegeben wird, muss die Variable einen Wert enthalten.

3.5 Quoting

Dies ist ein sehr schwieriges Thema, da hier mehrere ähnlich aussehende Zeichen völlig verschiedene Effekte bewirken. Unix unterscheidet allein zwischen drei verschiedenen Anführungszeichen. Das Quoten dient dazu, bestimmte Zeichen mit einer Sonderbedeutung vor der Shell zu 'verstecken' um zu verhindern, dass diese expandiert (ersetzt) werden.

Die folgenden Zeichen haben eine spezielle Bedeutung innerhalb der Shell:

Die folgenden Zeichen können zum Quoten verwendet werden:

Beispiele:

3.6 Meta-Zeichen

Bei der Angabe von Dateinamen können eine Reihe von Meta-Zeichen verwendet werden, um mehrere Dateien gleichzeitig anzusprechen oder um nicht den vollen Dateinamen ausschreiben zu müssen. (Meta-Zeichen werden auch Wildcards, Joker-Zeichen oder Platzhalter genannt.)

Die wichtigsten Meta-Zeichen sind:

3.7 Mustererkennung

Man unterscheidet in der Shell-Programmierung zwischen den Meta-Zeichen, die bei der Bezeichnung von Dateinamen eingesetzt werden und den Meta-Zeichen, die in mehreren Programmen Verwendung finden, um z. B. Suchmuster zu definieren. Diese Muster werden auch reguläre Ausdrücke (regular expression) genannt. Sie bieten wesentlich mehr Möglichkeiten als die relativ einfachen Wildcards für Dateinamen.

In der folgenden Tabelle wird gezeigt, in welchen Unix-Tools welche Zeichen zur Verfügung stehen. Eine ausführlichere Beschreibung der Einträge findet sich danach.

Bei einigen Tools (ex, sed und ed) werden zwei Muster angegeben: Ein Suchmuster (links) und ein Ersatzmuster (rechts). Nur die folgenden Zeichen sind in einem Ersatzmuster gültig:

Sonderzeichen in Suchmustern:

Sonderzeichen in Ersatzmustern:

Beispiele: egrep- oder awk-Muster

Beispiele: sed- oder grep-Muster

3.8 Programmablaufkontrolle

Bei der Shell-Programmierung verfügt man über ähnliche Konstrukte wie bei anderen Programmiersprachen, um den Ablauf des Programms zu steuern. Dazu gehören Funktionsaufrufe, Schleifen, Fallunterscheidungen und dergleichen.

3.9 Kommentare (#)

Kommentare in der Shell beginnen immer mit dem Nummern-Zeichen (#). Dabei spielt es keine Rolle, ob das Zeichen am Anfang der Zeile steht, oder hinter irgendwelchen Befehlen. Alles von diesem Zeichen bis zum Zeilenende (bis auf eine Ausnahme - siehe unter  Auswahl der Shell).

3.10 Auswahl der Shell (#!)

In der ersten Zeile eines Shell-Skriptes sollte definiert werden, mit welcher Shell das Skript ausgeführt werden soll. Das System öffnet dann eine Subshell und führt das restliche Skript in dieser aus.

Die Angabe erfolgt über eine Zeile in der Form #!/bin/sh, wobei unter /bin/sh die entsprechende Shell (in diesem Fall die Bourne-Shell) liegt. Dieser Eintrag wirkt nur dann, wenn er in der ersten Zeile des Skripts steht.

3.11 Null-Befehl (:)

Dieser Befehl tut nichts, außer den Status 0 zurückzugeben. Er wird benutzt, um Endlosschleifen zu schreiben (siehe unter  while), oder um leere Blöcke in  if- oder  case-Konstrukten möglich zu machen.

if who | grep $1 > /dev/null # who: Liste der Benutzer
                             # grep: Suche nach Muster
then :                       # tut nichts
  else echo "Benutzer $1 ist nicht angemeldet"
fi
     

3.12 Source (.)

Der Source-Befehl wird in der Form . skriptname angegeben. Er bewirkt ähnliches wie ein #include in der Programmiersprache C.

Die Datei (auf die das Source ausgeführt wurde) wird eingelesen und ausgeführt, als ob ihr Inhalt an der Stelle des Befehls stehen würde. Diese Methode wird zum Beispiel während des Bootvorgangs in den Init-Skripten benutzt, um immer wieder benötigte Funktionen (Starten eines Dienstes, Statusmeldungen auf dem Bildschirm etc.) in einer zentralen Datei pflegen zu können (siehe Beispiel unter  Ein typisches Init-Skript).

3.13 Funktionen

Es ist in der Shell auch möglich, ähnlich wie in einer 'richtigen' Programmiersprache, Funktionen zu deklarieren und zu benutzen. Da die Bourne-Shell (sh) nicht über Aliase verfügt, können einfache Funktionen als Ersatz dienen. Mit dem Kommando  exit hat man die Möglichkeit, aus einer Funktion einen Wert zurückzugeben.

count () {
      ls | wc -l # ls: Liste aller Dateien im Verzeichnis
      # wc: Word-Count, zählt Wörter
}
     

3.14 Bedingungen ([ ])

Da die Standard-Shell keine arithmetischen oder logischen Ausdrücke auswerten kann, muss dazu ein externes Programm benutzt werden. (if und Konsorten prüfen nur den Rückgabewert eines aufgerufenen Programmes -- 0 bedeutet true, alles andere bedeutet false, siehe auch  Rückgabewerte) Dieses Programm heißt test. Üblicherweise besteht auf allen Systemen auch noch ein Link namens [ auf dieses Programm. Dieser Link ist absolut gleichwertig zu benutzen. Dementsprechend ist es auch zwingend erforderlich, nach der Klammer ein Leerzeichen zu schreiben. Das dient dazu, Bedingungen in if-Abfragen u. ä. lesbarer zu machen. Um dieses Konzept der Lesbarkeit zu unterstützen, sollte man diese öffnende Klammer auch wieder schließen (obwohl das nicht zwingend nötig ist).

Das test-Programm bietet sehr umfangreiche Optionen an. Dazu gehören Dateitests und Vergleiche von Zeichenfolgen oder ganzen Zahlen. Diese Bedingungen können auch durch Verknüpfungen kombiniert werden. Dateitests:

Bedingungen für Zeichenfolgen:

Ganzzahlvergleiche:

Kombinierte Formen:

3.15 if. . .

Die if-Anweisung in der Shell-Programmierung macht das gleiche wie in allen anderen Programmiersprachen, sie testet eine Bedingung auf Wahrheit und macht davon den weiteren Ablauf des Programms abhängig.

Die Syntax der if-Anweisung lautet wie folgt:

if Bedingung1
   then Befehle1
   [ elif Bedingung2
   then Befehle2 ]
   ...
   [ else Befehle3 ]
fi
     

Wenn die Bedingung1 erfüllt ist, werden die Befehle1 ausgeführt; andernfalls, wenn die Bedingung2 erfüllt ist, werden die Befehle2 ausgeführt. Trifft keine Bedingung zu, sollen die Befehle3 ausgeführt werden.

Bedingungen werden normalerweise mit dem Befehl  test formuliert. Es kann aber auch der   Rückgabewert jedes anderen Kommandos ausgewertet werden. Für Bedingungen, die auf jeden Fall zutreffen sollen steht der  Null-Befehl :) zur Verfügung.

#!/bin/sh
# Füge eine 0 vor Zahlen kleiner 10 ein:
if [ $counter -lt 10 ]; then
   number=0$counter; else number=$counter; fi

# Erstelle ein Verzeichnis, wenn es noch nicht existiert:
if [ ! -e $dir ]; then
   mkdir $dir; fi # mkdir: Verzeichnis erstellen
     

3.16 case. . .

Auch die case-Anweisung ist vergleichbar in vielen anderen Sprachen vorhanden. Sie dient, ähnlich wie die if-Anweisung, zur Fallunterscheidung. Allerdings wird hier nicht nur zwischen zwei Fällen unterschieden (Entweder / Oder), sondern es sind mehrere Fälle möglich. Man kann die case-Anweisung auch durch eine geschachtelte if-Anweisung völlig umgehen, allerdings ist sie ein elegantes Mittel um den Code lesbar zu halten.

Die Syntax der case-Anweisung lautet wie folgt:

#!/bin/sh
case Wert in
     Muster1) Befehle1;;
     Muster2) Befehle2;;
     ...
esac
     

Wenn der Wert mit dem Muster1 übereinstimmt, wird die entsprechende Befehlsgruppe (Befehle1) ausgeführt, bei Übereinstimmung mit Muster2 werden die Kommandos der zweiten Befehlsgruppe (Befehle2) ausgeführt, usw. Der letzte Befehl in jeder Gruppe muss mit ;; gekennzeichnet werden. Das bedeutet für die Shell soviel wie springe zum nächsten esac, so dass die anderen Bedingungen nicht mehr überprüft werden.

In den Mustern sind die gleichen Meta-Zeichen erlaubt wie bei der Auswahl von Dateinamen. Wenn in einer Zeile mehrere Muster angegeben werden sollen, müssen sie durch ein Pipezeichen (|, logisches ODER) getrennt werden.

#!/bin/sh
# Mit dem ersten Argument in der Befehlszeile
# wird die entsprechende Aktion festgelegt:

case $1 in # nimmt das erste Argument
     Ja|Nein) response=1;;
              -[tT]) table=TRUE;;
           *) echo "Unbekannte Option"; exit 1;;
esac

# Lies die Zeilen von der Standardeingabe, bis eine
# Zeile mit einem einzelnen Punkt eingegeben wird:

while : # Null-Befehl (immer wahr, siehe unter 3.11)

do
        echo "Zum Beenden . eingeben ==> \c"
        read line # read: Zeile von StdIn einlesen
        case "$line" in
             .) echo "Ausgefuehrt"
                break;;
             *) echo "$line" >> $message ;;
        esac
done
     

3.17 for. . .

Dieses Konstrukt ähnelt nur auf den ersten Blick seinen Pendants aus anderen Programmiersprachen. In anderen Sprachen wird die for-Schleife meistens dazu benutzt, eine Zählvariable über einen bestimmten Wertebereich iterieren zu lassen (for i = 1 to 100...next). In der Shell dagegen wird die Laufvariable nicht mit aufeinanderfolgenden Zahlen belegt, sondern mit einzelnen Werten aus einer anzugebenden Liste. (Wenn man trotzdem eine Laufvariable braucht, muss man dazu die  while-Schleife mißbrauchen.

Die Syntax der for-Schleife lautet wie folgt:

#!/bin/sh
for x [ in Liste ]
do
        Befehle
done
     

Die Befehle werden ausgeführt, wobei der Variablen x nacheinander die Werte aus der Liste zugewiesen werden. Wie man sieht ist die Angabe der Liste optional, wenn sie nicht angegeben wird, nimmt x der Reihe nach alle Werte aus $@ (in dieser vordefinierten Variablen liegen die Aufrufparameter - siehe unter  Datenströme) an. Wenn die Ausführung eines Schleifendurchlaufs bzw. der ganzen Schleife abgebrochen werden soll, müssen die Kommandos  continue bzw.  break benutzt werden.
Beispiele:

#!/bin/sh
# Seitenweises Formatieren der Dateien, die auf der
# Befehlszeile angegeben wurden, und speichern des
# jeweiligen Ergebnisses:

for file do
    pr $file > $file.tmp # pr: Formatiert Textdateien
done

# Durchsuche Kapitel zur Erstellung einer Wortliste (wie fgrep -f):

for item in `cat program_list` # cat: Datei ausgeben
do
        echo "Pruefung der Kapitel auf"
        echo "Referenzen zum Programm $item ..."
        grep -c "$item.[co]" chap* # grep: nach Muster suchen
done

# Ermittle einen Ein-Wort-Titel aus jeder Datei und
# verwende ihn als neuen Dateinamen:

for file do
    name=`sed -n 's/NAME: //p' $file`
    # sed: Skriptsprache zur
    # Textformatierung
    mv $file $name
    # mv: Datei verschieben
    # bzw. umbenennen
done
     

3.18 while. . .

Die while-Schleife ist wieder ein Konstrukt, das einem aus vielen anderen Sprachen bekannt ist: Die kopfgesteuerte Schleife.

Die Syntax der while-Schleife lautet wie folgt:

#!/bin/sh
while Bedingung
do
        Befehle
done
     

Die Befehle werden so lange ausgeführt, wie die Bedingung erfüllt ist. Dabei wird die Bedingung vor der Ausführung der Befehle überprüft. Die Bedingung wird dabei üblicherweise, genau wie bei der if-Anweisung, mit dem Befehl  test) formuliert. Wenn die Ausführung eines Schleifendurchlaufs bzw. der ganzen Schleife abgebrochen werden soll, müssen die Kommandos  continue bzw.  break benutzt werden.
Beispiel:

#!/bin/sh
# Zeilenweise Ausgabe aller Aufrufparameter:

while [ -n "$1"]; do
      echo $1
      shift     # mit shift werden die Parameter nach
                # Links geshiftet (aus $2 wird $1)
done
     

Eine Standard-Anwendung der while-Schleife ist der Ersatz für die Zählschleife. In anderen Sprachen kann man mit der for-Schleife eine Zählvariable über einen bestimmten Wertebereich iterieren lassen (for i = 1 to 100...next). Da das mit der for-Schleife der Shell nicht geht, ersetzt man die Funktion durch geschickte Anwendung der while-Schleife:

#!/bin/sh
# Ausgabe der Zahlen von 1 bis 100:

i=1
while [ $i -le 100 ]
do
        echo $i
        i=`expr $i + 1`
done
     

3.19 until. . .

Die until-Schleife ist das Gegenstück zur while-Schleife: Die ebenfalls aus vielen anderen Sprachen bekannte Schleife.

Die Syntax der until-Schleife lautet wie folgt:

#!/bin/sh
until Bedingung
do
        Befehle
done
     

Die Befehle werden ausgeführt, bis die Bedingung erfüllt ist. Die Bedingung wird dabei üblicherweise, genau wie bei der if-Anweisung, mit dem Befehl  test) formuliert. Wenn die Ausführung eines Schleifendurchlaufs bzw. der ganzen Schleife abgebrochen werden soll, müssen die Kommandos  continue bzw.  break benutzt werden.

#!/bin/sh
# Warten, bis sich der Administrator einloggt:

until who | grep "root"; do
      # who: Liste der Benutzer
      # grep: Suchen nach Muster
      sleep 2 # sleep: warten
done
echo "Der Meister ist anwesend"
     

3.20 continue

Die Syntax der continue-Anweisung lautet wie folgt:

#!/bin/sh
continue [ n ]
     

Man benutzt continue um die restlichen Befehle in einer Schleife zu überspringen und mit dem nächsten Schleifendurchlauf anzufangen. Wenn der Parameter n angegeben wird, werden n Schleifenebenen übersprungen.

3.21 break

Die Syntax der break-Anweisung lautet wie folgt:

break [ n ]
     

Mit break kann man die innerste Ebene (bzw. n Schleifenebenen) verlassen ohne den Rest der Schleife auszuführen.

3.22 exit

Die Syntax der exit-Anweisung lautet wie folgt:

exit [ n ]
     

Die exit-Anweisung wird benutzt, um ein Skript zu beenden. Wenn der Parameter n angegeben wird, wird er von dem Skript als Exit-Code zurückgegeben.

3.23 Befehlsformen

Es gibt eine Reihe verschiedener Möglichkeiten, Kommandos auszuführen:

3.24 Datenströme

Eines der markantesten Konzepte, das in Shell-Skripten benutzt wird, ist das der Datenströme. Die meisten der vielen Unix-Tools bieten die Möglichkeit, Eingaben aus der sogenannten Standard-Eingabe entgegenzunehmen und Ausgaben dementsprechend auf der Standard-Ausgabe zu machen. Es gibt noch einen dritten Kanal für Fehlermeldungen, so dass man eine einfache Möglichkeit hat, fehlerhafte Programmdurchläufe zu behandeln indem man die Fehlermeldungen von den restlichen Ausgaben trennt.

Es folgt eine Aufstellung der drei Standardkanäle:

Die standardmäßige Eingabequelle oder das Ausgabeziel können wie folgt geändert werden:

Zwischen den Datei-Deskriptoren und einem Umlenkungssymbol darf kein Leerzeichen sein; in anderen Fällen sind Leerzeichen erlaubt.
Beispiele:

Gerade der Mechanismus mit dem Piping sollte nicht unterschätzt werden. Er dient nicht nur dazu, relativ kleine Texte zwischen Tools hin- und herzureichen. An dem folgenden Beispiel soll die Mächtigkeit dieses kleinen Zeichens gezeigt werden:

Es ist mit den passenden Tools unter Unix möglich, eine ganze Audio-CD mit zwei Befehlen an der Kommandozeile zu duplizieren. Das erste Kommando veranlaßt, dass die TOC (Table Of Contents) der CD in die Datei cd.toc geschrieben wird. Das dauert nur wenige Sekunden. Die Pipe steckt im zweiten Befehl. Hier wird der eigentliche Inhalt der CD mit dem Tool  cdparanoia ausgelesen. Da kein Dateiname angegeben schreibt cdparanoia die Daten auf seine Standardausgabe. Diese wird von dem Brennprogramm cdrdao übernommen und in Verbindung mit der TOC on the fly auf die CD geschrieben.

#!/bin/sh
cdrdao read-toc --datafile - cd.toc
cdparanoia -q -R 1- - | cdrdao write --buffers 64 cd.toc