UNIX Shellskripten
aus: Wie werde ich UNIX-Guru
und: UNIX-Das umfassende Handbuch
Willemers Informatik-Ecke
An dieser Stelle wird die Programmierung der Bourne Shell respektive der POSIX Shell diskutiert. Sie hat den Vorteil, dass sie auf jedem System vorhanden ist. Die Korn Shell und die bash (Linux) sind weitgehend kompatibel. Lediglich die C-Shell unterscheidet sich erheblich in der Syntax.

Erstellen und Start eines Shellskripts

Ein Shellskript ist eine Abfolge von Kommandos

Um einen Shellskript zu erzeugen, startet man einen Editor und führt einfach ein paar Kommandos hintereinander zeilenweise auf. Beispielsweise schreibt man in eine Datei namens skripttest: 

# Mein erster Skript
echo "ach ja"
ls 
echo "soso"

Kommentare

Das Kommentarzeichen in einer Skriptdatei ist das #. Alles, was in der gleichen Zeile dahinter steht, geht den Computer nichts an. Die nächste Zeile ist der echo Befehl, der einfach nur wiedergibt, was ihm als Parameter mitgegeben wird. Hier sagt er "ach ja". Danach wird das Inhaltsverzeichnis angezeigt und schließlich kommentiert das Ganze der echo mit "soso".

Ausführungs­rechte setzen

Um aus der Textdatei ein Programm zu machen, reicht es, den Skript ausführbar zu machen. Dazu verwendet man den Befehl chmod 755. Danach kann man ihn durch Eingeben des Dateinamens direkt starten. 

gaston> chmod 755 skripttest
gaston> skripttest
ach ja
skripttest
soso
gaston>

Variablen

Speicher und Namen

Die Shellskripten können mit Variablen arbeiten. Variablen sind Speicher für Daten, die über einen Namen angesprochen werden. Die Variablen der Shell entsprechen den bereits bekannten Umgebungsvariablen. Ihr Name beginnt mit einem Buchstaben und kann dann beliebig viele Ziffern und Buchstaben enthalten. Auch der Unterstrich ist zulässig.

Füllen und Auslesen

Variablen werden gefüllt, indem man dem Variablennamen ein Gleichheitszeichen und den Wert folgen lässt. Dabei darf kein Leerzeichen zwischen der Variablen, dem Gleichheitszeichen und dem zugewiesenen Wert stehen. Um sich auf den Inhalt einer Variablen zu beziehen wird dem Variablennamen ein Dollarzeichen vorangestellt. Zur Darstellung von Variablen wird der Befehl echo verwendet, der seine Argumente auf die Standardausgabe ausgibt.

Vordefinierte Variablen

Bestimmte Variablennamen sind vorbelegt. Beispielsweise erfährt die Shell über besondere Variablen, wie der Aufruf aussah. Mit $0 erhält man den Befehl, unter dem der Skript gerufen wurde. $1 ist der erste Parameter, $2 der zweite und so weiter. In der Variablen $# wird mitgeteilt, wieviele Parameter belegt wurden. Beispiel: 

# Skript dreh - Tauscht Parameter
echo "Ich heiße " $0 " und habe " $# "Parameter"
echo $2 $1

Der Skript soll dreh heißen. Nachdem mit chmod die Rechte auf ausführbar gesetzt wurden, kann man das Programm aufrufen. Das Ergebnis sieht so aus: 

arnold@gaston > dreh anton erna
Ich heiße  ./dreh  und habe  2 Parameter
erna anton
arnold@gaston >

Zusammenfassung der vordefinierten Variablen:

Variablen Inhalt
$1 $2 .. Parameterstrings
$0 Name der Kommandodatei
$# Anzahl der übergebenen Parameter

Zuweisungen

Variablen speichern Zeichenfolgen

Eine Variable wird dadurch definiert, dass sie das erste Mal benutzt wird. Typischerweise geschieht dies durch eine Zuweisung. Variablen der Shell halten Zeichenketten, die als Konstanten durch Anführungszeichen begrenzt werden. Damit auch Sonderzeichen aufgenommen werden können, wird eine Zeichenkette in Hochkommata eingeschlossen. Das Zuweisungszeichen ist das Gleichheitszeichen. Beispiele: 

a="a ist ein schlechter Name für eine Variable: zu kurz"
dieZahlPi=3.14

