Rückgabewerte von Bash-Funktionen

Einführung

Dieses umfassende Tutorial untersucht die Rückgabewerte von Bash-Funktionen und vermittelt Ihnen das notwendige Wissen und die Techniken, um effektiv mit Funktionen in Bash-Skripten zu arbeiten. Egal, ob Sie neu in der Shell-Skripting sind oder Ihre Fähigkeiten verbessern möchten, dieser Leitfaden vermittelt Ihnen ein solides Verständnis davon, wie Sie Funktionsrückgabewerte definieren, aufrufen und verarbeiten. Mit diesen Fähigkeiten können Sie robuster und flexiblere Shell-Skripte für verschiedene Automatisierungsaufgaben schreiben.

Erstellen Ihrer ersten Bash-Funktion

Bash-Funktionen sind wiederverwendbare Codeblöcke, die helfen, Ihre Skripte besser zu organisieren. Bevor wir uns den Rückgabewerten zuwenden, wollen wir zunächst verstehen, wie man eine Funktion erstellt und aufruft.

Erstellen einer einfachen Funktion

Erstellen wir nun unsere erste Bash-Funktion. Öffnen Sie ein Terminalfenster und geben Sie ein:

cd ~/project
mkdir -p bash_functions
cd bash_functions

Verzeichnis erstellen

Jetzt erstellen wir eine einfache Funktion in einem neuen Skript. Erstellen Sie mit nano eine Datei namens first_function.sh:

touch first_function.sh

Fügen Sie der Datei den folgenden Inhalt hinzu:

#!/bin/bash

## Define a simple greeting function
say_hello() {
  echo "Hello, world!"
}

## Call the function
say_hello

## Define a function that accepts arguments
greet_person() {
  echo "Hello, $1!"
}

## Call the function with an argument
greet_person "Alice"
greet_person "Bob"

Machen Sie das Skript ausführbar:

chmod +x first_function.sh

Führen Sie nun das Skript aus:

./first_function.sh

Sie sollten die folgende Ausgabe sehen:

Hello, world!
Hello, Alice!
Hello, Bob!

Erklärung der Funktionssyntax

In Bash gibt es zwei Möglichkeiten, Funktionen zu definieren:

Mit der Standard-Syntax:

function_name() {
  ## Commands
}

Mit dem Schlüsselwort function:

function function_name {
  ## Commands
}

Beide Schreibweisen funktionieren gleich, aber die erste wird häufiger verwendet und ist POSIX-konform.

Zugriff auf Funktionsargumente

Innerhalb einer Funktion können Sie die an die Funktion übergebenen Argumente mithilfe von Positionsparametern zugreifen:

$1, $2, $3 usw. beziehen sich auf das erste, zweite, dritte Argument und so weiter
$0 bezieht sich auf den Funktionsnamen oder den Skriptnamen
$# gibt die Anzahl der Argumente an
$@ enthält alle Argumente als separate Zeichenketten
$* enthält alle Argumente als eine einzelne Zeichenkette

Erstellen wir eine neue Datei, um mit Funktionsargumenten zu üben:

touch function_args.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

show_args() {
  echo "Function name: $0"
  echo "First argument: $1"
  echo "Second argument: $2"
  echo "Number of arguments: $#"
  echo "All arguments: $@"
}

echo "Calling function with three arguments:"
show_args apple banana cherry

Speichern Sie die Datei, machen Sie das Skript ausführbar und führen Sie es aus:

chmod +x function_args.sh
./function_args.sh

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Calling function with three arguments:
Function name: ./function_args.sh
First argument: apple
Second argument: banana
Number of arguments: 3
All arguments: apple banana cherry

Dieses grundlegende Verständnis von Funktionsdefinitionen und der Argumentverarbeitung bildet die Grundlage für die Arbeit mit Funktionsrückgabewerten in den nächsten Schritten.

Verständnis von Funktions-Rückgabecodes

