Shell-Skripting Teil V: Funktionen in Bash

Hallo! Willkommen zur Shell-Skripting-Tutorial-Serie von HowToForge. Wenn Sie die vorherigen Ausgaben des Tutorials lesen möchten, klicken Sie hier für Teil1, Teil2, Teil3 und Teil4 des Tutorials. In diesem Teil lernen Sie, wie Sie Ihre Skripte effizient strukturieren, indem Sie Funktionen erstellen. Am Ende dieses Tutorials werden Sie wissen, wie Sie Funktionen in der Linux Bash Shell erstellen, Parameter an Ihre Funktionen übergeben und einige Werte von einer Funktion an Ihren Hauptcode zurückgeben. Lassen Sie uns anfangen!

Einführung

Eine Funktion, auch bekannt als Unterroutine in Programmiersprachen, ist eine Menge von Anweisungen, die eine bestimmte Aufgabe für eine Hauptroutine ausführt [1]. Sie ermöglicht es Programmierern, einen komplizierten und langen Code in kleine Abschnitte zu unterteilen, die bei Bedarf aufgerufen werden können. Jede Funktion muss von einer Hauptroutine aufgerufen werden, um ausgeführt zu werden, und ist somit von anderen Teilen Ihres Codes isoliert, was eine einfache Möglichkeit zum Testen des Codes schafft. Darüber hinaus können Funktionen jederzeit und wiederholt aufgerufen werden, was es Ihnen ermöglicht, Ihren Code wiederzuverwenden, zu optimieren und zu minimieren. Wie die meisten Programmiersprachen unterstützt auch die Bash-Shell Funktionen.

Allgemeine Syntax:

1. Syntax 1: function function_name { ##### Befehlssatz }
2. Syntax 2: function_name() { #### Befehlssatz }

Funktionen erstellen

Die Bash unterstützt zwei Strukturen für Funktionen. Bei Verwendung der ersten Syntax müssen Sie das Schlüsselwort function verwenden, gefolgt von Ihrem Funktionsnamen und öffnenden und schließenden Klammern sowie geschweiften Klammern, um den Inhalt Ihrer Funktionen von Ihrer Hauptroutine zu trennen. Diese Syntax wird Ihnen vertraut vorkommen, wenn Sie Erfahrung mit PHP haben, da Funktionen in PHP auf die gleiche Weise deklariert werden. Die andere Syntax besteht nur aus einem Funktionsnamen, öffnenden und schließenden Klammern sowie geschweiften Klammern.

#!/bin/bash  
myfunction(){  
    echo "Meine Funktion funktioniert!"  
}  
myfunction

Ich habe die zweite Syntax in unserem Beispiel verwendet. Nachdem die Funktion myfunction erstellt wurde, wurde sie dann aufgerufen, indem ihr Funktionsname in unserer Hauptroutine verwendet wurde. Die Hauptroutine befindet sich überall in unserem Skript, das nicht als Teil unserer Funktion definiert wurde.

Jetzt lassen Sie uns unseren Code umstrukturieren, um zu testen, ob Funktionen überall in unserem Skript deklariert werden können. Betrachten Sie den folgenden Code:

#!/bin/bash  
echo "Teste meine Funktion"  
myfunction  
  
myfunction(){  
    echo "Meine Funktion funktioniert!"  
}

Die Zeile 3 im obigen Code gibt einen Fehler “Befehl nicht gefunden” zurück. Das bedeutet nur:

Die Funktion funktioniert nur, wenn sie vor Ihrer Hauptroutine deklariert wird. Der Interpreter gibt einen Fehler zurück, wenn Sie Ihre Funktion nach Ihrer Hauptroutine deklariert haben.

Codes umstrukturieren mit Funktionen

Eine der besten Eigenschaften von Funktionen ist die Möglichkeit, Codes wiederzuverwenden. Wenn ein Verfahren wiederholt Befehle ausführen muss, aber nicht mit Schleifen strukturiert werden kann, dann kann eine Funktion eine Lösung sein.

Betrachten Sie beispielsweise den folgenden Code:

#!/bin/bash  
while(true)  
do  
    clear  
    printf "Wählen Sie aus den folgenden Operationen: \n"  
    printf "[a]Addition\n[b]Subtraktion\n[c]Multiplikation\n[d]Division\n"  
    printf "################################\n"  
    read -p "Ihre Wahl: " choice  
    case $choice in  
    [aA])  
        read -p "Geben Sie die erste ganze Zahl ein: " int1  
        read -p "Geben Sie die zweite ganze Zahl ein: " int2  
        res=$((int1+int2))  
   
    ;;  
    [bB])  
        read -p "Geben Sie die erste ganze Zahl ein: " int1  
        read -p "Geben Sie die zweite ganze Zahl ein: " int2  
    res=$((int1-int2))  
   
    ;;  
    [cC])  
        read -p "Geben Sie die erste ganze Zahl ein: " int1  
        read -p "Geben Sie die zweite ganze Zahl ein: " int2  
        res=$((int1*int2))  
   
    ;;  
    [dD])  
        read -p "Geben Sie die erste ganze Zahl ein: " int1  
        read -p "Geben Sie die zweite ganze Zahl ein: " int2  
        res=$((int1/int2))  
   
    ;;  
    *)  
        res=0  
        echo "Falsche Wahl!"  
    esac  
  
    echo "Das Ergebnis ist: " $res  
    read -p "Möchten Sie fortfahren? [j]a oder [n]ein: " ans  
    if [ $ans == 'n' ]  
        then  
         echo "Skript wird beendet. Einen schönen Tag noch!"  
        break  
    else  
        continue  
    fi  
  
