Bash-Funktion und Verwendung {Variablen, Argumente, Rückgabe}

Einführung

Eine Bash-Funktion ist eine Methode, die in Shell-Skripten verwendet wird, um wiederverwendbare Codeblöcke zu gruppieren. Diese Funktion ist für die meisten Programmiersprachen verfügbar, die unter verschiedenen Namen wie Prozeduren, Methoden oder Unterroutinen bekannt sind.

Dieser Artikel bietet einen vollständigen Überblick über Bash-Funktionen, ihre Funktionsweise und ihre Verwendung.

Voraussetzungen

• Ein System, auf dem Linux ausgeführt wird.
• Zugriff auf das Terminal und die Bash-Shell.
• Ein Texteditor zum Schreiben von Bash-Skripten (die Anleitung verwendet Vim).

Was sind Bash-Funktionen?

Eine Bash-Funktion ist eine Technik zum Gruppieren wiederverwendbarer Codebits unter einem Namen zur späteren Verwendung. Die Bash-Funktion ist wie ein Skript innerhalb eines Skripts.

Die Verwendung von Funktionen in Bash-Skripten hat zwei Vorteile :

1. Eine Funktion wird direkt in den Speicher der Shell eingelesen und zur späteren Verwendung gespeichert. Da der Computerspeicher heutzutage kein Problem mehr darstellt, ist die Verwendung von Funktionen schneller als Wiederholungscode.

2. Funktionen helfen dabei, lange Shell-Skripte in modulare und wiederverwendbare Codeblöcke zu organisieren. Die Chunks sind einfacher zu entwickeln und zu pflegen .

Wie verwende ich Bash-Funktionen?

Es gibt zwei Möglichkeiten, Bash-Funktionen zu implementieren:

• Innerhalb eines Shell-Skripts, wo die Funktionsdefinition vor allen Aufrufen der Funktion stehen muss.
• Neben anderen Bash-Alias-Befehlen und direkt im Terminal als Befehl.

Um Bash-Funktionen zu verwenden, befolgen Sie die nachstehenden Umrisse.

Bash-Funktionssyntax

Es gibt zwei verschiedene Möglichkeiten, eine Bash-Funktion zu deklarieren:

1. Das am weitesten verbreitete Format ist:

<function name> () { 
        <commands> 
}

Alternativ kann die gleiche Funktion eine Zeile sein:

<function name> () { <commands>; }

2. Die alternative Möglichkeit, eine Bash-Funktion zu schreiben, ist die Verwendung des reservierten Wortes function :

function <function name> {
        <commands>
}

Oder in einer Zeile:

function <function name> { <commands>; }

Beachten Sie bei der Verwendung von Funktionen die folgenden Verhaltensweisen und Tipps:

• Beim Schreiben in einer Zeile müssen die Befehle mit einem Semikolon enden (; ), ob in Bash-Skripten oder direkt im Terminal.
• Hinzufügen der function reserviertes Wort macht Klammern optional.
• Die Befehle zwischen den geschweiften Klammern { <commands> } werden als Body der Funktion bezeichnet . Der Körper kann eine beliebige Anzahl von Deklarationen, Variablen, Schleifen oder bedingten Anweisungen enthalten.
• Versuchen Sie, aussagekräftige Namen für Funktionen zu verwenden. Obwohl es beim Testen von Funktionen und Befehlen nicht erforderlich ist, helfen beschreibende Namen in Einstellungen, in denen andere Entwickler den Code betrachten.

Wie deklariert und ruft man eine Funktion auf?

Eine Funktion wird nicht ausgeführt, wenn sie deklariert ist. Der Rumpf der Funktion wird ausgeführt, wenn er nach der Deklaration aufgerufen wird. Führen Sie die folgenden Schritte aus, um ein Bash-Skript mit verschiedenen Syntaxoptionen zu erstellen:

1. Erstellen Sie mit Ihrem bevorzugten Texteditor ein Shell-Skript mit dem Namen syntax . Wenn Sie Vim verwenden, führen Sie die folgende Zeile im Terminal aus:

vim syntax.sh

2. Fügen Sie dem Shell-Skript den folgenden Code hinzu:

