Funktionen in Shell-Skripten verstehen und schreiben – Teil VI
Funktionen spielen in jeder Programmiersprache eine wichtige Rolle. Wie viele echte Programmiersprachen verfügt Bash über Funktionen, die nur mit begrenzter Implementierung verwendet werden können.
Was sind Funktionen?
In der Programmierung sind Funktionen benannte Abschnitte eines Programms, die eine bestimmte Aufgabe ausführen. In diesem Sinne ist eine Funktion eine Art Prozedur oder Routine. Wenn eine Funktion aufgerufen wird, verlässt das Programm den aktuellen Codeabschnitt und beginnt mit der Ausführung der ersten Zeile innerhalb der Funktion. Wenn sich wiederholender Code vorhanden ist oder eine Aufgabe wiederholt wird, sollten Sie stattdessen die Verwendung einer Funktion in Betracht ziehen.
Stellen Sie sich beispielsweise den Fall vor, dass wir die Fakultät einer Zahl in mehreren Phasen eines bestimmten Programms ermitteln müssen. Anstatt jedes Mal den gesamten Code (zur Berechnung der Fakultät) zu schreiben, können wir den Teil des Codes, der die Fakultät berechnet, einmal innerhalb eines Blocks schreiben und ihn mehrmals wiederverwenden.
Warum schreiben wir Funktionen?
- Es hilft uns, den Code wiederzuverwenden.
- Verbessern Sie die Lesbarkeit des Programms.
- Effiziente Nutzung von Variablen innerhalb des Programms.
- Ermöglicht uns, das Programm Teil für Teil zu testen.
- Zeigt das Programm als eine Reihe von Unterschritten an.
Funktionen in Shell-Skripten
Die allgemeine Syntax zum Schreiben von Funktionen in Shell-Skripten umfasst die folgenden Möglichkeiten.
function func_name {
. . .
commands
. . .
}
or
func_name ( ) {
. . .
commands
. . .
}
Opening curly braces can also be used in the second line as well.
func_name ( )
{
. . .
commands
. . .
}
Es steht Ihnen jederzeit frei, gültige Befehle in diese Funktionsblöcke zu schreiben, wie wir es normalerweise in Shell-Skripten tun. Versuchen wir nun, ein einfaches Skript mit einer kleinen Funktion darin zu schreiben.
#!/bin/bash
call_echo ( ) {
echo ‘This is inside function’
}
op=$1
if [ $# -ne 1 ]; then
echo "Usage: $0 <1/0>"
else
if [ $1 = 0 ] ; then
echo ‘This is outside function’
elif [ $1 = 1 ] ; then
call_echo
else
echo ‘Invalid argument’
fi
fi
exit 0
Die Funktionsdefinition muss vor dem ersten Aufruf erfolgen. Es gibt nichts Schöneres, als die Funktion zu deklarieren, bevor man sie aufruft. Und wir können Funktionen immer innerhalb von Funktionen verschachteln.
Hinweis: – Das Schreiben leerer Funktionen führt immer zu Syntaxfehlern.
Wenn dieselbe Funktion mehrmals definiert wird, wird die endgültige Version aufgerufen. Nehmen wir ein Beispiel.
#!/bin/bash
func_same ( ) {
echo ‘First definition’
}
func_same ( ) {
echo ‘Second definition’
}
func_same
exit 0
Funktionen, die Parameter entgegennehmen und Werte zurückgeben
Gehen wir näher darauf ein, indem wir Funktionen betrachten, die Parameter entgegennehmen und Werte zurückgeben. Um einen Wert von einer Funktion zurückzugeben, verwenden wir die integrierte „Return“-Shell. Die Syntax ist wie folgt.
func_name ( ) {
. . .
commands
. . .
return $ret_val
}
Ebenso können wir Argumente an die Funktionen übergeben, die durch Leerzeichen getrennt sind, wie unten angegeben.
func_name $arg_1 $arg_2 $arg_3
Innerhalb der Funktion können wir auf die Argumente in der Reihenfolge $1, $2, $3 usw. zugreifen. Schauen Sie sich das folgende Beispielskript an, um mithilfe der Funktion das Maximum von zwei Ganzzahlen zu ermitteln, um mehr Klarheit zu schaffen.
#!/bin/bash
USG_ERR=7
max_two ( ) {
if [ "$1" -eq "$2" ] ; then
echo 'Equal'
exit 0
elif [ "$1" -gt "$2" ] ; then
echo $1
else
echo $2
fi
}
err_str ( ) {
echo "Usage: $0 <number1> <number2>"
exit $USG_ERR
}
NUM_1=$1
NUM_2=$2
x
if [ $# -ne 2 ] ; then
err_str
elif [ `expr $NUM_1 : '[0-9]*'` -eq ${#NUM_1} ] ; then
if [ `expr $NUM_2 : '[0-9]*'` -eq ${#NUM_2} ] ; then
max_two $NUM_1 $NUM_2
else
err_str
fi
else
err_str
fi
exit 0
Das Obige sieht etwas komplex aus, ist aber einfach, wenn wir die Zeilen durchlesen. Erste verschachtelte if-else if-Zeilen für Validierungszwecke, d. h. um die Anzahl und Art der Argumente mithilfe regulärer Ausdrücke zu überprüfen. Anschließend rufen wir die Funktion mit zwei Kommandozeilenargumenten auf und zeigen dort selbst das Ergebnis an. Dies liegt daran, dass wir von einer Funktion keine großen Ganzzahlen zurückgeben können. Eine andere Möglichkeit, dieses Problem zu umgehen, besteht darin, globale Variablen zu verwenden, um das Ergebnis innerhalb der Funktion zu speichern. Das folgende Skript erklärt diese Methode.
#!/bin/bash
USG_ERR=7
ret_val=
max_two ( ) {
if [ "$1" -eq "$2" ] ; then
echo 'Equal'
exit 0
elif [ "$1" -gt "$2" ] ; then
ret_val=$1
else
ret_val=$2
fi
}
err_str ( ) {
echo "Usage: $0 <number1> <number2>"
exit $USG_ERR
}
NUM_1=$1
NUM_2=$2
if [ $# -ne 2 ] ; then
err_str
elif [ `expr $NUM_1 : '[0-9]*'` -eq ${#NUM_1} ] ; then
if [ `expr $NUM_2 : '[0-9]*'` -eq ${#NUM_2} ] ; then
max_two $NUM_1 $NUM_2
echo $ret_val
else
err_str
fi
else
err_str
fi
exit 0
Probieren Sie nun einige spannende Probleme aus, die in der vorherigen Shell-Scripting-Reihe erklärt wurden, indem Sie die folgenden Funktionen verwenden.
- Verstehen Sie grundlegende Tipps zur Linux-Shell-Skriptsprache – Teil I
- 5 Shell-Skripte für Linux-Neulinge zum Erlernen der Shell-Programmierung – Teil II
- Segeln durch die Welt der Linux-BASH-Skripterstellung – Teil III
- Mathematischer Aspekt der Linux-Shell-Programmierung – Teil IV
- Berechnen mathematischer Ausdrücke in der Shell-Skriptsprache – Teil V
Ich werde im nächsten Teil mehr Einblick in funktionale Funktionen wie die Verwendung lokaler Variablen, Rekursion usw. geben. Bleiben Sie mit Kommentaren auf dem Laufenden.