Wenn man mit echo $a oder echo $dieZahlPi anzeigt, so ist das Ergebnis genau das, was man den Variablen zugewiesen hat. Bevor aber zu hohe Erwartungen entstehen, ist zu sagen, das dieZahlPi keineswegs eine Zahl ist. Sie ist nur die Zeichenkette "3.14". Mit ganzen Zahlen kann man in Skripten rechnen. Dazu gibt es den Befehl expr. Der Befehl erwartet als Parameter einen numerischen Ausdruck wie etwa 3 + 3. Dabei ist darauf zu achten, dass zwischen den Zahlen und den Operanden ein Leerzeichen steht. Das Ergebnis solcher Rechenkünste kann man einklammern, ein $ davorstellen und es einer Variablen zuweisen. Das sieht dann so aus: 

a=$(expr 3 + 3)
b=$(expr $a \* 3)

expr braucht Leerzeichen zwischen seinen Argumenten

Wenn man per echo die Variablen a und b anschaut, stellt man fest, a ist nun 6 und b ist 18. Bei genauem Hinsehen sieht man, dass bei der Zuweisung kein Leerzeichen und hinter expr überall Leerzeichen stehen. An dieser Stelle ist der Interpreter äußerst pingelig. Natürlich fällt der Backslash vor dem * auf. Der ist notwendig, weil der Stern ja ein Sonderzeichen für die Shell ist. Damit der Stern den Befehl expr auch als Stern erreicht, muss man eben einen Backslash davor setzen. In der folgenden Tabelle steht nun, welche Operanden verwendet werden können.

Zeichen Bedeutung
+ Addition
- Subtraktion
* Multiplikation
/ Division
% Modulo: Rest einer Division

Die verwendbaren Operatoren in Shellskripten unterscheiden sich wenig von denen anderer Programmiersprachen.

Alternative let

Wie bereits beim Abschnitt über die Shell gezeigt wurde, gibt es bei den moderneren Nachfolgern der Bourneshell den Befehl let, mit dem das Rechnen etwas eleganter wird als der Aufruf von expr. Da die Schreibweise etwas leichter lesbar ist, wird man diese Variante bevorzugen, sofern sichergestellt ist, dass die Shell der Zielsysteme alle den Befehl let verstehen. Hier noch einmal ein paar Beispiele: 

gaston> let wert=45+5
gaston> echo $wert
50
gaston> let wert=16%5
gaston> echo $wert
1
gaston> let wert=(1+3)*2
gaston> echo $wert
8
gaston>

Ablaufsteuerung

Werden die Kommandos einfach nur hintereinander ausgeführt, spricht man von einem Batchlauf. Richtig interessant werden die Skripten aber erst, wenn man auf äußere Umstände reagieren kann oder Arbeitsabläufe wiederholen kann. Dazu dienen die Kommandos der Ablaufsteuerung. Dazu gehören Unterscheidungen und Schleifen.

Die Unterscheidung: if

Das Kommando if prüft eine Bedingung und führt den hinter dem then angegebenen Kommandoblock nur aus, wenn die Bedingung zutrifft. Das if kennt auch ein else. Darunter wird ein Kommandoblock zusammengefasst, der im anderen Fall ausgeführt wird, wenn also die Bedingung nicht zutrifft. Einen else-Zweig muss man allerdings nicht bilden. Das Kommando wird durch fi, also ein umgedrehtes if abgeschlossen. Die Struktur einer Unterscheidung sieht so aus: 

if Bedingung
then
  Befehle
else
  Befehle
fi

Die Befehle können einfach mehrere Programmaufrufe hintereinander sein. Es können aber durchaus auch wieder Ablaufkommandos sein. Man kann Ablaufkommandos also verschachteln. Informationen zu if finden sich normalerweise auf der Manpage der jeweiligen Shell. Bei der bash kann man aber auch help verwenden. Ohne Parameter werden die verfügbaren Befehle aufgezählt. Gibt man als Parameter beispielsweise if an, wird der Syntax und die Verwendung von if erläutert.

Bedingungen

Für die meisten Strukturbefehle muss auf eine Bedingung abgefragt werden. Dazu gibt es den Befehl test. Er liefert einen Wahrheitswert in Abhängigkeit seiner Parameter zurück. Dabei gilt

