Shell-Scripting Teil V:Funktionen in Bash

Hi! Willkommen zur Shell-Scripting-Tutorial-Reihe von HowToForge. Wenn Sie die vorherigen Versionen des Tutorials lesen möchten, klicken Sie hier für Teil 1, Teil 2, Teil 3 und Teil 4 des Tutorials. In diesem Teil erfahren Sie, wie Sie Ihre Skripte effizient strukturieren, indem Sie Funktionen erstellen. Am Ende dieser Anleitung wissen Sie, 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. Fangen wir an!

Einführung

Eine Funktion, in Programmiersprachen auch als Subroutine bezeichnet, ist eine Reihe von Anweisungen, die eine bestimmte Aufgabe für eine Hauptroutine ausführen [1]. Es ermöglicht Programmierern, einen komplizierten und langen Code in kleine Abschnitte zu zerlegen, die bei Bedarf aufgerufen werden können. Jede Funktion muss von einer Hauptroutine aufgerufen werden, um ausgeführt zu werden, daher ist sie von anderen Teilen Ihres Codes isoliert und dies schafft eine einfache Möglichkeit zum Testen von Code. Darüber hinaus können Funktionen jederzeit und wiederholt aufgerufen werden, wodurch Sie Ihre Codes wiederverwenden, optimieren und minimieren können. Wie die meisten Programmiersprachen unterstützt auch die Bash-Shell Funktionen.

Allgemeine Syntax:

1. Syntax 1:

   function function_name
   {
       ##### set of commands
   }

2. Syntax 2:

   function_name()
   {
       #### set of commands
   }

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 runden Klammern, um den Inhalt Ihrer Funktionen von Ihrer Hauptroutine zu trennen. Sie werden diese Syntax vertraut finden, wenn Sie sich mit PHP auskennen, da Funktionen in PHP auf die gleiche Weise deklariert werden. Die andere Syntax besteht nur aus einem Funktionsnamen, öffnenden und schließenden Klammern und geschweiften Klammern.

#!/bin/bash
myfunction(){
    echo "My function works!"
}
myfunction

In unserem Beispiel habe ich die zweite Syntax verwendet. Nachdem die Funktion myfunction erstellt wurde, wurde sie aufgerufen, indem ihr Funktionsname in unserer Hauptroutine aufgerufen wurde. Die Hauptroutine befindet sich an einer beliebigen Stelle in unserem Skript, die nicht als Teil unserer Funktion definiert wurde.

Lassen Sie uns nun unseren Code neu anordnen, um zu testen, ob Funktionen irgendwo in unserem Skript deklariert werden können. Betrachten Sie den folgenden Code:

#!/bin/bash
echo "testing my function"
myfunction

myfunction(){
    echo "My function works!"
}

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

The function only works if it is declared before your main routine. The interpreter will return an error if you have declared your function after your main routine.

Umstrukturierung von Codes mit Funktionen

Eine der besten Funktionen von Funktionen ist die Möglichkeit, Codes wiederzuverwenden. Wenn eine Prozedur die wiederholte Ausführung von Befehlen erfordert, aber nicht mit Schleifenanweisungen strukturiert werden kann, kann eine Funktion eine Lösung sein.

Betrachten Sie beispielsweise den folgenden Code:

#!/bin/bash
while(true)
do
    clear
    printf "Choose from the following operations: \n"
    printf "[a]ddition\n[b]Subtraction\n[c]Multiplication\n[d]Division\n"
    printf "################################\n"
    read -p "Your choice: " choice
    case $choice in
    [aA])
        read -p "Enter first integer: " int1
        read -p "Enter second integer: " int2
        res=$((int1+int2))
 
    ;;
    [bB])
        read -p "Enter first integer: " int1
        read -p "Enter second integer: " int2
    res=$((int1-int2))
 
    ;;
    [cC])
        read -p "Enter first integer: " int1
        read -p "Enter second integer: " int2
        res=$((int1*int2))
 
    ;;
    [dD])
        read -p "Enter first integer: " int1
        read -p "Enter second integer: " int2
        res=$((int1/int2))
 
    ;;
    *)
        res=0
        echo "wrong choice!"
    esac

    echo "The result is: " $res
    read -p "Do you wish to continue? [y]es or [n]o: " ans
    if [ $ans == 'n' ]
        then
         echo "Exiting the script. Have a nice day!"
        break
    else
        continue
    fi

done

Das Skript läuft gut, beachten Sie jedoch, dass die Zeilen zum Akzeptieren von Eingaben in jedem Muster in unserer switch-Anweisung wiederholt ausgeführt werden.

#!/bin/bash
inputs(){
     read -p "Enter first integer: " int1
    read -p "Enter second integer: " int2
}

exitPrompt(){
    read -p "Do you wish to continue? [y]es or [n]o: " ans
    if [ $ans == 'n' ]
    then
        echo "Exiting the script. Have a nice day!"
        break
    else
        continue
    fi
}

