Kornshell

Die KornShell – so die durch ihren Autor geprägte Schreibung[2] – wurde Anfang der 1980er Jahre von David Korn bei den Bell Labs der AT&T entwickelt und bei der USENIX-Konferenz am 14. Juli 1983 vorgestellt.[3] Sie basierte ursprünglich auf einem Formularinterpreter, an dem David Korn mitgearbeitet hatte. Dessen Syntax wurde auf Basis der Bourne Shell konzipiert, unterschied sich von dieser aber durch wesentliche Verbesserungen: Job Control, eine der C Shell nachempfundene Command History und Command Aliasing.

Die KornShell war von Beginn an, insbesondere aber die ksh93, in erster Linie als Script-Interpreter und erst in zweiter Linie als interaktive Shell gedacht.[11] Die folgende Einführung geht auf die Unterschiede zwischen ksh88 und ksh93 nur am Rande ein, sondern versucht, die Eigentümlichkeiten der Programmiersprache KornShell überhaupt herauszuarbeiten.

#!/usr/bin/ksh

# Dies ist ein Kommentar
print - "Hello World."  # Kommentar: führe print-Statement aus
print - "#"             # Doppelkreuz in Anführungszeichen wird als Zeichen interpretiert
print - \#              # escapetes Doppelkreuz

exit 0

#!/usr/bin/ksh

typeset variable="Hello World."  # Zuweisung
print - ${variable}              # Verwendung der Variablen
print - $variable                # Verwendung, alternative Form

exit 0

Benannte Variablen entsprechen dem, was in anderen Hochsprachen als Variablen bezeichnet wird: ein Bezeichner, der einen Speicherplatz referenziert, in welchem ein Wert abgelegt sein kann. Die KornShell erfordert dabei – zum Unterschied von anderen Hochsprachen – keine formale Deklaration und verlangt auch keine explizite Typisierung. Gleichwohl kann – und soll(!), schon im Sinne der Lesbarkeit und Dokumentation – mittels des Schlüsselwortes typeset eine Deklaration samt Datentyp erfolgen, insbesondere dann, wenn dieser von String abweicht. Als Datentypen stehen zur Verfügung:

• String
• Integer
• Float (nur ksh93)
• Compound (nur ksh93)
• Array

Darüber hinaus kann jede Variable, unabhängig vom Typ, als String verwendet werden. Diese Variablen zeichnen sich dadurch aus, dass sie Namen tragen, weshalb sie benannte Variablen genannt werden.

Daneben gibt es unbenannte, sogenannte positionale Variablen, die automatisch im Falle von Scripten mit den übergebenen Kommandozeilen-Parametern, im Falle von Shell-Funktionen mit den übergebenen Argumenten gefüllt werden. Sie werden mit Zahlen bezeichnet (${0}, ${1}, ${2} usw.), wobei ${0} immer den Namen des Programms bzw. der Funktion enthält.

Mit Ausnahme von $0 können positionale Variablen mit dem Keyword shift abgearbeitet werden. shift löscht den Inhalt der Variablen $1 und belegt dann $1 mit dem Wert von $2, $2 mit dem Wert von $3 .. $n-1 mit dem Wert von $n:

#!/usr/bin/ksh

print - "Name des Scripts............: ${0}"
print - "Erstes übergebenes Argument : ${1}"
print - "Zweites übergebenes Argument: $2"   # alternativ auch ohne Klammern
print - "Drittes übergebenes Argument: $3"

shift
print - "Erstes übergebenes Argument : $1 (war vorher $2)"
print - "Zweites übergebenes Argument: $2 (war vorher $3)"
print - "Drittes übergebenes Argument: $3 (war vorher $4)"

exit 0

In Verbindung mit einer Schleife kann so eine bei Programmerstellung unbekannte Anzahl von übergebenen Parametern stückweise abgearbeitet werden.

Eine lediglich in manchen Shell-Sprachen anzutreffende Besonderheit ist das Here-Document. Es ist ein mit einem feststehenden Text gefüllter String, der aber nicht wie eine Variable deklariert, sondern lediglich einmalig, z. B. als Input eines Kommandos, verwendet wird. Allerdings können innerhalb eines Here-Documents Variablen verwendet werden, die bei Ausführung des Scripts durch ihre Inhalte ersetzt werden.