Ausdruck Wirkung
test -f Name ist DateiName eine existierende Datei?
test -d Name ist Name ein existierendes Verzeichnis?
test String ist String eine nichtleere Zeichenkette?
test String1 = String2 ist Zeichenkette String1 und String2 gleich?
test String1 != String2 ist Zeichenkette String1 und String2 ungleich?
test Nummer1 -eq Nummer2 ist Zahl Nummer1 gleich Nummer2?
test Nummer1 -ne Nummer2 ist Zahl Nummer1 ungleich Nummer2?
test Nummer1 -ge Nummer2 ist Zahl Nummer1 gr"o"ser oder gleich Nummer2?
test Nummer1 -gt Nummer2 ist Zahl Nummer1 gr"o"ser Nummer2?
test Nummer1 -le Nummer2 ist Zahl Nummer1 kleiner oder gleich Nummer2?
test Nummer1 -lt Nummer2 ist Zahl Nummer1 kleiner Nummer2?

Der Beispielskript dreh wird nun erweitert. Der Skript soll feststellen, ob er mit der richtigen Anzahl Parameter aufgerufen wurde. 

# Skript dreh - Tauscht Parameter
echo "Ich heiße " $0 " und habe " $# "Parameter"
if test $# -eq 2
then
    echo $2 $1
else
    echo "Falsche Parameterzahl"
fi

Rechteckige Klammern statt test

Da die Schreibweise mit dem Kommando test sehr gewöhnungsbedürftig für Benutzer anderer Programmiersprachen ist, gibt es dafür eine alternative Schreibweise. Dabei wird das Wort test durch eine eckige, öffnende Klammer ersetzt, die nach dem letzten Parameter von test wieder geschlossen wird. Das liest sich komplizierter als es ist. Das Beispiel macht es deutlich: 

# Skript dreh - Tauscht Parameter
echo "Ich heiße " $0 " und habe " $# "Parameter"
if [ $# -eq 2 ]
then
    echo $2 $1
else
    echo "Falsche Parameterzahl"
fi

Eine kleine Stolperfalle möchte ich Ihnen nicht vorenthalten. Im folgenden Skript soll eine Diskette formatiert werden, wenn der Parameter new angegeben wird. Das Abfragen des Parameters ist fast das gleiche wie beim Abfragen der Anzahl der Parameter. 

if [ $1 = "new" ]
then
    echo "Formatiere..."
fi
echo "Und los gehts..."

Nun rufen Sie den Skript dreimal auf! Einmal mit dem Parameter new, dann mit dem Parameter old und schließlich ohne Parameter. Und da gibt es eine Überraschung! 

gaston> trick new
Formatiere...
Und los gehts...
gaston> trick old
Und los gehts...
gaston> trick
./trick: [: =: unary operator expected
Und los gehts...
gaston>

Die Fehlermeldung sagt aus, dass der Operator = zwei Operanden erwartet hätte, aber nur einer da war. Tatsächlich wird $1 vor dem Vergleich ausgewertet und da dort nichts drin steht, ist zwischen der eckigem Klammer und dem Gleichheitszeichen nichts. Es ist also so, als würde dort folgender Ausdruck stehen: 

if [  = "new" ]

Die Variablen in Anführungszeichen können solche Überraschungen vermeiden. Wie bereits an anderer Stelle erwähnt, bewirken die Anführungszeichen das Zusammenfassen mehrerer Worte zu einem Parameter, aber es lässt im Gegensatz zu den Hochkommata die Auswertung der Variablen zu. 

if [ "$1" = "new" ]
then
    echo "Formatiere..."
fi
echo "Und los gehts..."

Auch wenn die Variablenauswertung von $1 leer ist, steht nun links vom Gleichheitszeichen etwas, nämlich zwei Anführungszeichen, also: 

if [ "" = "new" ]

Rückgabewert von Programmen

0 ist wahr, alles andere falsch

Aufgerufene Programme liefern einen Wert zurück, der über den Erfolg oder Misserfolg ihrer Tätigkeit Auskunft geben. Dabei ist es unter UNIX Standard, dass ein fehlerfrei gelaufenes Programm eine 0 zurückgibt. Diese wird dann von if als wahr interpretiert. Liefert das Programm dagegen eine Zahl ungleich 0 zurück, deutet das auf einen Fehler hin. Darum interpretiert if ein Ergebnis ungleich 0 als falsch. (Anm: Das ist für den C-Programmierer etwas ungewohnt, da dort eine 0 als falsch und alles andere als wahr interpretiert wird.)

cmp vergleicht Dateien

Einige dieser Programme sind geradezu prädestiniert für die Arbeit in Skripten. Der Befehl cmp vergleich zwei Dateien. Wird er mit der Option -s aufgerufen, macht er dabei keine Ausgaben. Er gibt bei Gleichheit 0, ansonsten 1 zurück.

Die Fallunterscheidung: case

Die Fallunterscheidung ist eine Art gestaffeltes if. Der Inhalt einer Variablen wird untersucht und für jeden denkbaren Inhalt eine Aktion definiert. Eine Anwendung findet sich in den rc-Skripten, die beim Booten des Systems gestartet werden. Hier wird unterschieden, ob als Parameter die Worte start oder stop oder ein anderes Schlüsselwort übergeben wurde. Zwischen den Schlüsselworten case und in steht die Variable, deren Inhalt zur Unterscheidung führen soll. Ein Unterscheidungszweig beginnt mit einem Begriff, der bearbeitet werden soll. Diese Maske schließt mit einer rechten Klammer und kann Wildcards verwenden, wie sie bei der Namensauswahl durch die Shell üblich sind. Es folgen die Kommandos bis zu einem doppelten Semikolon, das das Ende des Zweiges definiert. Die Fallunterscheidung endet mit dem Schlüsselwort esac. 

case $i in
     Maske) Kommandos ;;
     Maske) Kommandos ;;
     *) Default Kommandos ;;