while(true)
    do
    clear
    printf "Choose from the following operations: \n"
    printf "[a]Addition\n[b]Subtraction\n[c]Multiplication\n[d]Division\n"
    printf "################################\n"
    read -p "Your choice: " 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 "wrong choice!"
    esac

    echo "The result is: " $res
    exitPrompt
done

Wir haben unseren Code verbessert, indem wir Unterabschnitte input und exitPrompt erstellt haben. Es funktioniert genauso mit unserem vorherigen Code, aber unser aktueller Code ist einfacher zu beheben, da er richtig strukturiert ist.

Übergabe von Parametern an Funktionen

Wie die meisten Programmiersprachen können Sie Parameter übergeben und diese Daten in Funktionen in Bash verarbeiten. Der folgende Code zeigt das Verfahren zum Übergeben von Werten in Shell-Skripten:

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

myfunction "Hello" "World"

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

Hinweis:Die 1 und 2 in unserem Beispiel sind lokale Variablen und daher für andere Teile des Skripts außer der Funktion, an die die Parameter übergeben werden, nicht zugänglich.

Zum Beispiel

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

myfunction "Hello" "World"
echo $1
echo $2

echo $1 und echo $2 in den letzten beiden Zeilen unseres Skripts werden nicht angezeigt, da der Interpreter beide Variablen nicht erkennt, weil sie beide lokal für myfunction sind.

Rückgabewerte von Funktionen

Abgesehen von der Erstellung von Funktionen und der Übergabe von Parametern können Bash-Funktionen die Werte der lokalen Variablen einer Funktion an die Hauptroutine übergeben, 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 "Enter an integer: " int1
read -p "Enter an integer: " int2
add $int1 $int2
echo "The result is: " $?

Im Beispiel übergeben wir der add-Funktion die Parameter int1 und int2. Als nächstes verarbeitet die Add-Funktion es durch die Zeile sum=$(($1+$2)). Dann wird der Wert der Sum-Variablen über die Zeile return $sum an die Hauptroutine übergeben. Standardmäßig werden die Werte von $sum in der Standardvariablen $? gespeichert. Schließlich wird die Zeile echo "Das Ergebnis ist:" $? druckt das Ergebnis.

Note: Shell scripts can only return a single value.

Im Gegensatz zu anderen Programmiersprachen können Shell-Skripte nicht mehrere Werte von einer Funktion zurückgeben. Sehen wir uns dieses Beispiel an:

#!/bin/bash
add(){
    sum=$(($1+$2))
    dif=$(($1-$2))
    return $sum 
}

read -p "Enter an integer: " int1
read -p "Enter an integer: " int2
add $int1 $int2
echo "The result is: " $?
echo "The result is: " $?

Um es zusammenzufassen

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

#!/bin/bash
#####################
#Author: HowtoForge #
#####################
 
clear(){
    clear
}

bin(){
    bin1=$(echo "obase=2;$1"|bc)
    echo $bin1
}

dec(){
    dec1=$(echo "ibase=2;$1"|bc)
    return $dec1
}

########Main#########
    printf "Choose from the following operations:\n[1]Decimal to Binary Conversion\n"
    printf "[2]Binary to Decimal Conversion\n"
    read -p "Your choice: " op
    case $op in

    1)
        read -p "Enter integer number: " int
        bin $int
    ;;

    2)
        read -p "Enter binary number: " int
        dec $int
        echo "The decimal equivalent of $int is $?"
    ;;

    *)
        echo "Wrong Choice!"
    esac

Das gegebene Beispiel wandelt eine gegebene Eingabe mit dem Befehl obase und ibase sowohl in einen Binär- als auch in einen Dezimalwert um. Die Zeile $(echo "obase=2;$1"|bc) wandelt einen gegebenen Dezimalwert in eine Binärziffer um und speichert ihn in der Variablen bin1. Als nächstes haben wir den Wert von $bin1 mit dem Echo-Befehl angezeigt.

Note: It's better to use echo directly when converting from decimal to binary because when you return command to pass a binary value, the bash converts the binary value to decimal before returning it.

Zusätzlich haben wir den Binärwert mit dem Befehl $(echo "ibase=2;$1"|bc).

in einen Dezimalwert umgewandelt

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

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

Schlussfolgerung

Bash verfügt über Funktionalitäten, die Programmiersprachen sehr ähnlich sind, um dem Benutzer zahlreiche Werkzeuge zur Verfügung zu stellen und Linux-Systeme leistungsfähiger zu machen. In dieser Serie haben Sie Ihr Wissen über Shell-Scripting durch Funktionen erweitert. Funktionen in Shell-Skripten, um dem Benutzer Modularität zu bieten, die Fehlersuche in Skripten zu erleichtern und die Wiederverwendung von Code zu ermöglichen.