#!/usr/bin/ksh

typeset chMsg="Hello World."

mail recipient@remote.system.com <<EOF
Hallo recipient,
der Text der Nachricht lautet: $chMsg
EOF

exit 0

Alles zwischen den Begrenzern EOF (die Begrenzer sind frei wählbare Bezeichner) wird als Eingabe an das Kommando mail geschickt, $chMsg wird durch den oben zugewiesenen Wert der Variablen ersetzt. In anderen Hochsprachen entsprechen den Here-Documents am ehesten String-Literale, in C++ etwa Raw String Literals.

Schleifen und Verzweigungen sind kompatibel mit denen der Bourne Shell, von der sie bezogen sind. Die KornShell stellt drei Arten von Schleifen zur Verfügung: for, while und until.

Die for-Schleife entspricht im Verhalten dem von anderen Programmiersprachen Gewohnten: eine Liste von Werten wird iterierend einer Schleifenvariablen zugewiesen und jeweils ein Durchlauf des Schleifen-Körpers mit diesem Wert ausgeführt.

for Variable in <Liste von Werten>
do
  Liste von Kommandos
done

Im Unterschied zu den meisten Sprachen werden allerdings keine Zahlen-Werte (Integer) iteriert, sondern Strings, die aus einer feststehenden Liste entnommen werden. Diese feststehende Liste kann allerdings auch Wildcards enthalten:

#!/usr/bin/ksh
typeset chLoopVar=""

# ---------------------------- Schleife mit Festwerten
for chLoopVar in a b c d e ; do
  print - "Der Wert der Variablen chLoopVar ist: $chLoopVar"
done

# ---------------------------- Schleife mit Files
print - "Eine Liste von txt-Dateien:"
for chLoopVar in *txt ; do
  print - "   -> $chLoopVar"
done

exit 0

Die while- und die until-Schleife sind sowohl syntaktisch gleich wie auch logisch äquivalent, mit dem Unterschied, dass die until-Schleife ausgeführt wird, bis eine bestimmte Bedingung eintritt, die while-Schleife hingegen, solange eine bestimmte Bedingung erfüllt ist. Die folgenden Ausführungen zur while-Schleife gelten deshalb sinngemäß auch für die until-Schleife.

Die while-Schleife arbeitet etwas anders als von anderen Sprachen gewohnt, weil die KornShell ursprünglich keine eigene Methode für Vergleiche kannte und sich deshalb des externen Kommandos test bediente. Mittlerweile hat die KornShell zwar eine eingebaute Funktion, die diesem Kommando entspricht, dennoch hat sich die Syntax der Schleife nicht geändert. while führt den Schleifenkörper so lange aus, wie ein angegebenes Kommando den Error Level 0 (entspricht TRUE) zurückgibt.

while Kommando ; do
    Liste von Kommandos
done

until Kommando ; do
    Liste von Kommandos
done

Wie das folgende Beispiel zeigt, ersetzen in der KornShell while-Schleifen die in anderen Sprachen eingesetzten for-Schleifen. Das zweite Beispiel zeigt die Flexibilität, die durch Einsatz des externen Kommandos gewonnen wird. Das shellinterne Kommando read wird in Verbindung mit einer Pipeline benutzt, einen Datenstrom zeilenweise zu verarbeiten:

#!/usr/bin/ksh
typeset -i iLoopVar=0
typeset  chLine=""

# ------------------------------- while-Schleife als for-Schleifen-Ersatz
while [ $iLoopVar -le 10 ] ; do
    print - "Wert von iLoopVar: $iLoopVar"
    (( iLoopVar += 1 ))           # inkrementiere iLoopVar
done

# ------------------------------- listet alle Kommandos mit 3 Buchstaben in /usr/bin
find /usr/bin -name "???" -print | while read chLine ; do
    print - "Kommando: $chLine"
done

exit 0

Die KornShell kennt zwei Arten der Verzweigung: if..fi und case..esac.