esac

Ein einfaches Beispiel unterscheidet zwischen einfachen Begriffen. Es ist als der Grundbaustein eines deutsch-englischen Übersetzungsprogramms namens englisch gedacht. Wer mag, kann es ja erweitern. 

case "$1" in
     haus) echo "house" ;;
     auto)  echo "car" ;;
     kind)  echo "child" ;;
     *) echo "stuff" ;;
esac

Defaultzweig

Der Stern als letzte Maske dient dem Abfangen aller der Begriffe, die durch die davor stehenden nicht erfasst wurden. Als nächstes Beispiel wird ein Skript erstellt, der meinname heißen soll und Namen analysieren soll. Der Name wird dem Skript als Parameter mitgegeben. Damit wird die Verwendung von Masken gezeigt. 

case "$1" in
     [wW]illemer) echo "Verwandschaft!!!!" ;;
     A* | a*)  echo "Welch ein Name!" ;;
     *) echo "soso! Nett, Sie kennenzulernen" ;;
esac

Stern und rechteckige Klammern als Maske

Die erste Zeile besagt, dass der erste Parameter untersucht wird. In der zweiten Zeile sieht man, dass der Skript in der Lage ist, den Namen Willemer zu erkennen. Dem Skript ist dabei gleich, ob das W klein oder groß geschrieben wird. In der nächsten Zeile werden Namen bearbeitet, die mit einem A anfangen. Der senkrechte Strich bedeutet ODER. Also ist es wieder egal, ob es ein kleines oder ein großes A ist. Der Stern allein ist der Defaultfall, wenn keines der bisherigen Muster gegriffen hat.

Die while-Schleife

Wiederholungen

Schleifen ermöglichen es, Abläufe kurz zu beschreiben, die sich wiederholen. Damit ein definiertes Ende stattfindet, läuft die Schleife nur so lange, wie eine Bedingung eingehalten wird. Diese Bedingung sollte sorgfältig gewählt werden, sonst kommt es zur gefürchteten Endlosschleife. Das bedeutet, dass das Programm bis zum nächsten Stromausfall läuft. 

while Bedingung
do
   Befehle
done

Als Beispiel für eine solche Schleife sollen alle Parameter überprüft werden, ob sie mit einem Minuszeichen beginnen. Dann sollen sie als Option gelten. Ansonsten handelt es sich um ein Argument. Für diese Aufgabe werden nun zwei Ablaufsteuerungen ineinander verschachtelt. Da eigentlich nur ein Abfragefall existiert, würde man zunächst an die if Bedingung denken. In diesem Fall machen wir uns aber die Fähigkeit des case zunutze, Muster zu erkennen. 

while test -n "$1"
do
    case $1 in
        -*) echo "Option: $1" ;;
        *) echo "Argument: $1" ;;
    esac
    shift # schiebt die Parameter einen durch
done

shift schiebt die Parameter durch

Es wird immer der erste Parameter abgefragt. In der Schleife befindet sich aber der Befehl shift. Dieser schiebt die Parameter durch. Der erste Parameter verschwindet und alle anderen rücken einen nach. Irgendwann wird so der erste Parameter leer. In der Bedingung der Schleife ist die Variable in Anführungszeichen gesetzt. Da kann nichts passieren. Beim case können sie weggelassen werden, da diese Position nie erreicht wird, wenn im ersten Parameter nichts steht.