Jeder Befehl in Bash, einschließlich Funktionen, erzeugt einen Rückgabecode (auch als Exit-Status bezeichnet). Dieser numerische Wert gibt an, ob der Befehl erfolgreich war oder fehlgeschlagen ist. Dieser Rückgabecode ist von grundlegender Bedeutung für die Fehlerbehandlung in Bash-Skripten.

Grundlegende Rückgabecodes

In Bash gilt:

Ein Rückgabecode von 0 zeigt Erfolg an.
Jeder von Null verschiedene Wert (1 - 255) zeigt einen Fehler oder einen abnormalen Zustand an.

Erstellen wir ein Skript, um dies zu demonstrieren:

cd ~/project/bash_functions
touch return_codes.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

## Function that always succeeds
succeed() {
  echo "This function succeeds"
  return 0
}

## Function that always fails
fail() {
  echo "This function fails"
  return 1
}

## Call the functions and check their return codes
succeed
echo "Return code of succeed: $?"

fail
echo "Return code of fail: $?"

Speichern Sie das Skript, machen Sie es ausführbar und führen Sie es aus:

chmod +x return_codes.sh
./return_codes.sh

Sie sollten folgende Ausgabe sehen:

This function succeeds
Return code of succeed: 0
This function fails
Return code of fail: 1

Erfassen von Rückgabecodes

Die spezielle Variable $? enthält den Rückgabecode des zuletzt ausgeführten Befehls oder der zuletzt ausgeführten Funktion. Dieser Wert ist wichtig für die bedingte Ausführung und die Fehlerbehandlung.

Erstellen wir ein weiteres Skript, um die Verwendung von Rückgabecodes für bedingte Logik zu üben:

touch check_file.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

## Function to check if a file exists
file_exists() {
  local filename="$1"

  if [ -f "$filename" ]; then
    echo "File $filename exists"
    return 0
  else
    echo "File $filename does not exist"
    return 1
  fi
}

## Test the function with files that exist and don't exist
file_exists "return_codes.sh"
if [ $? -eq 0 ]; then
  echo "Great! The file was found."
else
  echo "Too bad. The file was not found."
fi

echo ""

file_exists "non_existent_file.txt"
if [ $? -eq 0 ]; then
  echo "Great! The file was found."
else
  echo "Too bad. The file was not found."
fi

Speichern Sie das Skript, machen Sie es ausführbar und führen Sie es aus:

chmod +x check_file.sh
./check_file.sh

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

File return_codes.sh exists
Great! The file was found.

File non_existent_file.txt does not exist
Too bad. The file was not found.

Verwendung von Rückgabecodes in bedingten Anweisungen

Der Rückgabecode kann direkt in bedingten Ausdrücken mit den Operatoren && (UND) und || (ODER) verwendet werden:

touch conditional_return.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

check_number() {
  local num=$1

  if [ $num -gt 10 ]; then
    return 0 ## Success if number is greater than 10
  else
    return 1 ## Failure if number is not greater than 10
  fi
}

## Using conditional operators with return codes
check_number 15 && echo "Number is greater than 10"
check_number 5 || echo "Number is not greater than 10"

## This line runs only if check_number succeeds
check_number 20 && {
  echo "Number is greater than 10"
  echo "Performing additional operations..."
}

## This line runs only if check_number fails
check_number 3 || {
  echo "Number is not greater than 10"
  echo "Taking alternative actions..."
}

Speichern Sie das Skript, machen Sie es ausführbar und führen Sie es aus:

chmod +x conditional_return.sh
./conditional_return.sh

Die Ausgabe sollte wie folgt aussehen:

Number is greater than 10
Number is not greater than 10
Number is greater than 10
Performing additional operations...
Number is not greater than 10
Taking alternative actions...

Das Verständnis, wie Rückgabecodes funktionieren, ist unerlässlich für das Schreiben von robusten Skripten, die Fehler richtig behandeln und Entscheidungen auf der Grundlage des Erfolgs oder Misserfolgs von Operationen treffen können.

Arbeiten mit benutzerdefinierten Rückgabewerten

