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
}

 

  • eine bash-Function kann überall stehen, muß aber vor der Benutzung definiert werden.

  • es gibt zwei Formen der Definition. In beiden Formen müssen die geschweiften Klammern von Blanks oder newline eingerahmt sein.

    • Erste Version, function gefolgt von functionname gefolgt von {

      function show {
          echo  "function body"
          }
       
    • Zweite Version, folgt der C Syntax functionname gefolgt von () gefolgt von {

        show () {
           echo " function body "
             }
      
      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 keinen Zugriff auf die Parameter, die dem Script übergeben wurden, es sei denn sie wurden wieder als Parameter an die Funktion übergeben.
  • Functions dürfen nicht leer sein.

     function show { }
    bash: Syntaxfehler beim unerwarteten Wort `}'
    
    
  • Variablen in der Bash sind global und somit in Functions bekannt und veränderbar. Die Änderung ist global. Soll der Scope der Variablen auf die Funktion begrenzt werden, dann werden sie in der Function mit dem builtin local definiert

     v1=100
    v2=10
    function add {
        	local v1=1999
            erg=$(( $v1 + $v2 ))
            echo " aus function $v1  + $v2 = $erg "
    }
    add
    echo " nach function $v1  + $v2 = $erg "
    
     aus function 1999  + 10 = 2009 
     nach function 100  + 10 = 2009 
    
    • die Anweisung erg=$(( $v1 + $v2 )) ist eine Rechenanweisung. Sie speichert ihr Resultat in der Variablen erg.

    • Wie man sieht,

      • wurde in der function der lokale Wert von v1 verwendet. Die Änderung der Variablen wurde aber nicht zurückgereicht.
      • Die Variable erg wurde in der Funktion erzeugt und ist danach auch global verfügbar

     

     

  • Parameter können an Functions übergeben werden. Sie kommen dort als positional Parameter $1 .. $n an , Auch sind sie alle als $* zugreifbar

     function show () {
      echo "aus function " $2  $1 $3
      echo $*; 
      }
    
    show test parameter übergabe
    aus function  übergabe test parameter
    test parameter übergabe
    
    
    • Blanks , TAB sind Delimiter , Die Parameter werden hier als Strings übergeben,
    • obwohl sie nicht quoted sind. Quoting ist im Zuge der besseren Lesbarkeit aber anzuraten und erforderlich, wenn die Parameter Blanks enthalten"

 

  • Functions liefern den Returnwert des letzten Commandos zurück.
  • Mittels der Anweisung return kann ein adererer Returnwert zurückgegeben werden. Der Wert der Integer muss zwischen 0 und 255 einschliesslich liegen.
  • Im rufenden Programm muss der Returnwert $? sofort ausgewertet oder in einer Variable gespeichert werden, da das nächste Kommando bereits wieder einen neuen Returnwert in $? ablegt.
  • eine Function kann sich rekursiv aufrufen. Die maximale Aufruftiefe (Nesting Level) kann über die Variable FUNCNEST=n festgelegt werden.
       
     function summe_zahlen () { (( summe=summe + cnt )); echo $cnt $summe ; (( cnt++)); summe_zahlen ; }
     
     
     summe_zahlen
    1 1
    2 3
    3 6
    4 10
    5 15
    6 21
    7 28
    8 36
    9 45
    10 55
    bash: summe_zahlen: maximale Funkrionsschachtelungstiefe überschritten (10)
    
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
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
 
$  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
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
 
 
$  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
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
  
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
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
 
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