Bash-Scripting Teil 6 – Erstellen und Verwenden von Bash-Funktionen

Bevor wir über Bash-Funktionen sprechen, lassen Sie uns diese Situation besprechen. Beim Schreiben von Bash-Skripten werden Sie feststellen, dass Sie denselben Code an mehreren Stellen verwenden.

Wenn Sie es satt haben, immer wieder dieselben Codezeilen in Ihr Bash-Skript zu schreiben, wäre es nett, den Codeblock einmal zu schreiben und ihn irgendwo in Ihrem Bash-Skript aufzurufen.

Die Bash-Shell ermöglicht Ihnen genau das mit Funktionen .

Bash-Funktionen sind Codeblöcke, die Sie überall in Ihrem Code wiederverwenden können. Jedes Mal, wenn Sie diesen Codeblock in Ihrem Skript verwenden möchten, geben Sie einfach den ihm zugewiesenen Funktionsnamen ein.

Wir werden darüber sprechen, wie Sie Ihre Bash-Funktionen erstellen und wie Sie sie in Shell-Skripten verwenden.

Erstellen einer Funktion

Sie können eine Funktion wie folgt definieren:

Funktionsname() {}

Die Klammern () sind erforderlich, um die Funktion zu definieren.

Sie können die Funktion auch mit dem Schlüsselwort function definieren, aber dieses Schlüsselwort ist aus Gründen der POSIX-Portabilität veraltet.