if verwendet wie auch while ein externes Programm, um den benötigten logischen Wert zu generieren. if kann optional mittels des Keywords elif auch mehrere Bedingungen verarbeiten, ebenfalls optional ist ein bei Nichtzutreffen aller vorheriger Bedingungen auszuführender else-Zweig.

if Kommando ; then
  Liste von Kommandos
elif Kommando ; then
  Liste von Kommandos
elif Kommando ; then
  Liste von Kommandos
...
else
  Liste von Kommandos
fi

Bei üblichen Vergleichen wird dafür test bzw. dessen eingebautes Pendant benutzt, es kann aber auch ein beliebiges Programm ausgeführt und – abhängig von dessen Rückgabewert – eine Aktion gestartet werden:

#!/usr/bin/ksh

typeset -i iIn=0

# ------------------------------- einfaches if
if [ 1 -eq 1 ] ; then
  print - "1 ist tatsächlich gleich 1"
fi

# ------------------------------- if-else
if /path/to/program -opt arg1 arg2 ; then
  print - "Programm program wurde ohne Fehler beendet."
else
  print - "Programm program lieferte einen Fehler zurück."
fi

# ------------------------------- mehrstufiges if
print - "Geben Sie eine Ziffer (0-3) ein:" ; read iIn
if [ $iIn -eq 0 ] ; then
  print - "Sie haben 0 eingegeben."
elif [ $iIn -eq 1 ] ; then
  print - "Sie haben 1 eingegeben."
elif [ $iIn -eq 2 ] ; then
  print - "Sie haben 2 eingegeben."
elif [ $iIn -eq 3 ] ; then
  print - "Sie haben 3 eingegeben."
else
  print - "Sie haben was anderes eingegeben."
fi

exit 0

case wertet einen einzelnen Ausdruck durch Variablenexpansion aus und führt aus mehreren alternativen Codeblöcken abhängig von dessen Wert (das kann eine Shell Regular Expression, auch bekannt als File Glob, sein) einen davon durch. Das entspricht annähernd dem aus Pascal bekannten case .. of bzw. dem switch() aus C.

case Ausdruck in
  Wert)
    Kommando
    ...
  ;;

  Wert)
    Kommando
    ...
  ;;
  ...
esac

Das obige Beispiel, mit case anstatt if ausgeführt, würde lauten:

#!/usr/bin/ksh
typeset -i iIn=0

print - "Geben Sie eine Ziffer (0-3) ein:" ; read iIn
case $iIn in
  0)
    print - "Sie haben 0 eingegeben."
    ;;

  [123])                      # 1, 2 oder 3 als Regexp
    print - "Sie haben 1, 2 oder 3 eingegeben."
  ;;

  *)                        # default-Ast
    print - "Sie haben etwas anderes eingegeben."
  ;;
esac

exit 0

Wie in allen anderen prozeduralen Programmiersprachen gibt es auch in der KornShell die Möglichkeit, logisch in sich geschlossene und/oder oftmals wiederkehrende Codeteile in Subroutinen – hier Funktionen genannt – auszulagern. Die Syntax ist mit jener der Bourne-Shell bzw. der POSIX-Shell identisch, die KornShell versteht beide Varianten:

function Funktionsname   # Bourne Shell-artig
{
     Kommando
     Kommando
     ...
}

Funktionsname ()      # POSIX-Shell-artig
{
     Kommando
     Kommando
     ...
}

Zum Unterschied von anderen Programmiersprachen wird die Ein- bzw. Ausgabe allerdings regelmäßig dazu verwendet, Eingaben von anderen Programmteilen zu empfangen bzw. Ergebnisse an andere Programmteile zu übermitteln (Pipelining). In dieser Hinsicht verhalten sich Funktionen in der Shell ähnlich wie externe Programme.

Funktionsargumente werden – analog zu Kommandozeilenparametern – mittels positionaler Variablen übergeben. Mit dem Keyword return (optional gefolgt von einem Integer mit Wert 0–255) kann der Rücksprung ins aufrufende Programm erfolgen und ein Funktionsergebnis, das von diesem als Error Level abgefragt und behandelt werden kann. Jede Funktion sollte deshalb mindestens ein solches return-Kommando (am Ende) enthalten.