Während Rückgabecodes nützlich sind, um Erfolg oder Misserfolg anzuzeigen, sind sie auf Zahlen zwischen 0 und 255 beschränkt. Um tatsächliche Daten aus Funktionen zurückzugeben, müssen wir andere Techniken verwenden.

Methode 1: Verwenden von Echo zum Rückgeben von Werten

Der häufigste Weg, um tatsächliche Werte aus Funktionen zurückzugeben, ist die Verwendung von echo oder anderen Ausgabebefehlen und die anschließende Erfassung dieser Ausgabe.

Erstellen wir ein Skript, um diese Technik zu demonstrieren:

cd ~/project/bash_functions
touch return_values.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

## Function that returns a value using echo
get_username() {
  echo "labex"
}

## Function that returns a calculated value
add_numbers() {
  local sum=$(($1 + $2))
  echo $sum
}

## Capture the returned values
username=$(get_username)
echo "The username is: $username"

result=$(add_numbers 5 7)
echo "The sum of 5 and 7 is: $result"

## You can also use the returned value directly
echo "Calculating again: $(add_numbers 10 20)"

Speichern Sie das Skript, machen Sie es ausführbar und führen Sie es aus:

chmod +x return_values.sh
./return_values.sh

Sie sollten folgende Ausgabe sehen:

The username is: labex
The sum of 5 and 7 is: 12
Calculating again: 30

Methode 2: Verwenden von globalen Variablen

Ein anderer Ansatz besteht darin, globale Variablen innerhalb der Funktion zu ändern:

touch global_return.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

## Declare global variables
FULL_NAME=""
USER_AGE=0

## Function that sets global variables
set_user_info() {
  FULL_NAME="$1 $2"
  USER_AGE=$3

  ## Return success
  return 0
}

## Call the function
set_user_info "John" "Doe" 30

## Use the global variables that were set by the function
echo "Full name: $FULL_NAME"
echo "Age: $USER_AGE"

Speichern Sie das Skript, machen Sie es ausführbar und führen Sie es aus:

chmod +x global_return.sh
./global_return.sh

Ausgabe:

Full name: John Doe
Age: 30

Methode 3: Rückgeben mehrerer Werte

Untersuchen wir, wie man mehrere Werte aus einer Funktion zurückgibt:

touch multiple_returns.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

## Function that returns multiple values separated by a delimiter
get_system_info() {
  local hostname=$(hostname)
  local kernel=$(uname -r)
  local uptime=$(uptime -p)

  ## Return multiple values separated by semicolons
  echo "$hostname;$kernel;$uptime"
}

## Capture the output and split it
system_info=$(get_system_info)

## Split the values using IFS (Internal Field Separator)
IFS=';' read -r host kernel up <<< "$system_info"

## Display the values
echo "Hostname: $host"
echo "Kernel version: $kernel"
echo "Uptime: $up"

## Alternative method using an array
get_user_details() {
  local details=("John Doe" "john@example.com" "Developer")
  printf "%s\n" "${details[@]}"
}

## Capture the output into an array
mapfile -t user_details < <(get_user_details)

echo ""
echo "User information:"
echo "Name: ${user_details[0]}"
echo "Email: ${user_details[1]}"
echo "Role: ${user_details[2]}"

Speichern Sie das Skript, machen Sie es ausführbar und führen Sie es aus:

chmod +x multiple_returns.sh
./multiple_returns.sh

Die Ausgabe sollte zunächst Ihre Systeminformationen und dann die Benutzerdetails anzeigen:

Hostname: ubuntu
Kernel version: 5.15.0-1033-azure
Uptime: up 2 hours, 15 minutes

User information:
Name: John Doe
Email: john@example.com
Role: Developer

Der tatsächliche Hostname, die Kernel-Version und die Betriebszeit variieren je nach Ihrem System.

Diese Methoden zeigen verschiedene Möglichkeiten, Werte aus Funktionen zurückzugeben, die über einfache Rückgabecodes hinausgehen. Jeder Ansatz hat seine Vorteile, je nach Ihren spezifischen Anforderungen.

