Function

Mit Hilfe von Funktionen kann ein großes Scripts in einfache, übersichtliche Blöcke aufgebrochen werden. Funktionen werden wie normale Kommandos aufgerufen und werden im Environment des aufrufenden Scripts ausgeführt. Funktionen müssen bei der bash im Script enthalten sein.
Eine Funktion wird definiert durch :
name () 
{
    Anweisungen der Function
     [ return  [n] ]                 # Achtung: exit beendet das script
}
Achtung: in der () werden keine Paramter definiert.
Sie werden beim Aufruf der Funktion einfach nach dem Funktionsnamen angegeben und
kommen wie beim Script als positional Parameter $0 bis $n in der Funktion an.
Die Funktion hat keien Zugriff auf die Parameter, die dem Script übergeben wurden, es sei denn sie wurden wieder als Parameter an die Funktion übergeben.

Wenn Script in separaten Files abgelegt wurden (Wiederverwendbarkeit) müssen sie jeweils separat dazu geladen werden. Dazu wird ein build-in command verwendet:
  
source  filename [arguments]
				oder die Kurzform
. filename [arguments]
Achtung der Punkt ist hier nicht das Kennzeichen für eine hidden File. Zwischen dem Punkt und dem Filename muß ein Blank stehen.


Hier ein Beispiel für eine nützliche Funktion:
Sie gibt den Text Fortsetzung durch [CR] oder Q + [CR] aus und wartet auf die Benutzereingabe.
Der Benutzer kann dann das Script fortsetzen oder abbrechen lassen.
line:  code : cont Funktion
001:
002:
003:
004:
005:
006:
007:
008:
009:
010:
011:
012:
 
$  cat  /usr/local/func_lib/cont
cont 
() {
  
typeset -u dummy
  read dummy
?"Fortsetzung durch [CR]  oder Q + [CR]"
  
if [ "${dummy}"Q" ]
  
then
      
exit $OK
  fi
  
echo "${CUUP}${CLR_EOS}\c"
}


Die nächste Funktion löscht den Bildschirm und gibt eine farbig hinterlegte Überschriftszeile aus.
Dafür werden Escapesequenzen verwendet, die das Terminal umsetzt.
line:  code : kopf Funktion
001:
002:
003:
004:
005:
006:
007:
008:
009:
010:
011:
012:
013:
014:
015:
 
 
$  cat  /usr/local/func_lib/kopf
 kopf 
() {
 
typeset -i len                # Integer
 
typeset -LZ p                 # Linksbündig aufüllen mit leading Zeros
 
len=${#1}
 
rev=${REV:-$(tput rev)}       # wenn nicht definiert, dann setzen
 
norm=${NORM:-$(tput sgr0)}
 
clr_eol=${CLR_EOL:-$(tput el)}
 ((
p=(48-len) / 17))       # Mittig ausrichten
 
clear;
 print ${
rev}${clr_eol}Datum : $(date "+%d.%m.%y") $(tput cup 0 $p) $1\
 $(
tput cup 0 64Uhrzeit : $(date "+%H:%M")$norm
 
}



Die folgende Funktion sollte in bash und ksh funktionieren. Sie hält das Script an und wartet :
- auf eine J/N Antwort
- -x oder +x für Toggle Debug oder
- ein Shellcommand.
line:  code : J/N Funktion
001:
002:
003:
004:
005:
006:
007:
008:
009:
010:
011:
012:
013:
014:
015:
016:
017:
018:
019:
  
function prompt_jn                     # erwartet J/N Antwort
{                                      # akzeptiert  -x  +x  für Debug
                                       # !cmd
   #  typeset -l cmd                   # lower-case (ksh only)
   
while  true
   
do echo -$"?"
      
read -r  cmd  || return 1
        
case  $cmd in
     y
|Y|yes|Yes)   return 0;;
     
j|J|ja|Ja)     return 0;;
     [
nN])            return 1;;
     +
x|-x)           set $cmd;;         # Toggle x (Debug)
     
!*)            eval ${cmd:#!};;   # beliebiges shell-cmd ausführen
     
*)             print "Bitte J oder N antworten ";;
        
esac
  done
}




Korne Shell

Die ksh (Korne-shell) erlaubt es Funktionen, analog zu einer dynamischen Linklibrary, erst beim Aufruf zu laden. Warum die bash diese nützliche Funktion nicht übernommen hat, wissen die Götter. Damit ist es möglich, häufig verwendete Funktionen zentral für alle Scripts zu verwalten und zu pflegen. über eine Variable FPATH werden die Funktionen gesucht. Eine Funktion wird definiert durch :
function  name
{
    Anweisungen der Function
     [ return  [n] ]                 # Achtung: exit beendet das script
}

Beispiel:
function pos
{  print $(tput cup $1 $2)"\c"
}
  • Eine Function muß definiert oder deklariert sein, bevor darauf zugegriffen werden kann.
  • Eine Funktion kann durch den preset alias functions [name] deklariert werden
  • Eine Deklaration kann erfolgen durch typeset f[txu] name [name] ... f Funktionsnamen anzeigen oder Attribute setzen - bzw löschen + t xtrace Option für die Funktion setzen - oder löschen + x Die Funktion soll bei shell-scripts erhalten bleiben, die die ksh nicht separat aufrufen u name bezieht sich auf eine Funktion die bisher noch nicht definiert ist (autoload).
  • oder (ksh only) autoload name [name] ... Funktionsnamen und Funktionsdefinitionen werden nicht automatisch vererbt: wenn die ksh interaktiv separat aufgerufen wird, muß die Funktion in der Environmentfile definiert werden. wenn ein Script aufgerufen wird, werden Funktionen in der Environmetfile nicht automatisch vererbt. Damit eine Funktion vererbt wird, muß sie in der Environmentfile definiert und mit typeset -xf name exportiert werden. Achtung: In der .profile sollte dann die Bearbeitung der .envfile nicht unterbunden werden.
ksh only
Funktionen können in einer separaten Datei abgelegt sein,  die erst bei der ersten
Ausführung der Funktion in das Environment geladen wird.
Jede Funktion hat eigene positional Parameter
Im aufgerufenen Script  muß die Funktion  (vor der Verwendung) als autoload deklariert
werden   (autoload ist ein preset alias  für  typeset -fu )
Die Environmentvariable   FPATH  muß einen Pfad zum Verzeichnis der Funktionen enthalten.
Werden mehrere Pfade angegeben, so ist der Pathstring  wie bei PATH   durch :  zu trennen
	FPATH=/usr/local/func_lib
line:  code : Kopf-Funktion ksh
001:
002:
003:
004:
005:
006:
007:
008:
009:
010:
011:
 
cat  ~/unix/ksh/func_ex
#! /bin/ksh
    
: ${FPATH:=/usr/local/func_lib}
    
autoload  kopf  cont
    kopf 
" <<<<<   Function-Beispiel  >>>>> "
    
print "FPATH=$FPATH \n"
    
ps -fu $(logname)
    
cont
    pg 
-$0                       # page ist ähnlich wie less