#!/usr/bin/ksh

function pShowText
{
  print - "Dies ist ein Beispieltext."
  print - "Bei Ausführung der Funktion pShowText()"
  print - "wird er auf <stdout> ausgegeben."
  return 0
}

function pShowAnyText
{
  typeset iCnt=0
  while [ "$1" != "" ] ; do
    print - "$1"
    (( iCnt += 1 ))
    shift
  done
  return $iCnt
}

# --------- Hauptprogramm
typeset iRetVal=0

print - "Hier wird pShowText() aufgerufen:"
pShowText
print - "das Ergebnis kann auch in einer Pipeline verarbeitet werden:"
pShowText | grep 'ei'    # zeigt alle Zeilen, in denen "ei" vorkommt, also die ersten beiden

print - "pShowAnyText() gibt alle übergebenen Argumente zeilenweise aus:"
pShowAnyText "erste Zeile" "zweite Zeile" "dritte Zeile"
iRetVal=$?          # sichert den Rückgabewert von pShowAnyText()
print - "Es wurden $iRetVal Argumente an pShowAnyText() übergeben."

exit 0

Ein wesentlicher Unterschied zwischen Shell-Sprachen und herkömmlichen Programmiersprachen ist die Behandlung von Variablen: in einer gewöhnlichen Hochsprache ist eine Variable letztlich ein Speicherplatz, in dem ein Wert abgelegt sein und der mit einem Namen angesprochen werden kann. In der ksh (wie auch der bash und ähnlichen Sprachen) ist eine Variable zwar ebenfalls ein Platz zum Ablegen von Werten, aber als direkte Operation existiert nur die Zuweisung. Alle anderen Arten, die Variable anzusprechen, sind mehr oder minder komplexe Funktionen, die den Inhalt der Variablen als Argument bekommen, ihn bearbeiten und das Ergebnis dieser Bearbeitung ausgeben. Der Variableninhalt bleibt dabei selbst aber unverändert.