Praktische Verwendung von Funktionen in einem Skript

Nachdem wir nun verstehen, wie man Funktionen definiert und deren Rückgabewerte verarbeitet, wollen wir ein praktisches Skript erstellen, das diese Konzepte in Aktion zeigt. Wir werden ein Dateiverwaltungs-Utilitär erstellen, das Funktionen mit verschiedenen Rückgabemethoden verwendet.

Erstellen des Dateiverwaltungs-Utilitärs

Erstellen wir ein umfassendes Skript, das verschiedene Dateioperationen ausführt:

cd ~/project/bash_functions
touch file_manager.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

## Function to check if a file exists
## Returns 0 if file exists, 1 if it doesn't
file_exists() {
  if [ -f "$1" ]; then
    return 0
  else
    return 1
  fi
}

## Function to get file size in bytes
## Returns the size via echo
get_file_size() {
  if file_exists "$1"; then
    ## Use stat to get file size in bytes
    local size=$(stat -c %s "$1")
    echo "$size"
  else
    echo "0"
  fi
}

## Function to count lines in a file
## Returns line count via echo
count_lines() {
  if file_exists "$1"; then
    local lines=$(wc -l < "$1")
    echo "$lines"
  else
    echo "0"
  fi
}

## Function to get file information
## Returns multiple values using a delimiter
get_file_info() {
  local filename="$1"

  if file_exists "$filename"; then
    local size=$(get_file_size "$filename")
    local lines=$(count_lines "$filename")
    local modified=$(stat -c %y "$filename")
    local permissions=$(stat -c %A "$filename")

    ## Return all info with semicolons as delimiters
    echo "$size;$lines;$modified;$permissions"
  else
    echo "0;0;N/A;N/A"
  fi
}

## Function to create a test file
create_test_file() {
  local filename="$1"
  local lines="$2"

  ## Create or overwrite the file
  > "$filename"

  ## Add the specified number of lines
  for ((i = 1; i <= lines; i++)); do
    echo "This is line $i of the test file." >> "$filename"
  done

  ## Return success if file was created
  if file_exists "$filename"; then
    return 0
  else
    return 1
  fi
}

## Main script execution starts here
echo "File Management Utility"
echo "----------------------"

## Create a test file
TEST_FILE="sample.txt"
echo "Creating test file with 10 lines..."
if create_test_file "$TEST_FILE" 10; then
  echo "File created successfully."
else
  echo "Failed to create file."
  exit 1
fi

## Check if file exists
echo ""
echo "Checking if file exists..."
if file_exists "$TEST_FILE"; then
  echo "File '$TEST_FILE' exists."
else
  echo "File '$TEST_FILE' does not exist."
fi

## Get file size
echo ""
echo "Getting file size..."
size=$(get_file_size "$TEST_FILE")
echo "File size: $size bytes"

## Count lines
echo ""
echo "Counting lines in file..."
lines=$(count_lines "$TEST_FILE")
echo "Line count: $lines"

## Get all file information
echo ""
echo "Getting complete file information..."
file_info=$(get_file_info "$TEST_FILE")

## Split the returned values
IFS=';' read -r size lines modified permissions <<< "$file_info"

echo "File: $TEST_FILE"
echo "Size: $size bytes"
echo "Lines: $lines"
echo "Last modified: $modified"
echo "Permissions: $permissions"

echo ""
echo "File content preview:"
head -n 3 "$TEST_FILE"
echo "..."

Speichern Sie das Skript, machen Sie es ausführbar und führen Sie es aus:

chmod +x file_manager.sh
./file_manager.sh

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

File Management Utility
----------------------
Creating test file with 10 lines...
File created successfully.

Checking if file exists...
File 'sample.txt' exists.

Getting file size...
File size: 300 bytes

Counting lines in file...
Line count: 10

Getting complete file information...
File: sample.txt
Size: 300 bytes
Lines: 10
Last modified: 2023-11-04 12:34:56.789012345 +0000
Permissions: -rwxrwxr-x