function functionName() { # Veraltete Definition, aber immer noch verwendet und funktioniert

In der zweiten Definition sind die Klammern nicht erforderlich.

Funktionen verwenden

#!/bin/bashmyfunc() { echo "Funktionen verwenden"}total=1while [ $total -le 3 ]; do myfunc total=$(($total + 1))doneecho "Loop beendet"myfuncecho "Ende des Skripts"

Hier haben wir eine Funktion namens myfunc erstellt und zum Aufrufen einfach ihren Namen eingegeben.

Sie können die Funktion beliebig oft aufrufen.

Hinweis:Was passiert, wenn Sie versuchen, eine nicht definierte Funktion zu verwenden?

#!/bin/bashtotal=1while [ $total -le 3 ]; do myfunc total=$(($total + 1))doneecho "Loop End"myfunc() { echo "Using function ..."}echo "End of the script"

Oh, es ist ein Fehler weil es keine solche Funktion gibt.

Ein weiterer Hinweis:Der Name der Bash-Funktion muss eindeutig sein. Andernfalls bricht die neue Funktion die alte Funktion fehlerfrei ab.

#!/bin/bashmyfunc() { echo "Die erste Funktionsdefinition"}myfuncfunction myfunc() { echo "Die zweite Funktionsdefinition"}myfuncecho "Ende des Skripts"

Wie Sie sehen, übernimmt die zweite Funktionsdefinition fehlerfrei die Kontrolle über die erste, seien Sie also vorsichtig, wenn Sie Funktionen definieren.

Mit dem Return-Befehl

Der return-Befehl gibt eine Ganzzahl aus der Funktion zurück.

Es gibt zwei Möglichkeiten, den Return-Befehl zu verwenden; Der erste Weg ist wie folgt:

#!/bin/bashmyfunc() { read -p "Geben Sie einen Wert ein:" value echo "Wert hinzufügen" return $(($value + 10))}myfuncecho "Der neue Wert ist $?"

Die myfunc-Funktion addiert 10 zur $value-Variablen und zeigt dann die Summe mit dem $? Variable.

Führen Sie keine Befehle aus, bevor Sie den Wert der Funktion erhalten, da die Variable $? gibt den Status der letzten Zeile zurück.

Diese Rückgabemethode gibt ganze Zahlen zurück. Was ist mit der Rückgabe von Zeichenfolgen?

Funktionsausgabe verwenden

Die zweite Möglichkeit, einen Wert von einer Bash-Funktion zurückzugeben, ist die Befehlssubstitution. Auf diese Weise können Sie alles von der Funktion zurückgeben.

#!/bin/bashmyfunc() { read -p "Geben Sie einen Wert ein:" value echo $(($value + 10))}result=$(myfunc)echo "Der Wert ist $result"

Parameter übergeben

Wir können mit Bash-Funktionen wie kleinen Snippets umgehen, die wir wiederverwenden können, und das ist in Ordnung, aber wir müssen die Funktion wie eine Engine machen, wir geben ihr etwas, und sie gibt ein Ergebnis basierend auf dem zurück, was wir bereitstellen.

Sie können die Umgebungsvariablen verwenden, um die übergebenen Parameter an die Funktion zu verarbeiten. Der Funktionsname wird als $0-Variable deklariert und die übergebenen Parameter sind $1, $2, $3 usw.

Sie können die Anzahl der an die Funktion übergebenen Parameter mit dem ($# ) Variable.

Wir übergeben Parameter wie diese:

myfunc $val1 10 20

Das folgende Beispiel zeigt, wie die Variable ($#) verwendet wird:

#!/bin/bashaddnum() { if [ $# -gt 2 ]; then echo "Falsche Parameter übergeben" # Wenn Parameter ungleich 2 else echo $(($1 + $2)) # Sonst addiere sie fi}echo -n "Hinzufügen von 10 und 15:"value=$(addnum 10 15)echo $valueecho -n "Addieren von drei Zahlen:"value=$(addnum 10 15 20)echo $value

Die addnum-Funktion erhält die Anzahl der übergebenen Parameter. Wenn mehr als 2 übergeben wird, wird -1 zurückgegeben.

Wenn es einen Parameter gibt, fügt die Addnum-Funktion diesen Parameter zweimal hinzu. Wenn zwei Parameter übergeben werden, fügt die addnum-Funktion sie zusammen, und wenn Sie versuchen, drei Parameter hinzuzufügen, wird -1 zurückgegeben.

Wenn Sie versuchen, die übergebenen Parameter innerhalb der Funktion zu verwenden, schlägt dies fehl:

#!/bin/bashmyfunc() { echo $(($1 + $2 + $3 + $4))}if [ $# -eq 4 ]; then value=$(myfunc) echo "Total=$value"else echo "Übergebene Parameter wie folgt:myfunc a b c d"fi

Stattdessen müssen Sie sie wie folgt an die Funktion senden:

#!/bin/bashmyfunc() { echo $(($1 + $2 + $3 + $4))}if [ $# -eq 4 ]; then value=$(myfunc $1 $2 $3 $4) echo "Total=$value"else echo "Passed parameter like this:myfunc a b c d"fi

Jetzt funktioniert es!!

Variablen in Bash-Funktionen verarbeiten

Jede Variable, die wir verwenden, hat einen Geltungsbereich; Der Geltungsbereich ist die variable Sichtbarkeit Ihres Skripts.

Sie können zwei Arten von Variablen definieren:

• Weltweit
• Lokal

Globale Variablen

Sie sind überall im Bash-Skript sichtbar und gültig. Sie können seinen Wert sogar innerhalb der Funktion abrufen.

Wenn Sie eine globale Variable innerhalb einer Funktion deklarieren, können Sie ihren Wert von außerhalb der Funktion abrufen.

Jede Variable, die Sie deklarieren, ist standardmäßig eine globale Variable. Wenn Sie eine Variable außerhalb der Funktion definieren, rufen Sie sie problemlos innerhalb der Funktion auf:

#!/bin/bashmyfunc() { input=$(($input + 10))}read -p "Geben Sie eine Zahl ein:" inputmyfuncecho "Der neue Wert ist:$input"

Wenn Sie den Variablenwert innerhalb der Funktion ändern, wird der Wert außerhalb der Funktion geändert.

Wie kann man so etwas überwinden? Verwenden Sie lokale Variablen.

Lokale Variablen

Wenn Sie die Variable nur innerhalb der Funktion verwenden, können Sie sie als lokale Variable deklarieren, indem Sie das local-Schlüsselwort wie folgt verwenden:

lokales tmp=$(( $val + 10 ))

Wenn Sie also zwei Variablen haben, eine innerhalb der Funktion und die andere außerhalb der Funktion, und sie denselben Namen haben, beeinflussen sie sich nicht gegenseitig.

#!/bin/bashmyfunc() { local tmp=$(($val + 10)) echo "Die Temperatur von innen ist $tmp"}tmp=4myfuncecho "Die Temperatur von außen ist $tmp" 

 
 

 Wenn Sie die $tmp-Variable innerhalb der myfunc-Funktion verwenden, ändert sie nicht den Wert von $tmp, der sich außerhalb der Funktion befindet.
 

 
 
Arrays als Parameter übergeben
 

 Was passiert, wenn Sie ein Array als Parameter an eine Funktion übergeben:
 
#!/bin/bashmyfunc() { echo "Die Parameter sind:[email protected]" arr=$1 echo "Das empfangene Array ist ${arr[*]}"}my_arr=(5 10 15)echo "Das alte Array ist:${my_arr[*]}"myfunc ${my_arr[*]}
 

 
 

 Die Funktion übernimmt nur den ersten Wert der Array-Variablen.
 

 Sie sollten das Array in seine einzelnen Werte zerlegen und diese Werte dann als Funktionsparameter verwenden. Packen Sie sie schließlich wie folgt in ein Array in der Funktion:
 
#!/bin/bashmyfunc() { local new_arr new_arr=("[email protected]") echo "Der aktualisierte Wert ist:${new_arr[*]}"}my_arr=(4 5 6)echo "Alt array ist ${my_arr[*]}"myfunc ${my_arr[*]}
 

 
 

 Die Array-Variable wurde dank der Funktion neu erstellt.
 

 
 
Rekursive Funktion
 

 Diese Funktion ermöglicht es der Funktion, sich selbst innerhalb der Funktion selbst aufzurufen.
 

 Das klassische Beispiel einer rekursiven Funktion ist die Berechnung von Fakultäten. Um die Fakultät von 3 zu berechnen, verwenden Sie die folgende Gleichung:
 

 3! =1 * 2 * 3
 

 Stattdessen können wir die rekursive Funktion wie folgt verwenden:
 
x! =x * (x-1)!
 

 Um also die Fakultätsfunktion mit Bash-Skripting zu schreiben, sieht es so aus:
 
#!/bin/bashfac_func() { if [ $1 -eq 1 ]; then echo 1 else local tmp=$(($1 - 1)) local res=$(fac_func $tmp) echo $(($res * $1)) fi}read -p "Wert eingeben:" valres=$(fac_func $ val)echo "Die Fakultät von $val ist:$res"
 

 
 

 Die Verwendung rekursiver Bash-Funktionen ist so einfach!
 

 
 
Bibliotheken erstellen
 

 Jetzt wissen wir, wie man Funktionen schreibt und wie man sie aufruft, aber was ist, wenn Sie diese Bash-Funktionen oder Codeblöcke in verschiedenen Bash-Skriptdateien verwenden möchten? ohne es zu kopieren und in Ihre Dateien einzufügen.
 

 Sie können eine Bibliothek für Ihre Funktionen erstellen und bei Bedarf von jeder Datei aus auf diese Bibliothek verweisen.
 

 Durch Verwendung des Quellenbefehls , können Sie das Skript der Bibliotheksdatei in Ihr Shell-Skript einbetten.
 

 Der Quellbefehl hat einen Alias, nämlich den Punkt.  Um eine Datei in einem Shell-Skript zu beziehen, schreiben Sie die folgende Zeile:
 . ./myscript

Nehmen wir an, wir haben eine Datei namens myfuncs, die Folgendes enthält:

addnum() { echo $(($1 + $2 + $3 + $4))}

Jetzt werden wir es in einer anderen Bash-Skriptdatei wie dieser verwenden:

#!/bin/bash. ./myfuncsresult=$(addnum 10 10 5 5)echo "Total =$result"

Genial!! Wir haben die Bash-Funktionen in unserer Bash-Skriptdatei verwendet; wir können sie auch direkt in unserer Shell verwenden.

Bash-Funktionen von der Kommandozeile aus verwenden

Nun, das ist einfach, wenn Sie den vorherigen Beitrag gelesen haben, in dem es um die Signale und Jobs ging, haben Sie eine Vorstellung davon, wie Sie unsere Funktionsdatei in der bashrc-Datei beziehen, und daher können wir die Funktionen direkt aus der Bash-Shell verwenden . Cool

Bearbeiten Sie die bashrc-Datei unter /home/username und fügen Sie diese Zeile hinzu:

$ Zusatz 10 20