Grundlagen Linux bash Functions
Definition, Aufruf


awk
Regel und Beispielscripts

Function

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    # v1 in der Function ist local
   nach function 100  + 10 = 2009    # v1 nach der Function ist global, 
                                     # da aber erg in der Function im globalen Scope liegt,
                                     # wird 2009  ausgegeben. 
  

  • 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 anderer 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 Funktionsschachtelungstiefe überschritten (10)
  

  
source  filename [arguments]
		oder die Kurzform
. filename [arguments]

 
$  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"
}

 
 $  cat  /usr/local/func_lib/kopf
 kopf () {
 typeset -i len          # Integer
 typeset -LZ p           # Linksbündig aufüllen 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) / 2 + 17)) # Mittig ausrichten
 clear;
 print ${rev}${clr_eol}Datum : $(date "+%d.%m.%y") \
 $(tput cup 0 $p) $1\
 $(tput cup 0 64) Uhrzeit : $(date "+%H:%M")$norm
 }

  
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 -n $1 "?"
      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)       et $cmd;;     # Toggle x (Debug)
        !*)          eval ${cmd:#!};; # beliebiges shell-
                                   # cmd ausführen
        *)           print "Bitte J oder N antworten ";;
        esac
  done
}

Korne Shell

function  name
{
    Anweisungen der Function
     [ return  [n] ]     
                        
      
}
 # liefert n an den Caller zurück
 # wurde n nicht angegeben wird der Status der letzten Anweisung zurückgeliefert
 # Der Rückgabewert kann in $? abgefragt werden.
 # Achtung: exit beendet das script  

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	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.

Funktionen können in einer separaten Datei abgelegt werden,  
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

 
$ 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 -e $0                       # page ist ähnlich wie less