File content preview:
This is line 1 of the test file.
This is line 2 of the test file.
This is line 3 of the test file.
...

Die genauen Werte für die Dateigröße, die Änderungszeit und die Berechtigungen variieren.

Analyse des Skripts

Unser Dateiverwaltungs-Utilitär zeigt mehrere Schlüsselkonzepte:

Rückgabecodes - Die Funktionen file_exists() und create_test_file() geben 0 für Erfolg und 1 für Misserfolg zurück.
Rückgabe von Werten mit echo - Die Funktionen get_file_size() und count_lines() geben numerische Werte über echo zurück.
Rückgabe mehrerer Werte - Die Funktion get_file_info() gibt mehrere Werte unter Verwendung eines Trennzeichens zurück.
Funktionszusammensetzung - Einige Funktionen rufen andere Funktionen auf, was zeigt, wie man komplexe Funktionalität aufbauen kann.
Bedingte Ausführung - Das Skript verwendet if-Anweisungen mit Rückgabecodes, um den Programmablauf zu steuern.

Dieses praktische Beispiel zeigt, wie man verschiedene Funktionstechniken kombiniert, um ein nützliches Utilitär zu erstellen. Das Skript demonstriert die richtige Fehlerbehandlung, die Funktionszusammensetzung und verschiedene Methoden zum Rückgeben von Werten.

Fehlerbehandlung und Best Practices für Funktionen

In unserem letzten Abschnitt wollen wir Techniken zur Fehlerbehandlung und Best Practices für Bash-Funktionen untersuchen. Die richtige Fehlerbehandlung ist von entscheidender Bedeutung für die Erstellung von robusten und wartbaren Skripten.

Erstellen eines Skripts mit Fehlerbehandlung

Erstellen wir ein neues Skript, das eine robuste Fehlerbehandlung zeigt:

cd ~/project/bash_functions
touch error_handling.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

## Enable error handling
set -e ## Exit immediately if a command exits with non-zero status

## Define a function to log messages
log_message() {
  local level="$1"
  local message="$2"
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$level] $message"
}

## Function to validate a number is positive
validate_positive() {
  local num="$1"
  local name="$2"

  ## Check if the argument is a number
  if ! [[ "$num" =~ ^[0-9]+$ ]]; then
    log_message "ERROR" "$name must be a number"
    return 1
  fi

  ## Check if the number is positive
  if [ "$num" -le 0 ]; then
    log_message "ERROR" "$name must be positive"
    return 2
  fi

  return 0
}

## Function that divides two numbers
divide() {
  local numerator="$1"
  local denominator="$2"

  ## Validate inputs
  validate_positive "$numerator" "Numerator" || return $?
  validate_positive "$denominator" "Denominator" || return $?

  ## Check for division by zero
  if [ "$denominator" -eq 0 ]; then
    log_message "ERROR" "Division by zero is not allowed"
    return 3
  fi

  ## Perform division
  local result=$(echo "scale=2; $numerator / $denominator" | bc)
  echo "$result"
  return 0
}

## Function to safely get user input
get_number() {
  local prompt="$1"
  local input

  while true; do
    read -p "$prompt: " input

    if validate_positive "$input" "Input"; then
      echo "$input"
      return 0
    else
      log_message "WARN" "Invalid input. Please try again."
    fi
  done
}

## Disable automatic exit on error for the main script
set +e

## Main script logic
log_message "INFO" "Starting division calculator"

## Test with valid values
result=$(divide 10 2)
exit_code=$?

if [ $exit_code -eq 0 ]; then
  log_message "INFO" "10 / 2 = $result"
else
  log_message "ERROR" "Division failed with code $exit_code"
fi

## Test with invalid values
echo ""
log_message "INFO" "Testing with invalid values"
divide 0 5
log_message "INFO" "Exit code: $?"

divide 10 0
log_message "INFO" "Exit code: $?"

divide abc 5
log_message "INFO" "Exit code: $?"

## Interactive mode
echo ""
log_message "INFO" "Interactive mode"
echo "Let's perform a division. Enter positive numbers."

