Bash-Funktionen

Eine Bash-Funktion ist im Wesentlichen eine Reihe von Befehlen, die mehrmals aufgerufen werden können. Der Zweck einer Funktion besteht darin, Ihnen zu helfen, Ihre Bash-Skripte besser lesbar zu machen und zu vermeiden, denselben Code wiederholt zu schreiben. Im Vergleich zu den meisten Programmiersprachen sind Bash-Funktionen etwas eingeschränkt.

In diesem Tutorial behandeln wir die Grundlagen von Bash-Funktionen und zeigen Ihnen, wie Sie sie in Ihren Shell-Skripten verwenden.

Bash-Funktionen definieren #

Die Syntax zum Deklarieren einer Bash-Funktion ist einfach. Funktionen können in zwei verschiedenen Formaten deklariert werden:

1. Das erste Format beginnt mit dem Funktionsnamen, gefolgt von Klammern. Dies ist das bevorzugte und am häufigsten verwendete Format.

   function_name () {
     commands
   }

   Einzeilige Version:

   function_name () { commands; }

2. Das zweite Format beginnt mit dem reservierten Wort function , gefolgt vom Funktionsnamen.

   function function_name {
     commands
   }

   Einzeilige Version:

   function function_name { commands; }

Einige Punkte, die beachtet werden müssen:

• Die Befehle zwischen den geschweiften Klammern ({} ) werden als Rumpf der Funktion bezeichnet. Die geschweiften Klammern müssen durch Leerzeichen oder Zeilenumbrüche vom Textkörper getrennt werden.
• Das Definieren einer Funktion führt sie nicht aus. Um eine Bash-Funktion aufzurufen, verwenden Sie einfach den Funktionsnamen. Befehle zwischen den geschweiften Klammern werden immer dann ausgeführt, wenn die Funktion im Shell-Skript aufgerufen wird.
• Die Funktionsdefinition muss vor allen Aufrufen der Funktion platziert werden.
• Bei Verwendung von einzeiligen „komprimierten“ Funktionen ein Semikolon ; muss dem letzten Befehl in der Funktion folgen.
• Versuchen Sie immer, Ihre Funktionsnamen aussagekräftig zu halten.

Um dies besser zu verstehen, werfen Sie einen Blick auf das folgende Beispiel:

~/hello_world.sh

#!/bin/bash

hello_world () {
   echo 'hello, world'
}

hello_world

Analysieren wir den Code Zeile für Zeile:

• In Zeile 3 definieren wir die Funktion, indem wir ihr einen Namen geben. Die geschweifte Klammer { markiert den Anfang des Hauptteils der Funktion.
• Zeile 4 ist der Funktionskörper. Der Funktionskörper kann mehrere Befehle, Anweisungen und Variablendeklarationen enthalten.
• Zeile 5 , die schließende geschweifte Klammer } , definiert das Ende von hello_world Funktion.
• In Zeile 7 Wir führen die Funktion aus. Sie können die Funktion beliebig oft ausführen.

Wenn Sie das Skript ausführen, wird es hello, world ausgeben .

Variablenbereich #

Globale Variablen sind Variablen, auf die unabhängig vom Gültigkeitsbereich von überall im Skript zugegriffen werden kann. In Bash sind alle Variablen standardmäßig als global definiert, auch wenn sie innerhalb der Funktion deklariert sind.

Lokale Variablen können innerhalb des Funktionskörpers mit dem local deklariert werden Schlüsselwort und kann nur innerhalb dieser Funktion verwendet werden. Sie können lokale Variablen mit demselben Namen in verschiedenen Funktionen haben.

Um besser zu veranschaulichen, wie der Gültigkeitsbereich von Variablen in Bash funktioniert, betrachten wir dieses Beispiel:

~/variables_scope.sh

#!/bin/bash

var1='A'
var2='B'

my_function () {
  local var1='C'
  var2='D'
  echo "Inside function: var1: $var1, var2: $var2"
}

echo "Before executing function: var1: $var1, var2: $var2"

my_function

echo "After executing function: var1: $var1, var2: $var2"

Das Skript beginnt mit der Definition von zwei globalen Variablen var1 und var2 . Dann gibt es eine Funktion, die eine lokale Variable var1 setzt und modifiziert die globale Variable var2 .

Wenn Sie das Skript ausführen, sollten Sie die folgende Ausgabe sehen:

