Eine große Vielseitigkeit der Shell ist das man jedes Kommando mit allen Optionen aufrufen kann während man in einem z.B. grafischen oder menügesteuertem System nur die Aktionen wählen kann die einem angezeigt werden.


Die Arbeit mit einer Shell geschieht interaktiv. Die Shell liefert ein Prompt (Eingabeaufforderung), und ein User kann es mit Kommandos füllen. Wird eine solche Kommandozeile mit ENTER bestätigt, interpretiert die Shell die Zeile und führt die Kommandos aus. Da manche Kommandos recht lange sind oder häufig gebraucht werden kann man diese auch in Scriptdateien schreiben.


Es gibt viele Shells wie z.B. die tcsh, csh, sh, ksh oder wie sie alle heißen mögen. Ich beziehe mich im folgendem auf die bash auch bourne again shell genannt, welche in den meisten Distributionen die Standardshell ist. Sie ist eine Erweiterung der bourne shell (sh) mit nützlichen Features anderer Shells.

Am Anfang sieht man eine Zeile die in etwa so aussieht:


woody@camel:~$


Wenn so etwas sieht wartet die Shell sozusagen auf ein Kommando. Da steht am Anfang der Username, durch ein @ getrennt vom Hostnamen des Rechners. Nach dem : steht das aktuelle Verzeichnis und bei einem User am Ende ein $, bei root steht am Ende ein #. Natürlich kann man das, wie alles andere auch, an seine Bedürfnisse anpassen. Dazu muss man nur die Environment Variable PS1 entsprechend setzen mit export. Mögliche Werte sind z.B.:

Ein Kommando besteht üblicherweise aus 3 Teilen und sieht so aus:


Befehl Optionen Argumente


Der Befehl ist das zu startende Programm (Script). Die Optionen können Anweisungen für das Programm sein und werden üblicherweise mit einem - eingeleitet, z.B. was es machen soll oder wie. Als Argument wird oft übergeben mit was sich der Befehl beschäftigen soll. Das sind oft Dateien oder Geräte kann aber auch irgendwas anderes sein. Bei vielen Kommandos sind die Optionen und Argumente optional und können auch weggelassen werden.


Eine Option die fast jedes Programm hat ist --help dabei wird eine kurze Übersicht der verfügbaren Optionen gezeigt und sollte das nicht reichen kann man mit man Befehl die man-page zu dem Befehl durchstöbern (q zum beenden ;o)).


Wird ein Kommando mit ENTER bestätigt, interpretiert die Shell dieses. Dabei werden z.B. Klammern ausgewertet und Variablen ersetzt. Anschließend wird ein Unterprozess gestartet der das Kommando ausführt und nach Beendigung liefert die Shell wieder einen Prompt.


Man kann Programme auch im Hintergrund starten mit &, dabei wird gleich wieder ein Prompt angezeigt ob das Kommando abgearbeitet ist oder nicht. Wenn Ein Programm gestartet ist kann man es mit STRG+Z in den Hintergrund schicken, dann sieht man die Nummer des Hintergrundprozesses. Dabei wird es aber auch gestoppt, damit es weiter läuft muss man noch bg Nummer eintippen. Und mit fg Nummer holt man sich den Prozess wieder in den Vordergrund.


Soll ein Kommando der Übersicht halber über mehrere Zeilen gehen kann man mit \ ENTER in der nächsten Zeile weiter schreiben ohne das das Kommando schon ausgeführt wird.


STDIN STDOUT & STDERR


Kommandos kommunizieren standardmäßig über 3 Ebenen, Standardeingabe (STDIN, oder 0), Standardausgabe (STDOUT, oder 1) und Standardfehlerausgabe (STDERR, oder 2). Eingaben werden über STDIN angenommen und ein Output an STDOUT geschickt, wobei Fehlermeldungen auf STDERR erscheinen.


Kommandosubstitution


Das sind Kommandos innerhalb anderer Kommandos, um z.B. als Argumente zu dienen. Sie werden zwischen verkehrten Anführungsstriche geschrieben `Kommando`. Man kann damit auch den Output eines Kommandos einer Variablen zuweisen.

Listen


Eine Folge von Kommandos kann zu einer Liste zusammengefügt werden. Die Kommandos werden dabei mit den Zeichen &&, ||, & und ; zu einer Liste zusammengefasst. Sie muss weiters mit einem &, ; oder Zeilenende abgeschlossen werden.


Listen mit ; und &