## Get user input safely
num1=$(get_number "Enter first number")
num2=$(get_number "Enter second number")

## Perform division
result=$(divide "$num1" "$num2")
exit_code=$?

if [ $exit_code -eq 0 ]; then
  log_message "INFO" "$num1 / $num2 = $result"
else
  log_message "ERROR" "Division failed with code $exit_code"
fi

log_message "INFO" "Calculator finished"

Speichern Sie das Skript, machen Sie es ausführbar und führen Sie es aus:

chmod +x error_handling.sh
./error_handling.sh

Sie werden eine Ausgabe ähnlich der folgenden sehen und aufgefordert, Zahlen einzugeben:

[2023-11-04 13:45:23] [INFO] Starting division calculator
[2023-11-04 13:45:23] [INFO] 10 / 2 = 5.00

[2023-11-04 13:45:23] [INFO] Testing with invalid values
[2023-11-04 13:45:23] [ERROR] Numerator must be positive
[2023-11-04 13:45:23] [INFO] Exit code: 2
[2023-11-04 13:45:23] [ERROR] Division by zero is not allowed
[2023-11-04 13:45:23] [INFO] Exit code: 3
[2023-11-04 13:45:23] [ERROR] Numerator must be a number
[2023-11-04 13:45:23] [INFO] Exit code: 1

[2023-11-04 13:45:23] [INFO] Interactive mode
Let's perform a division. Enter positive numbers.
Enter first number:

Geben Sie eine Zahl ein, beispielsweise 20. Dann werden Sie zur Eingabe der zweiten Zahl aufgefordert:

Enter second number:

Geben Sie eine weitere Zahl ein, beispielsweise 4, und Sie sollten Folgendes sehen:

[2023-11-04 13:45:30] [INFO] 20 / 4 = 5.00
[2023-11-04 13:45:30] [INFO] Calculator finished

Best Practices für Bash-Funktionen

Basierend auf unseren Beispielen sind hier einige Best Practices für die Arbeit mit Bash-Funktionen:

Fügen Sie beschreibende Kommentare hinzu - Dokumentieren Sie, was jede Funktion tut, ihre Parameter und Rückgabewerte.
Verwenden Sie aussagekräftige Funktionsnamen - Wählen Sie Namen, die eindeutig den Zweck der Funktion anzeigen.
Validieren Sie Eingabeparameter - Überprüfen Sie die Eingaben, um Fehler zu vermeiden.
Verwenden Sie lokale Variablen - Verhindern Sie Namenskonflikte von Variablen mit dem Schlüsselwort local.
Geben Sie geeignete Exit-Codes zurück - Verwenden Sie konventionelle Rückgabecodes (0 für Erfolg, von Null verschiedene Werte für Fehler).
Implementieren Sie eine richtige Fehlerbehandlung - Protokollieren Sie Fehler und behandeln Sie sie gracefully.
Halten Sie Funktionen fokussiert - Jede Funktion sollte eine Aufgabe gut erledigen.
Verwenden Sie Funktionszusammensetzung - Bauen Sie komplexe Funktionalität auf, indem Sie einfachere Funktionen kombinieren.
Dokumentieren Sie Rückgabewerte - Dokumentieren Sie eindeutig, wie Werte zurückgegeben werden (über echo, Rückgabecode usw.).
Testen Sie Randfälle - Stellen Sie sicher, dass Funktionen ungewöhnliche Eingaben korrekt verarbeiten.

Indem Sie diese Praktiken befolgen, können Sie zuverlässigere, wartbarere und wiederverwendbare Bash-Funktionen erstellen.

Erstellen einer Funktionsbibliothek

Für die letzte Übung wollen wir eine wiederverwendbare Funktionsbibliothek erstellen:

touch math_functions.lib

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash
## math_functions.lib - A library of mathematical functions

## Add two numbers
add() {
  echo $(($1 + $2))
}

## Subtract second number from first
subtract() {
  echo $(($1 - $2))
}