Before executing function: var1: A, var2: B
Inside function: var1: C, var2: D
After executing function: var1: A, var2: D

Aus der obigen Ausgabe können wir Folgendes schließen:

• Wenn eine lokale Variable innerhalb des Funktionskörpers mit demselben Namen wie eine vorhandene globale Variable gesetzt wird, hat sie Vorrang vor der globalen Variablen.
• Globale Variablen können innerhalb der Funktion geändert werden.

Rückgabewerte #

Im Gegensatz zu Funktionen in „echten“ Programmiersprachen erlauben Ihnen Bash-Funktionen nicht, beim Aufruf einen Wert zurückzugeben. Wenn eine Bash-Funktion abgeschlossen ist, ist ihr Rückgabewert der Status der letzten in der Funktion ausgeführten Anweisung, 0 für Erfolg und eine Dezimalzahl ungleich Null im Bereich von 1 - 255 für Fehler.

Der Rückgabestatus kann mit return angegeben werden Schlüsselwort, und es wird der Variablen $? zugewiesen . Die return Anweisung beendet die Funktion. Sie können es sich als den Exit-Status der Funktion vorstellen.

~/return_values.sh

#!/bin/bash

my_function () {
  echo "some result"
  return 55
}

my_function
echo $?

some result
55

Um tatsächlich einen beliebigen Wert von einer Funktion zurückzugeben, müssen wir andere Methoden verwenden. Die einfachste Möglichkeit besteht darin, das Ergebnis der Funktion einer globalen Variablen zuzuweisen:

~/return_values.sh

#!/bin/bash

my_function () {
  func_result="some result"
}

my_function
echo $func_result

some result

Eine andere, bessere Möglichkeit, einen Wert von einer Funktion zurückzugeben, besteht darin, den Wert an stdout zu senden mit echo oder printf wie unten gezeigt:

~/return_values.sh

#!/bin/bash

my_function () {
  local func_result="some result"
  echo "$func_result"
}

func_result="$(my_function)"
echo $func_result

some result

Anstatt einfach die Funktion auszuführen, die die Nachricht auf stdout ausgibt, weisen wir die Funktionsausgabe dem func_result zu Variable mit $() Befehlsersetzung. Die Variable kann später bei Bedarf verwendet werden.

Argumente an Bash-Funktionen übergeben #

Um eine beliebige Anzahl von Argumenten an die Bash-Funktion zu übergeben, fügen Sie sie einfach direkt nach dem Namen der Funktion ein, getrennt durch ein Leerzeichen. Es ist eine gute Praxis, die Argumente in doppelte Anführungszeichen zu setzen, um zu vermeiden, dass ein Argument mit Leerzeichen falsch geparst wird.

• Die übergebenen Parameter sind $1 , $2 , $3 … $n , entsprechend der Position des Parameters nach dem Namen der Funktion.
• Der $0 Variable ist für den Namen der Funktion reserviert.
• Der $# Die Variable enthält die Anzahl der Positionsparameter/-argumente, die an die Funktion übergeben werden.
• Der $* und $@ Variablen enthalten alle Positionsparameter/-argumente, die an die Funktion übergeben werden.
  • Bei doppelten Anführungszeichen "$*" wird zu einer einzelnen Zeichenfolge erweitert, die durch Leerzeichen getrennt ist (das erste Zeichen von IFS) - "$1 $2 $n" .
  • Bei doppelten Anführungszeichen "$@" wird zu separaten Zeichenfolgen erweitert - "$1" "$2" "$n" .
  • Wenn nicht in doppelte Anführungszeichen gesetzt, $* und $@ sind gleich.

Hier ist ein Beispiel:

~/passing_arguments.sh

#!/bin/bash

greeting () {
  echo "Hello $1"
}

greeting "Joe"

Hello Joe

Schlussfolgerung #

Eine Bash-Funktion ist ein Block aus wiederverwendbarem Code, der zur Ausführung einer bestimmten Operation entwickelt wurde. Einmal definiert, kann die Funktion innerhalb eines Skripts mehrfach aufgerufen werden.

Vielleicht möchten Sie auch lesen, wie Sie eine Bash-Funktion verwenden, um einen einprägsamen Kurzbefehl für einen längeren Befehl zu erstellen.

Wenn Sie Fragen oder Feedback haben, können Sie gerne einen Kommentar hinterlassen.