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    # 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)

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.

Fatal error: Uncaught Error: Call to undefined function makebox() in /hp/ao/ae/lz/www/detlefhahn/linux/inc/functions_body.inc:231 Stack trace: #0 /hp/ao/ae/lz/www/detlefhahn/linux/linux_shell.php(316): require_once() #1 {main} thrown in /hp/ao/ae/lz/www/detlefhahn/linux/inc/functions_body.inc on line 231
216.73.216.68 linux_shell.php 178

E_ERROR
{"type":1
"message":"Uncaught Error: Call to undefined function makebox() in \/hp\/ao\/ae\/lz\/www\/detlefhahn\/linux\/inc\/functions_body.inc:231\nStack trace:\n
0 \/hp\/ao\/ae\/lz\/www\/detlefhahn\/linux\/linux_shell.php(316): require_once()\n
1 {main}\n thrown"
"file":"\/hp\/ao\/ae\/lz\/www\/detlefhahn\/linux\/inc\/functions_body.inc"
"line":231
"scriptfile":"\/linux\/linux_shell.php"} '
' . (0 - 1) /hp/ao/ae/lz/www/detlefhahn/common/inc/startup_6_1.inc(1005): debug_string_backtrace() '
' . (1 - 1) [internal function]: fatal_error()