## Multiply two numbers
multiply() {
  echo $(($1 * $2))
}

## Divide first number by second (with decimal precision)
divide() {
  if [ "$2" -eq 0 ]; then
    return 1
  fi
  echo "scale=2; $1 / $2" | bc
  return 0
}

## Calculate power: first number raised to second number
power() {
  echo $(($1 ** $2))
}

## Check if a number is even
is_even() {
  if (($1 % 2 == 0)); then
    return 0
  else
    return 1
  fi
}

## Check if a number is odd
is_odd() {
  if is_even "$1"; then
    return 1
  else
    return 0
  fi
}

Jetzt erstellen wir ein Skript, das diese Bibliothek verwendet:

touch use_library.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

## Source the math functions library
source math_functions.lib

## Display a header
echo "Math Functions Demo"
echo "------------------"

## Test the functions
echo "Addition: 5 + 3 = $(add 5 3)"
echo "Subtraction: 10 - 4 = $(subtract 10 4)"
echo "Multiplication: 6 * 7 = $(multiply 6 7)"

## Test division with error handling
div_result=$(divide 20 5)
if [ $? -eq 0 ]; then
  echo "Division: 20 / 5 = $div_result"
else
  echo "Division error: Cannot divide by zero"
fi

## Test division by zero
div_result=$(divide 20 0)
if [ $? -eq 0 ]; then
  echo "Division: 20 / 0 = $div_result"
else
  echo "Division error: Cannot divide by zero"
fi

echo "Power: 2 ^ 8 = $(power 2 8)"

## Test the even/odd functions
echo ""
echo "Number properties:"
for num in 1 2 3 4 5; do
  echo -n "Number $num is "

  if is_even $num; then
    echo "even"
  else
    echo "odd"
  fi
done

Speichern Sie das Skript, machen Sie es ausführbar und führen Sie es aus:

chmod +x use_library.sh
./use_library.sh

Sie sollten Folgendes sehen:

Math Functions Demo
------------------
Addition: 5 + 3 = 8
Subtraction: 10 - 4 = 6
Multiplication: 6 * 7 = 42
Division: 20 / 5 = 4.00
Division error: Cannot divide by zero
Power: 2 ^ 8 = 256

Number properties:
Number 1 is odd
Number 2 is even
Number 3 is odd
Number 4 is even
Number 5 is odd

Dieser Ansatz mit der Bibliothek zeigt, wie Sie wiederverwendbare Funktionssammlungen erstellen können, die in mehreren Skripten importiert werden können, was die Codewiederverwendung und Wartbarkeit fördert.

Zusammenfassung

In diesem Tutorial haben Sie die wesentlichen Konzepte der Rückgabewerte von Bash-Funktionen gelernt. Begonnen mit der grundlegenden Erstellung von Funktionen und der Verarbeitung von Argumenten, sind Sie dann zum Verständnis von Rückgabecodes und ihrer Bedeutung für den Erfolg oder Misserfolg eines Befehls vorgestoßen. Sie haben mehrere Methoden zur Rückgabe von tatsächlichen Daten aus Funktionen untersucht, darunter die Verwendung von echo, globalen Variablen und Trennzeichen für mehrere Werte.

Durch praktische Beispiele haben Sie ein Dateiverwaltungs-Utilitär implementiert, das die richtige Funktionszusammensetzung und Fehlerbehandlung zeigt. Abschließend haben Sie Best Practices für die Erstellung von robusten, wiederverwendbaren Funktionen gelernt und erfahren, wie Sie diese in Bibliotheken organisieren können.

Die in diesem Tutorial erworbenen Fähigkeiten bilden eine solide Grundlage für das Schreiben von anspruchsvolleren Bash-Skripten mit richtiger Fehlerbehandlung, Modularität und Wiederverwendbarkeit. Diese Techniken ermöglichen es Ihnen, wartbare Shell-Skripte für verschiedene Automatisierungsaufgaben zu erstellen, was Ihre Produktivität als Systemadministrator oder Entwickler insgesamt verbessert.