# syntax.sh
# Declaring functions using the reserved word function
# Multiline
function f1 {
        echo Hello I\'m function 1
        echo Bye!
}
# One line
function f2 { echo Hello I\'m function 2; echo Bye!; }

# Declaring functions without the function reserved word
# Multiline
f3 () { 
        echo Hello I\'m function 3
        echo Bye!
}
# One line
f4 () { echo Hello I\'m function 4; echo Bye!; }

# Invoking functions
f4
f3
f2
f1

Das Skript macht Folgendes:

• Zeilen 4-9 demonstrieren, wie eine Funktion mit function definiert wird reserviertes Wort. Die Funktion f1 verwendet in den Zeilen 4-6 eine mehrzeilige Syntax, während f2 verwendet eine Zeilensyntax in Zeile 9.
• Zeilen 13-18 zeigen die vertrautere Syntax. f3 ist eine mehrzeilige Funktion, die in den Zeilen 13-16 definiert ist, während f4 in Zeile 18 ist das einzeilige Äquivalent.
• Zeilen 21-24 Rufen Sie die zuvor definierten Funktionen auf und führen Sie die Befehle in den Körpern der entsprechenden Funktion aus. Die Aufrufe erfolgen in umgekehrter Reihenfolge der Definition.

3. Speichern Sie das Skript und schließen Sie Vim:

:wq

4. Erstellen Sie die syntax.sh ausführbare Datei:

chmod +x syntax.sh

5. Führen Sie zuletzt das Skript aus, um die Ausgabe anzuzeigen:

./syntax.sh

Wie deklariere und rufe ich eine Funktion im Terminal auf?

So deklarieren und verwenden Sie eine Funktion im Terminal:

1. Öffnen Sie das Terminal und geben Sie die folgende Zeile ein:

my_function () { echo "Hello I'm a function"; echo "Bye!"; }

2. Führen Sie die Funktion aus, indem Sie im Terminal den Namen der Funktion eingeben:

my_function

Die Ausgabe führt die Befehle im Hauptteil der Funktion aus.

Die Funktion bleibt nur in der aktuellen Terminalsitzung definiert. Um ihn für zukünftige Sitzungen zu speichern, fügen Sie den Code zu ~/.bashrc hinzu Datei.

Wo ist eine Bash-Funktion definiert?

Um zu sehen, wo eine Bash-Funktion definiert ist und welchen Inhalt sie hat, geben Sie die folgenden Befehle im Terminal ein:

1. Führen Sie die Bash-Shell im Debugger-Modus aus:

bash --debugger

2. Überprüfen Sie die Quelldatei der Funktion mit:

declare -F <function name>

Zum Beispiel:

declare -F my_function

Die Ausgabe gibt den Namen der Funktion, die Zeilennummer und den Speicherort der Funktionsdefinition aus.

3. Um den Inhalt der Funktion anzuzeigen, führen Sie Folgendes aus:

declare -f <function name>

Zum Beispiel:

declare -f my_function

Die declare Eingebaut im Debugging-Modus ermöglicht das Anzeigen des Inhalts und der Position der Funktion, ohne den Code auszuführen.

Wie lösche ich eine Bash-Funktion?

Wenn Sie einen Namespace freigeben müssen, der von einer Funktion in der aktuellen Terminalsitzung belegt ist, führen Sie Folgendes aus:

unset <function name>

Zum Beispiel:

unset my_function

Die Funktion ist in der aktuellen Terminalsitzung nicht mehr verfügbar. Wenn sich der Code jedoch in der Datei ~/.bashrc befindet Datei, wird in der nächsten Sitzung alles wieder normalisiert.

Bash-Funktionsvariablen

Die Variablen in bash sind standardmäßig global und von überall aus zugänglich, einschließlich Funktionskörpern. Innerhalb einer Funktion definierte Variablen sind ebenfalls global. Hinzufügen des Schlüsselworts local macht den Begriff nur innerhalb der Funktion und der untergeordneten Funktionen/Prozesse zugänglich.

Im dynamischen Scoping , eine lokale Variable Schatten eine globale Variable, wenn beide denselben Namen tragen.

Probieren Sie das folgende Bash-Skript aus, um zu demonstrieren, wie Funktionsvariablen in Bash funktionieren:

1. Erstellen Sie ein Skript namens variable.sh :

vim variable.sh

2. Fügen Sie dem Skript den folgenden Code hinzu:

var1=1
var2=1
change() {
        echo Inside function
        echo Variable 1 is: $var1
        echo Variable 2 is: $var2
        local var1=5
        var2=5
        echo
        echo After change inside function
        echo Variable 1 is locally $var1
        echo Variable 2 is globally $var2
}
echo Before function invocation
echo Variable 1 is: $var1
echo Variable 2 is: $var2
echo
change
echo
echo After function invocation
echo Variable 1 is: $var1
echo Variable 2 is: $var2

Das Skript zeigt Folgendes:

• Zeilen 1-2 deklarieren Sie Variablen var1 und var2 und setzen Sie beide auf 1 .
• Zeilen 5-6 befinden sich im Körper der Funktion und geben die Variablen an die Konsole aus. Da der Gültigkeitsbereich der Variablen global ist, werden die ursprünglichen Werte ausgegeben.
• Zeile 7 deklariert eine neue lokale Variable mit demselben Namen wie die globale Variable var1 . Die local var1 schattiert die globale var1 Wert aufgrund dynamischer Scoping.
• Zeile 8 ändert den Wert des globalen var2 variabel.
• Zeilen 14-22 Gibt die Variablenwerte vor und nach dem Aufruf der Funktion aus.

3. Speichern Sie das Skript und beenden Sie Vim:

:wq

4. Ändern Sie die Dateiberechtigungen in ausführbar:

chmod +x variable.sh

5. Führen Sie das Skript aus und analysieren Sie die Ergebnisse:

./variable.sh

Die Variablenwerte werden durch die im Skript vorgenommenen Änderungen auf der Konsole ausgegeben.

Bash-Funktionsargumente

Um Argumente an eine Funktion zu übergeben, fügen Sie die Parameter nach dem Funktionsaufruf durch Leerzeichen getrennt hinzu. Die folgende Tabelle zeigt die verfügbaren Optionen beim Arbeiten mit Bash-Funktionsargumenten.

Argument	Rolle
$0	Reserviert den Namen der Funktion, wenn sie im Terminal definiert ist. Wenn in einem Bash-Skript definiert, $0 gibt den Namen und den Speicherort des Skripts zurück.
$1 , $2 usw.	Entspricht der Position des Arguments nach dem Funktionsnamen.
$#	Hält die Anzahl der an die Funktion übergebenen Positionsargumente.
[email protected] und $*	Behält die Liste der Positionsargumente und funktioniert genauso, wenn sie auf diese Weise verwendet wird.
"[email protected]"	Erweitert die Liste auf separate Zeichenfolgen. Zum Beispiel "$1", "$2" usw.
"$*"	Erweitert die Liste zu einer einzelnen Zeichenfolge, wobei die Parameter durch ein Leerzeichen getrennt werden. Zum Beispiel "$1 $2" usw.

Führen Sie die folgenden Schritte aus, um zu testen, wie die verschiedenen Argumente in einer Funktion funktionieren.

1. Erstellen Sie ein Skript namens arguments :

vim arguments.sh

2. Fügen Sie den folgenden Code in das Skript ein:

arguments () {
        echo The function location is $0
        echo There are $# arguments
        echo "Argument 1 is $1"
        echo "Argument 2 is $2"
        echo "<[email protected]>" and "<$*>" are the same.
        echo List the elements in a for loop to see the difference!
        echo "* gives:"
        for arg in "$*"; do echo "<$arg>"; done
        echo "@ gives:"
        for arg in "[email protected]"; do echo "<$arg>"; done
}

arguments hello world

3. Speichern Sie das Skript und beenden Sie Vim:

:wq

4. Machen Sie das Skript ausführbar:

chmod +x arguments.sh

5. Führen Sie das Skript aus:

./arguments.sh

Die Ausgabe zeigt beschreibende Meldungen für jedes verwendete Argument an.

Rückgabe der Bash-Funktion

Bash-Funktionen unterscheiden sich von den meisten Programmiersprachen, wenn es darum geht, einen Wert von einer Funktion zurückzugeben. Standardmäßig gibt bash den Beendigungsstatus zurück des zuletzt ausgeführten Befehls im Hauptteil der Funktion.

Das folgende Skript zeigt, wie der Exit-Status mit return:

angegeben wird

1. Erstellen Sie ein Skript und nennen Sie es test.sh :

vim test.sh

2. Fügen Sie der Datei die folgende Funktion hinzu:

test_function() {
        echo Test
        return 100
}
echo The function\'s output is: 
test_function
echo The exit status is:
echo $?

3. Speichern und schließen Sie den Texteditor:

:wq

4. Ändern Sie die Berechtigungen:

chmod +x test.sh

5. Führen Sie das Skript aus, um die Ausgabe und den Beendigungsstatus der Funktion anzuzeigen:

./test.sh

Eine alternative Methode ist, das Ergebnis der Funktion wiederzugeben und die Ausgabe einer Variablen zuzuweisen. Bearbeiten Sie die test.sh Skript mit folgendem Code:

test_function() {
        echo Test
}
result=$(test_function)
echo $result is saved in a variable for later use

Diese Methode ahmt nach, wie die meisten Programmiersprachen bei der Verwendung von Funktionen arbeiten.