done

Das Skript läuft gut, jedoch beachten Sie, dass die Zeilen zur Eingabeaufforderung in jedem Muster in unserer Switch-Anweisung wiederholt werden.

#!/bin/bash  
inputs(){  
     read -p "Geben Sie die erste ganze Zahl ein: " int1  
    read -p "Geben Sie die zweite ganze Zahl ein: " int2  
}  
  
exitPrompt(){  
    read -p "Möchten Sie fortfahren? [j]a oder [n]ein: " ans  
    if [ $ans == 'n' ]  
    then  
        echo "Skript wird beendet. Einen schönen Tag noch!"  
        break  
    else  
        continue  
    fi  
}  
  
while(true)  
do  
    clear  
    printf "Wählen Sie aus den folgenden Operationen: \n"  
    printf "[a]Addition\n[b]Subtraktion\n[c]Multiplikation\n[d]Division\n"  
    printf "################################\n"  
    read -p "Ihre Wahl: " choice  
  
    case $choice in  
    [aA])  
        inputs  
        res=$((int1+int2))  
    ;;  
  
    [bB])  
        inputs  
        res=$((int1-int2))  
    ;;  
  
    [cC])  
        inputs  
        res=$((int1*int2))  
    ;;  
  
    [dD])  
        inputs  
        res=$((int1/int2))  
    ;;  
  
    *)  
        res=0  
        echo "Falsche Wahl!"  
    esac  
  
    echo "Das Ergebnis ist: " $res  
    exitPrompt  
done

Wir haben unseren Code verbessert, indem wir die Unterabschnitte inputs und exitPrompt erstellt haben. Es funktioniert genau wie unser vorheriger Code, jedoch ist unser aktueller Code einfacher zu debuggen, da er ordnungsgemäß strukturiert ist.

Parameter an Funktionen übergeben

Wie die meisten Programmiersprachen können Sie Parameter übergeben und diese Daten in Funktionen in Bash verarbeiten. Der folgende Code zeigt das Verfahren, wie Werte im Shell-Skripting übergeben werden:

#!/bin/bash  
myfunction(){  
    echo $1  
    echo $2  
}  
  
myfunction "Hallo" "Welt"

Beachten Sie in unserem Beispiel, dass wir die Werte “Hallo” und “Welt” hinzugefügt haben, nachdem wir die myfunction aufgerufen haben. Diese Werte werden der myfunction als Parameter übergeben und in einer lokalen Variablen gespeichert. Im Gegensatz zu anderen Sprachen speichert der Interpreter jedoch die übergebenen Werte in vordefinierten Variablen, die entsprechend der Reihenfolge der übergebenen Parameter benannt sind, beginnend mit 1 bis zur Reihenfolge der Übergabe. Beachten Sie, dass das Wort “Hallo” in der Variablen 1 und der Wert “Welt” in der Variablen 2 gespeichert ist.

Hinweis: Die 1 und 2 in unserem Beispiel sind lokale Variablen und somit nicht für andere Teile des Skripts zugänglich, abgesehen von der Funktion, in der die Parameter übergeben werden.

Zum Beispiel,

#!/bin/bash  
myfunction(){  
    echo $1  
    echo $2  
}  
  
myfunction "Hallo" "Welt"  
echo $1  
echo $2

Die echo $1 und echo $2 in den letzten beiden Zeilen unseres Skripts haben keine Anzeige, da der Interpreter beide Variablen nicht erkennt, weil sie beide lokal zur myfunction sind.

Werte von Funktionen zurückgeben

Neben der Erstellung von Funktionen und der Übergabe von Parametern an sie können Bash-Funktionen die Werte einer lokalen Variablen einer Funktion an die Hauptroutine zurückgeben, indem sie das Schlüsselwort return verwenden. Die zurückgegebenen Werte werden dann in der Standardvariablen $? gespeichert. Betrachten Sie beispielsweise den folgenden Code:

#!/bin/bash  
add(){  
    sum=$(($1+$2))  
    return $sum  
}  
  