break und continue unterbrechen eine Schleife

Schleifen können durch das Kommando break unterbrochen werden. Dieser Befehl steht typischerweise hinter einer if Konstruktion. Allerdings kann dieser Befehl leicht zu etwas undurchsichtigem Code führen. Besser ist es, die vollständige Bedingung für das Durchlaufen einer Schleife direkt hinter dem while zu formulieren. In die gleiche Kategorie gehört der Befehl continue, der dazu führt, dass der Rest des Schleifenkörpers nicht ausgeführt wird, sondern sofort zur Abfrage am Kopf gesprungen wird.

Die for-Schleife

Die for-Schleife ist spezialisiert auf die Abarbeitung von Listen. 

for Variable in Menge 
do 
  Kommandos
done

In der Schleife wird der Variable die Werte, die durch die Menge hinter dem Schlüsselwort in definiert wird, der Reihe nach annehmen. Die Variable kann als Argument innerhalb der Schleife durch ein vorangestelltes Dollarzeichen ($) zugegriffen werden. Die Schleife wird so oft durchlaufen, wie Argumente hinter dem 'in' stehen. Beispiel: 

for i in blau gelb grün rot
do
 echo "Meine Lieblingsfarbe ist $i. Also fahre ich" $i"e Autos."
done

Die Ausgabe der Schleife ist: 

Meine Lieblingsfarbe ist blau. Also fahre ich blaue Autos.
Meine Lieblingsfarbe ist gelb. Also fahre ich gelbe Autos.
Meine Lieblingsfarbe ist grün. Also fahre ich grüne Autos.
Meine Lieblingsfarbe ist rot. Also fahre ich rote Autos.

Hier wird noch einmal demonstriert, dass das $i auch innerhalb der Anführungszeichen interpretiert wird. Will man tatsächlich den Inhalt der Zeichenkette nicht interpretiert haben, muss man Hochkommata verwenden. Besonders interessant wird die for-Schleife, wenn statt einer festen Liste von Zeichenketten Dateien verwendet werden, die über Wildcards ausgwählt werden. Das folgende Beispiel wandelt Audiodateien in mp3 Dateien um und löscht anschließend die Originaldateien. 

for i in *.wav
do
  notlame $i `basename $i .wav`.mp3
  rm $i
done

basename stutzt Dateinamen

Eine kleine Schönheitsoperation wurde hier noch mit dem Kommando basename durchgeführt. basename entfernt den Verzeichnisnamen einer Datei. Wird noch ein weiterer Parameter außer dem Dateinamen angegeben, wird dieser als Anhängsel betrachtet, der von hinten abgeschnitten werden soll. Im Beispiel wird von $i der Anhang .wav abgeschnitten. An das Ergebnis dieser Operation wird, mp3 angehängt und das Ganze als Zieldatei des Programmes notlame verwendet. Angenommen im aktuellen Verzeichnis gäbe es die Dateien a.wav, b.wav und c.wav, so wird die Schleife folgende Befehle erzeugen: 

notlame a.wav a.mp3
rm a.wav
notlame b.wav b.mp3
rm b.wav
notlame c.wav c.mp3
rm c.wav

Funktionen

In Shellskripten kann man Funktionen definieren, die einen bestimmten Arbeitsablauf zusammenfassen und von beliebiger Stelle im Skript aufrufen. Auf diese Weise wird einerseits der Skript übersichtlicher und andererseits auch kürzer, da man sich wiederholende Codesequenzen in einer Funktion zusammenfassen kann. 

meinefunktion()
{
   echo "ich tue hier etwas"
}

meinefunktion

Hier wird die Funktion namens meinefunktion definiert und später einfach direkt über ihren Namen aufgerufen.

Parameterübergabe

Es ist auch möglich, Parameter an Funktionen zu geben. Das geschieht ganz ähnlich, wie man Skripten Parameter übergibt und wie man sie auswertet. Beim Aufruf werden die Parameter einfach durch Leerzeichen getrennt hinter dem Funktionsaufruf aufgelistet. Innerhalb der Funktion wird auf die Parameter mit den Variablen $1, $2 und so weiter zugegriffen. Hier ein Beispiel: 

meinefunktion()
{
    echo $1
    echo $2
}

meinefunktion "huhu"
meinefunktion "haha" 12

Der Aufruf des Shellskripts bringt folgende Ausgaben auf dem Bildschirm. 

gaston> func
huhu

haha
12
gaston>

Ein- und Ausgaben aus dem Skript

