Website-Suche

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?

  1. Es hilft uns, den Code wiederzuverwenden.
  2. Verbessern Sie die Lesbarkeit des Programms.
  3. Effiziente Nutzung von Variablen innerhalb des Programms.
  4. Ermöglicht uns, das Programm Teil für Teil zu testen.
  5. 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.

  1. Verstehen Sie grundlegende Tipps zur Linux-Shell-Skriptsprache – Teil I
  2. 5 Shell-Skripte für Linux-Neulinge zum Erlernen der Shell-Programmierung – Teil II
  3. Segeln durch die Welt der Linux-BASH-Skripterstellung – Teil III
  4. Mathematischer Aspekt der Linux-Shell-Programmierung – Teil IV
  5. 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.