read -p "Geben Sie eine ganze Zahl ein: " int1  
read -p "Geben Sie eine ganze Zahl ein: " int2  
add $int1 $int2  
echo "Das Ergebnis ist: " $?

In dem Beispiel übergeben wir die Parameter int1 und int2 an die Funktion add. Als nächstes verarbeitet die Funktion add dies durch die Zeile sum=$(($1+$2)). Dann wird der Wert der Variablen sum durch die Zeile return $sum an die Hauptroutine übergeben. Standardmäßig werden die Werte von $sum in der Standardvariablen $? gespeichert. Schließlich gibt die Zeile echo “Das Ergebnis ist: “ $? das Ergebnis aus.

Hinweis: Shell-Skripte können nur einen einzelnen Wert zurückgeben.

Im Gegensatz zu anderen Programmiersprachen können Shell-Skripte keine mehreren Werte von einer Funktion zurückgeben. Lassen Sie uns dieses Beispiel betrachten:

#!/bin/bash  
add(){  
    sum=$(($1+$2))  
    dif=$(($1-$2))  
    return $sum   
}  
  
read -p "Geben Sie eine ganze Zahl ein: " int1  
read -p "Geben Sie eine ganze Zahl ein: " int2  
add $int1 $int2  
echo "Das Ergebnis ist: " $?  
echo "Das Ergebnis ist: " $?

Zusammenfassung

Lassen Sie uns ein weiteres Beispiel betrachten, das Funktionen verwendet, Parameter an sie übergibt und Werte zurückgibt.

#!/bin/bash  
#####################  
#Autor: HowtoForge #  
#####################  
   
clear(){  
    clear  
}  
  
bin(){  
    bin1=$(echo "obase=2;$1"|bc)  
    echo $bin1  
}  
  
dec(){  
    dec1=$(echo "ibase=2;$1"|bc)  
    return $dec1  
}  
  
########Haupt#########  
    printf "Wählen Sie aus den folgenden Operationen:\n[1]Dezimal- zu Binärkonvertierung\n"  
    printf "[2]Binär- zu Dezimalumwandlung\n"  
    read -p "Ihre Wahl: " op  
    case $op in  
  
    1)  
        read -p "Geben Sie eine ganze Zahl ein: " int  
        bin $int  
    ;;  
  
    2)  
        read -p "Geben Sie eine Binärzahl ein: " int  
        dec $int  
        echo "Das dezimale Äquivalent von $int ist $?"  
    ;;  
  
    *)  
        echo "Falsche Wahl!"  
    esac

Das gegebene Beispiel konvertiert eine eingegebene Zahl sowohl in einen binären als auch in einen dezimalen Wert unter Verwendung des obase- und ibase-Befehls. Die Zeile $(echo “obase=2;$1”|bc) konvertiert einen gegebenen Dezimalwert in eine binäre Ziffer und speichert sie in der Variablen bin1. Als nächstes haben wir den Wert von $bin1 mit dem echo-Befehl angezeigt.

Hinweis: Es ist besser, echo direkt zu verwenden, wenn Sie von Dezimal zu Binär konvertieren, da Bash, wenn Sie einen Befehl zurückgeben, um einen binären Wert zu übergeben, den binären Wert in Dezimal umwandelt, bevor er zurückgegeben wird.

Zusätzlich haben wir den binären Wert in Dezimal mit dem Befehl $(echo “ibase=2;$1”|bc) umgewandelt.

Sie müssen auch beachten, dass der Interpreter nur 8-Bit-Binärziffern akzeptieren kann. Wenn Sie Ziffern eingeben, die das 8-Bit-Limit überschreiten, wird ein Überlauf erzeugt und das höchstwertige Bit der Ziffer wird verworfen.

Die 10-Bit-Binärziffer 1000001010 gibt 10 zurück, da gemäß der 8-Bit-Regel die verbleibenden 2 Bits auf der rechten Seite (höchstwertiges Bit) weggelassen werden, sodass 1000001010 gleich 00001010 wird, was 10 entspricht. Wenn Sie eine Operation wünschen, die binäre Ziffern über 8 Bit akzeptiert, müssen Sie den Code manuell erstellen.

Fazit

Bash hat Funktionen, die sehr ähnlich zu Programmiersprachen sind, um den Benutzern zahlreiche Werkzeuge zur Verfügung zu stellen und die Linux-Systeme leistungsfähiger zu machen. In dieser Serie haben Sie Ihr Wissen im Shell-Skripting durch Funktionen erweitert. Funktionen in Shell-Skripten bieten Modularität für den Benutzer, wodurch Skripte einfacher zu debuggen sind und eine Wiederverwendung des Codes ermöglicht wird.

Referenz:

[1] American Heritage® Dictionary of the English Language, Fifth Edition. Copyright © 2011 von Houghton Mifflin Harcourt Publishing Company. Veröffentlicht von Houghton Mifflin Harcourt Publishing Company.