; Trennt 2 Kommandos voneinander. Diese werden nacheinander ausgeführt. Ein Prompt erscheint erst wieder wenn alle Kommandos durchgeführt sind
& Trennt 2 Kommandos voneinander oder führt eines im Hintergrund aus. Diese werden gleichzeitig ausgeführt. Es erscheint sofort wieder ein Prompt
Bei beiden ist der Rückgabewert der des letzten Kommandos


Listen mit && und || (Bedingte Ausführung)


&& führt das rechte Kommando nur aus wenn das linke erfolgreich war
beide Kommandos müssen erfolgreich sein damit die Bedingung wahr (Rückgabewert von 0) ist
|| führt das rechte Kommando nur aus wenn das linke nicht erfolgreich war
nur ein Kommando muss erfolgreich sein damit die Bedingung wahr ist


Gruppen


Kommandos können weiter zu Gruppen zusammengefasst werden um z.B. komplexere Listen zu erstellen


{ } einfache Gruppe


( ) Gruppe in einer eigenen Shell. Dadurch kann man in einem Kommando einen Teil von einer Subshell ausführen lassen. Dabei sind Veränderungen am Environment nur für diesen Teil wirksam und nicht für das restliche Kommando.

Einige Kommandos werden mit einem bestimmten Symbol eingeleitet oder müssen damit aufhören, wie z.B. eine for-Schleife die mit for beginnt und done endet, ein Text in "Anführungsstrichen" oder ein Kommando in (Klammern). Wird nun eine Zeile eingegeben in der so ein Schluss-Symbol fehlt bemerkt das die Shell und gibt in einer neuen Zeile ein sekundäres Prompt aus in der man das Kommando weiter tippen kann.


Wie gesagt können manche Kommandos sehr umfangreich sein und darum gibt es den Kommandozeileneditor. Er bietet neben den einfachen Funktionen wie Zeichen vor, zurück, oder löschen, noch eine Menge Funktionen wie ausschneiden, einfügen, in der Zeile springen usw. Die Funktionen sind denen von vi und emacs nachempfunden wobei man normalerweise im emacs-Modus arbeitet. Mit set emacs und set vi kann man zwischen den Modi wechseln. Natürlich kann man sich das Verhalten auch an seine Bedürfnisse anpassen z.B. mit bind. Um die Belegung dauerhaft zu speichern muss man das noch in der Datei ~/.inputrc eintragen. Will man die Belegung für alle User speichern so muss die Datei /etc/inputrc editiert werden (bzw. die Datei die in der Shell variablen INPUTRC steht). Der Aufbau von inputrc und dem bind Kommando ist gleich:


Taten:Funktion


Jetzt kommen erst mal ein paar nützliche bind Optionen dann die Zeichen für spezielle Tasten und ein paar Beispiele.

Da man oft recht lange Befehle eintippt ist es mühsam mit Pfeil links/rechts zu navigieren oder Zeichen einzeln zu löschen. Damit das etwas flotter geht hier mal ein paar Tastatur befehle:

Ein sehr nützliches Feature der Shell ist der Kommandozeilenspeicher die so genannte history. In Ihr sind die letzten Befehle gespeichert. Das erspart einem sehr viel Tipparbeit wenn man Kommandos immer wieder in gleicher oder ähnlicher Form braucht. In diesem Fall navigiert man zum entsprechendem Kommando und wiederholt es.

So wie überall gibt es auch hier eine Reihe von Zeichen die besonderes bewirken. Da gibt es einige um Kommandos zu verbinden oder zu trennen, welche um Teile eines Kommandos gesondert auszuführen, oder Ein/Ausgaben umzuleiten. Hier mal die wichtigsten:

Wenn man ein Metazeichen als normales Zeichen behandeln will so muss man es entwerten. Dazu gibt es folgende 3 Möglichkeiten.

Jedes Kommando kann einen Status zurückgeben der Aufschluss darüber gibt wie das Programm beendet wurde. Anders als bei anderen Programmiersprachen ist der Rückgabewert eines erfolgreichen Kommandos 0. Den Status des zuletzt ausgeführten Kommandos kann man in der Variablen $? nachsehen

Wie in jeder Programmiersprache gibt es in der Shell auch reservierte Wörter die man nicht für Variablen oder Funktionen benutzen darf.


! case do done elif else esac fi for function if in select then time until while {}

Variablen