Die einfachste Art der Ausgabe läuft über den Befehl echo. Er gibt einfach seine Parameter über die Standardausgabe aus. Wenn man allerdings Texte größeren Umfangs hat, beispielsweise Hilfetexte, dann wird der Umgang mit echo etwas mühsam. Man kann allerdings dem Befehl cat die Eingabedatei aus dem Shellskript heraus geben. Und cat wird das tun, was es immer tut, nämlich die Datei auf der Standardausgabe ausgeben. Das sieht dann so aus: 

cat <<!
Hier steht nun eine sehr weitschweifige Erklärung, wie das
Programm zu benutzen ist, wer der geniale Programmierer
dieser Zeilen ist und dass man nach Benutzung dieses
Skriptes nie wieder einen anderen ansehen wird.
!

Der Text muss durch ein Zeichen eingeklammert werden, das im Text selbst natürlich nicht vorkommen darf. Das Ganze wird dann mit zwei Kleinerzeichen in den Befehl cat geschoben. Auf diese Weise kann natürlich jedem Programm die Standardeingabe zugeschoben werden, nicht nur cat. Neben der Ausgabe kann es erforderlich sein, vom Anwender Eingaben zu erfragen. Dazu gibt es das Kommando read, das als Parameter die Variable hat, in die die Eingabe gelangt. 

read ANSWER

Nach der Eingabe mit einem abschließenden Return wird die Eingabezeile in der Variablen ANSWER stehen.

Start und Umgebung von Skripten

Angenommen in der Datei skripttest steht ein kleiner Shellskript, der nur darauf wartet, ausgeführt zu werden. Um ihn zu starten, können Sie verschiedene Wege gehen. Der erste Weg wurde schon beschrieben. Man ändert die Dateirechte auf ausführbar und startet ihn wie ein normales Programm. 

skripttest

Der zweite Weg, einen Skript auszuführen, ist indem Sie eine Shell aufrufen und ihr die Datei als Parameter übergeben. Tatsächlich sind diese beiden Arten, einen Shellskript zu starten, äquivalent. Auch bei dem direkten Start des Dateinamens wird eine neue Shell gestartet, die die Datei skripttest interpretiert. 

sh skripttest

Mit dem Kommando . (Punkt) und dem Dateinamen kann die Datei skripttest von der aktuellen Shell ausführen lassen. 

. skripttest

Nur beim . wird die aktuelle Shell verändert

Der Unterschied zwischen dem Aufruf per Punkt oder per Subshell ist wichtig, da ein mit Punkt aufgerufener Skript den Zustand der aktuellen Shell verändern kann. Wechselt der Skript das Verzeichnis, legt er Umgebungsvariablen an oder verändert er sie, ist dies nach Ausführung des Skripts mit der Arbeitsshell erfolgt. Wird dagegen eine Tochtershell gestartet, wirken sich die Änderungen nur dort aus und hat auf die aktuelle Shell keinerlei Auswirkungen. Anders ausgedrückt: soll ein Skript Variablen setzen, die in der aktuellen Shell später gebraucht werden, muss dieser Skript zwingend mit dem Punkt aufgerufen werden.

Vererbungslehre und export

Die Variablen einer Shell werden normalerweise nicht an Kindprozesse weitergegeben. Wenn in einem Skript eine Variable gesetzt wird, die von einem Kindprozess gelesen werden soll, muss die Variable exportiert werden. Beispiel: 

MYENV="Tolles Wetter"
export MYENV

In der Kornshell und der bash kann auch setzen und exportieren der Variable zusammengesetzt werden. 

export MYENV="Tolles Wetter"

Da dies nicht unter der Standard Bourne-Shell funktioniert und Skripten sehr oft aus Kompatibilitätsgründen mit der /bin/sh gestartet werden, ist es sicherer, Zuweisung und Export getrennt zu halten.

Festlegen des Interpreters

In der ersten Zeile eines Skripts kann festgelegt werden, welche Shell bzw. welcher Interpreter für diese Datei geladen werden soll. Das erste Zeichen hinter dem Kommentarzeichen ist ein Ausrufezeichen. Dann folgt mit komplettem Pfad der Interpreter. Beispiel: 

#!/bin/sh

Dies ist wichtig, weil der Skript eventuell von jemandem gestartet wird, der vielleicht die C-Shell verwendet, die eine andere Syntax hat.

Diese Seite basiert auf Inhalten aus dem Buch Arnold Willemer: Wie werde ich UNIX-Guru.