Die einfachste dieser Funktionen ist __SUB_LEVEL_SECTION_20__lt;Bezeichner>, bzw. ${<Bezeichner>}, welche den Inhalt der Variablen unverändert wiedergibt. Hingegen gibt etwa ${#<Bezeichner>} die Länge der (String-)Variablen <Bezeichner> an und entspricht damit der C-Funktion strlen().

Der Interpreter wertet dabei in Kommandozeilen im Zuge des Command Line Parsing zuerst diese Variablenausdrücke aus und ersetzen sie durch ihr Ergebnis, bevor die so entstandene tatsächliche Kommandozeile auswertet wird. Die folgende Übersicht zeigt einige Möglichkeiten, den Variableninhalt umzuformen:

${<Bezeichner>}, __SUB_LEVEL_SECTION_20__lt;Bezeichner>

Inhalt der Variablen <Bezeichner> ohne Änderung

${#<Bezeichner>}

Länge der Variablen <Bezeichner>

${<Bezeichner>:-<Wert>}: Wenn die Variable <Bezeichner> deklariert und ihr Inhalt ungleich Null (bzw. dem leeren String) ist, dann wird dieser Inhalt ausgegeben, ansonsten der im zweiten Teil des Ausdrucks angegebene.

${<Bezeichner>:=<Wert>}: Wie ${<Bezeichner>:-<Wert>}, aber stattdessen wird der Variablen <Bezeichner> der sich ergebende Wert zugewiesen. Es entspricht

<Bezeichner>="${<Bezeichner>:-<Wert>}"

Dies wird üblicherweise verwendet, um Variablen mit Defaultwerten zu versorgen. Bei diesem wie auch allen ähnlichen Expansionen werden die dem Bezeichner folgenden Ausdrücke nur im Bedarfsfalle ausgewertet. Ungültige Ausdrücke können so für längere Zeit unentdeckt bleiben, was eines der (durch entsprechende Tests zu vermeidenden) Risiken bei größeren Shell-Skript-Projekten darstellt.

${<Bezeichner>#<regexp>}, ${<Bezeichner>##<regexp>}

Wenn die angegebene <regexp> mit dem Beginn des Inhalts der Variablen Bezeichner übereinstimmt, dann wird dieser Inhalt, vermindert um jenen Teil, der übereinstimmt, ausgegeben, ansonsten der gesamte Inhalt. Auf diese Weise können Teile des Inhalts einer Variablen abgeschnitten werden. Bei der Variante mit # wird der kleinste übereinstimmende Teil abgeschnitten, bei ## der längste. Beispielsweise schneidet der Ausdruck ${<PathName>##*/} vom Pfadnamen alles bis zum letzten / ab, was etwa dem Kommando basename entspricht.

${<Bezeichner>%<regexp>}, ${<Bezeichner>%%<regexp>}

Ähnlich wie ${<Bezeichner>#<regexp>} bzw. ${<Bezeichner>##<regexp>}, nur dass der abzuschneidende Teil nicht vom Beginn, sondern vom Ende des Variableninhalts an verglichen wird. Das Kommando dirname kann etwa durch die Expansion ${<Bezeichner>%/*} emuliert werden.

#!/usr/bin/ksh
typeset chVar="hello world"

print - "Inhalt der Variablen chVar: $chVar"
print - "Länge der Variablen chVar.: ${#chVar}"
print - "Defaultwert...............: ${chVar:-foo} hingegen: ${notdeclared:-foo}"

chVar="/path/to/some/file"
print - "Pattern entfernen..........: ${chVar##*/} bzw.: ${chVar%/*}"

exit 0

• Hans-Josef Heck: Standard-Betriebssystem UNIX für Fortgeschrittene. Rowohlt, Hamburg 1991, ISBN 3-499-18187-8.
• Morris I. Bolsky, David A. Korn: The KornShell command and programming language. Prentice Hall, Englewood Cliffs, N.J. 1989, ISBN 0-13-516972-0.
• Morris I. Bolsky, David A. Korn: The new KornShell command and programming language. Prentice Hall PTR, Upper Saddle River, N.J. 1995, ISBN 0-13-182700-6.
• Barry Rosenberg: KornShell Programming Tutorial. Addison-Wesley Professional, Boston, M.A. 1991, ISBN 0-201-56324-X.
• Barry Rosenberg: Hands-On KornShell93 Programming. Addison-Wesley Professional, Boston, M.A. 1998, ISBN 0-201-31018-X.

• ksh(1): KornShell, a command and programming language – Debian GNU/Linux Ausführbare Programme oder Shell-Befehle Handbuchseite
• ksh(1): public domain Korn shell – OpenBSD General Commands Manual
• Webseite der Kornshell (anscheinend verwaist)
• pdksh-Webseite
• ksh
• Quelltexte der ksh93 (Paket ast-ksh)
• Offizielle Webseite der mksh (Weiterleitung auf aktuell funktionierende Version)

1. The Open Group Base Specifications; 2. Shell Command Language. Abgerufen am 23. Mai 2013 (englisch).
2. Website des KornShell-Projekts. Abgerufen am 19. Juni 2013 (englisch).
3. David Korn: KSH – A Shell Programming Language. USENIX Conference Proceedings, Toronto, Ont. Summer 1983, S. 191–202.
4. Sven Maschek: Some ksh versions available. 18. Februar 2012, abgerufen am 10. Februar 2016.
5. QNX Manual: sh. Abgerufen am 10. Februar 2016.
6. AIX v6.1 Infocenter. Abgerufen am 24. Mai 2013 (englisch).
7. Andreas Siegert: AIX Survival Guide. 1. Auflage. Addison-Wesley Professional, Boston 1996, ISBN 0-201-59388-2.
8. Package Notes and Changes (Changelog der ksh93). Abgerufen am 23. Mai 2013 (englisch).
9. aminet.net
10. David Korn Tells All (Question 5, "True Story?"). Abgerufen am 24. Mai 2013 (englisch).
11. David Korn Tells All (Question 1, "Comparison"). Abgerufen am 8. Juni 2013 (englisch).