Variablen sind dazu da um Daten unter einem leichter zu merkenden Namen abzuspeichern. Variablennamen müssen mit einem Buchstaben oder _ beginnen und dürfen weiters nur Buchstaben, Ziffern und _ enthalten.


Wertzuweisung


variable=wert


Die Wertzuweisung Erfolg mit einem einfachen = Es darf kein Leerzeichen vor und nach dem = sein.


Variablen Löschen


Variablen werden mit dem Befehl unset gelöscht. Dazu gibt man einfach unset Variable ein.


Variablenzugriff


Wie man in den Beispielen schon sieht, werden anders als beim Wert zuweisen, die Variable mit einem $ vor dem Variablennamen angesprochen. Um den Inhalt einer Variablen anzusehen gibt man einfach echo $Variable ein.


Erweiterte Wertzuweisung


Manchmal ist es sinnvoll eine Variable abhängig von einer anderen zu setzten. Mit der erweiterten Wertzuweisung wird eine Variable auf vorhanden sein geprüft. Wenn sie vorhanden und nicht leer ist wird sie eingesetzt ansonsten der Angegebene Wert.
Folgendes ist vielleicht erst nach ein paar mal lesen verständlich:

Environment


Das Environment, auch Umgebungsvariablen genannt, ist eine Sammlung von Variablen auf die ein Programm zugreift. Um sich das Environment anzusehen gibt man export ein. Hier nun ein Auszug aus den Environment-Variablen:

Vererbung


Wird ein Prozess gestartet legt die Shell für jeden Wert im Environment eine Variable an, und übergibt diese dem Prozess. Verändert ein Prozess eine Variable hat das nur Auswirkungen aus das vererbte Environment, nicht auf das der anderen Programme. Wäre ja schlimm wenn sich die Programme untereinander die Variablen überschreiben :o)


export


Mit dem Kommando export kann man eine Variable aus einem vererbten Environment ins Environment exportieren (setzen). Führt man das Kommando ohne Argumente aus sieht man die Werte des aktuellen Environment


set


set zeigt alle Variablen mit deren Werten an.

Besondere Variablen

Argument-Variablen innerhalb von Kommandos und Scripten

Platzhalter oder auch Wildcard genannt

Wenn man z.B. den Output eines Programms speichern will zwecks späterer Weiterverarbeitung, oder weil man einem Fehler sucht und so das Output an jemanden schicken kann der einem dann weiterhilft, kann man das mit einer Ausgabeumleitung machen. Man kann auch den Output eines Kommandos als Input für ein anderes benutzen.

Mit einem & lassen sich auch noch STDIN, STDOUT und STDERR untereinander vertauschen. Da gibt es eine Menge Kombinationen, ich will mal ein paar einfache veranschaulichen:

Um den Output eines Kommandos als Input für ein anderes zu benutzen, kann man eine Pipeline benutzen

Wie aus anderen Programmiersprachen bekannt gibt es in der bash auch gewisse Kontrollstrukturen wie for-Schleifen, while-, if- Bedingungen, case Verknüpfungen und select Abfragen. Wie diese funktionieren will ich mal versuchen zu verdeutlichen.


Die for Schleife


for Name [in Liste]
do
Kommando
done


for Name [in Liste]; do Kommando; done


Die for Schleife wird so oft durchlaufen wie es Argumente in der Liste gibt. Bei jedem Durchlauf nimmt die Variable Name den nächsten Wert in der Liste an, und die Kommandos zwischen do und done werden ausgeführt. Vor do und done muss eine neue Zeile beginnen oder mit einem ; ein Kommandoende stattgefunden haben. Als Liste kann auch der Inhalt des aktuellen Verzeichnisses dienen mit z.B.:


for Textdatei in *.txt
do
echo $Textdatei
done


Führt für jede gefundene .txt Datei im Verzeichnis ein echo aus


Die if Bedingung


if Kommando
then
Kommando


elif Kommando
then
Kommando


else
Kommando


fi


if Kommando; then Kommando; elif Kommando; then Kommando; else Kommando; fi


Mit if kann man das ausführen von Kommandos von Bedingungen abhängig machen. Das Kommando direkt nach if ist die Bedingung. Wenn sie einen Rückgabewert von 0 hat wird der then Teil ausgeführt. Wenn jedoch ein anderer Rückgabewert als 0 herauskommt, wird die nächste elif Bedingung geprüft und wenn wahr die Kommandos nach dessen then ausgeführt. Ist keine elif Anweisung vorhanden oder alle Bedingungen falsch, wird wenn vorhanden der else Teil ausgeführt. Vor then, elif, else und fi muss eine neue Zeile beginnen oder mit einem ; ein Kommandoende stattgefunden haben. Eine if Anweisung endet immer mit einem fi. Der elif und else Teil sind optional also kann eine Einfache if Anweisung schon so aussehen:


if test -d $dir
then
echo "$dir ist ein Verzeichnis"
fi


Damit wird, wenn es sich bei der Variablen $dir um ein Verzeichnis handelt, dies mit einem kurzen Text bestätigt.


Fallunterscheidung mit case


case Variable in
Wert1) Kommando
;;
Wert2) Kommando
;;
esac


case Variable in Wert1) Kommando; ;; Wert2) Kommando; ;; esac


Mit der case Anweisung kann ein Kommandoteil angesprungen werden. case überprüft die Variable auf Übereinstimmung bei den Werten die mit einem ) am Ende markiert sind. Bei einem Treffer werden die Kommandos dahinter bis zum nächsten ;; ausgeführt. Ein verständliches Beispiel ist folgendes welches eine Ja/Nein Abfrage behandeln soll:


case $variable in
ja|yes|j|y) echo "Auswahl bestätigt"
;;
nein|no|n) echo "Programm abgebrochen"
;;
esac


Um sich noch gegen User zu schützen die Prinzipiell nichts oder das falsche eintippen kann man eine erweiterte Wertzuweisung verwenden bzw. mit * eine Anweisung für alle anderen Eingaben erzeugen.


case ${Name:=nichts} in
ja|yes|j|y) echo "Auswahl bestätigt"
;;
nein|no|n) echo "Programm abgebrochen"
;;
nichts) echo "keine Eingabe"
;;
*) echo "falsche Eingabe"
;;
esac


Die while Schleife


while Kommando
do
Kommando
done


while Kommando; do Kommando; done


ähnlich wie die if Anweisung prüft while eine Bedingung auf wahr, und führt den Kommandoteil zwischen do und done aus. Der Unterschied ist jedoch das der Teil zw. do und done so oft wiederholt wird bis die Bedingung falsch ist. Auch hier muss vor do und done eine neue Zeile beginnen oder mit einem ; ein Kommandoende stattgefunden haben.


while read dir; test -d $dir
do
echo "$dir ist ein Verzeichnis"
done


Hier wird geprüft ob die Eingabe einem Verzeichnis entspricht, read fordert uns zu einer Eingabe auf die dann unter der Variablen dir gespeichert wird. Die Schleife geht so lange bis man ein ungültiges Verzeichnis eingibt.


Abfragen mit select


select Name in Wert1 Wert2 Wert3
do
echo "Die Auswahl war: $Name"
break
done


select Name in Wert1 Wert2 Wert3; do echo "Die Auswahl war: $Name"; break; done


Mit select lassen sich einfache Menüabfragen erstellen. Die möglichen Werte stehen nach dem in und werden bei einer Auswahl in die Variable, hier Name, gespeichert. Wird keine getroffen erscheint das Menü von neuem. Ansonsten wird der do Teil ausgeführt und auf eine weitere Eingabe gewartet. Daher sollte man eine select Anweisung mit einem break beenden.

Ein Terminal ist die Kombination aus Tastatur, Maus und Monitor und dient als Standardein- und Ausgabe. Da in einem Multiuser/Multitasking System mehrere User/Programme gleichzeitig arbeiten können benutzt Linux virtuelle Terminals um die Ein- Ausgabekanäle zu steuern. Dadurch kann es bestimmen welchem virtuellen Terminal die reale Tastatureingabe bzw. der echte Bildschirm zugewiesen wird.


Der Bildschirm auf dem die Bootmeldungen zu sehen sind entspricht der Konsole. Sobald das System gestartet ist wird diese mit 7 oder mehr virtuellen Konsolen überlagert. Zwischen Ihnen kann man mit ALT+F1 - F7 wechseln. Auf ALT+F7 befindet sich normalerweise das X System mit der grafischen Oberfläche.

So jetzt kennen wir den Aufbau von Kommandos und können auch schon kleine Shellscripte erstellen. Nur fehlen noch die Befehle die man benutzen kann. Nachstehend will ich ein paar wichtige Befehle und deren Optionen nach Aufgabengebiete beschreiben. Zusätzlich sollen auch überall ein paar einfache Beispiele sein. Wenn man mal mehr Infos als die hier angegebenen braucht sollte man nie auf man und --help vergessen.