--- id: 2024-10-24-bash-grundkurs-kontrollstrukturen-in-bash slug: bash-grundkurs-kontrollstrukturen-in-bash title: "Bash Grundkurs #3: Kontrollstrukturen In Bash" excerpt: "Entdecke die Macht der Bash-Kontrollstrukturen! Lerne if-else, case, for und while Schleifen kennen und meistere die Kunst des Skriptings in unserem umfassenden Grundkurs." date: 2024-10-24 updated: 2024-11-10 author: name: "Sebastian Palencsár" handle: "spalencsar" category: ["bash-grundlagen"] tags: ["bash", "linux", "shell"] reading_time: 7 toc: true --- **Willkommen zum dritten Artikel unserer technischen Wiki-Serie über Linux und Bash-Programmierung!** Nachdem wir in den vorherigen Beiträgen die Grundlagen des [Erstellens und Ausführens von Bash-Skripten](/de/bash-grundlagen/bash-grundkurs-erstelle-dein-erstes-bash-shell-skript){.badge-link-text} sowie die [Verwendung von Variablen kennengelernt](/de/bash-grundlagen/bash-grundkurs-verwendung-von-variablen-in-bash){.badge-link-text} haben, widmen wir uns heute den Kontrollstrukturen in Bash. Kontrollstrukturen sind wesentliche Bausteine der Programmierung, die es dir ermöglichen, den Ablauf deines Skripts zu steuern und auf verschiedene Bedingungen zu reagieren. **Was sind Kontrollstrukturen?** Kontrollstrukturen in Bash ermöglichen es dir, Entscheidungen zu treffen, Code basierend auf Bedingungen auszuführen und Aktionen zu wiederholen. Die wichtigsten Kontrollstrukturen, die wir in diesem Artikel behandeln werden, sind: 1. if-else Anweisungen 2. case Anweisungen 3. for Schleifen 4. while und until Schleifen Jede dieser Strukturen hat ihre eigenen Anwendungsfälle und Besonderheiten, die wir im Detail erkunden werden. Lass uns ohne weitere Umschweife in die Welt der Bash-Kontrollstrukturen eintauchen! ## Bedingte Anweisungen ##### if-else Anweisungen Die if-else Anweisung ist eine der grundlegendsten Kontrollstrukturen in Bash. Sie ermöglicht es dir, Code basierend auf einer oder mehreren Bedingungen auszuführen. **Syntax:** Die einfachste Form der if-Anweisung sieht so aus: ```bash if [ Bedingung ]; then # Code, der ausgeführt wird, wenn die Bedingung wahr ist fi ``` Beachte die eckigen Klammern um die Bedingung und das Semikolon vor then. Das `fi` am Ende schließt die if-Anweisung ab. **Hier ein einfaches Beispiel:** ```bash #!/bin/bash alter=18 if [ $alter -ge 18 ]; then echo "Du bist volljährig." fi ``` In diesem Beispiel wird die Nachricht nur ausgegeben, wenn die Variable `alter` größer oder gleich `18` ist. ##### if-else Oft möchtest du auch Code ausführen, wenn die Bedingung nicht erfüllt ist. Dafür verwendest du die if-else Struktur: ```bash if [ Bedingung ]; then # Code, der ausgeführt wird, wenn die Bedingung wahr ist else # Code, der ausgeführt wird, wenn die Bedingung falsch ist fi ``` **Beispiel:** ```bash #!/bin/bash alter=16 if [ $alter -ge 18 ]; then echo "Du bist volljährig." else echo "Du bist minderjährig." fi ``` ##### if-elif-else Für mehrere Bedingungen kannst du `elif` (else if) verwenden: ```bash if [ Bedingung1 ]; then # Code für Bedingung1 elif [ Bedingung2 ]; then # Code für Bedingung2 else # Code, wenn keine Bedingung zutrifft fi ``` **Beispiel:** ```bash #!/bin/bash note=85 if [ $note -ge 90 ]; then echo "Sehr gut!" elif [ $note -ge 80 ]; then echo "Gut!" elif [ $note -ge 70 ]; then echo "Befriedigend." else echo "Verbesserungswürdig." fi ``` ## Vergleichsoperatoren In Bash gibt es verschiedene Vergleichsoperatoren für Zahlen und Zeichenketten: - **Für Zahlen:** - `-eq`: gleich - `-ne`: ungleich - `-gt`: größer als - `-ge`: größer oder gleich - `-lt`: kleiner als - `-le`: kleiner oder gleich - **Für Zeichenketten:** - `=`: gleich - `!=`: ungleich - `-z`: Zeichenkette ist leer - `-n`: Zeichenkette ist nicht leer **Beispiel für Zeichenkettenvergleich:** ```bash #!/bin/bash name="Max" if [ "$name" = "Max" ]; then echo "Hallo Max!" elif [ -z "$name" ]; then echo "Der Name ist leer." else echo "Hallo, wie heißt du?" fi ``` ##### case Anweisungen Die `case` Anweisung ist nützlich, wenn du viele mögliche Bedingungen für eine Variable hast. Sie ist oft übersichtlicher als verschachtelte if-elif-else Strukturen. **Syntax:** ```bash case $variable in muster1) # Code für muster1 ;; muster2) # Code für muster2 ;; *) # Standard-Code, wenn kein Muster passt ;; esac ``` **Beispiel:** ```bash #!/bin/bash fruit="Apfel" case $fruit in "Apfel") echo "Äpfel sind rot oder grün." ;; "Banane") echo "Bananen sind gelb." ;; "Orange") echo "Orangen sind orange." ;; *) echo "Unbekannte Frucht." ;; esac ``` ##### for Schleifen For-Schleifen in Bash werden verwendet, um eine Aktion für eine bestimmte Anzahl von Iterationen oder für jedes Element in einer Liste auszuführen. **Syntax** ```bash for variable in liste do # Code, der für jedes Element ausgeführt wird done ``` **Beispiel mit einer Liste von Zahlen:** ```bash #!/bin/bash for i in 1 2 3 4 5 do echo "Nummer $i" done ``` ##### Sequenzen generieren Du kannst auch Sequenzen mit dem Befehl `seq` generieren: ```bash #!/bin/bash for i in $(seq 1 5) do echo "Nummer $i" done ``` ##### Über Dateien iterieren For-Schleifen sind besonders nützlich, um über Dateien in einem Verzeichnis zu iterieren: ```bash #!/bin/bash for file in *.txt do echo "Verarbeite Datei: $file" # Hier könntest du weitere Aktionen mit der Datei durchführen done ``` ## while und until Schleifen While-Schleifen führen einen Codeblock aus, solange eine Bedingung wahr ist. Until-Schleifen führen einen Codeblock aus, bis eine Bedingung wahr wird. ##### while Schleife **Syntax:** ```bash while [ Bedingung ] do # Code, der ausgeführt wird, solange die Bedingung wahr ist done ``` **Beispiel:** ```bash #!/bin/bash count=1 while [ $count -le 5 ] do echo "Durchlauf $count" count=$((count + 1)) done ``` ## until Schleife **Syntax:** ```bash until [ Bedingung ] do # Code, der ausgeführt wird, bis die Bedingung wahr wird done ``` **Beispiel:** ```bash #!/bin/bash count=1 until [ $count -gt 5 ] do echo "Durchlauf $count" count=$((count + 1)) done ``` ## Übung Um dein Verständnis der Kontrollstrukturen zu festigen, hier eine Übungsaufgabe. Schreibe ein Bash-Skript, das: 1. Den Benutzer nach einer Zahl zwischen 1 und 10 fragt. 2. Eine Schleife verwendet, um von 1 bis zu dieser Zahl zu zählen. 3. Für jede Zahl prüft, ob sie gerade oder ungerade ist. 4. Das Ergebnis ausgibt und am Ende eine Zusammenfassung anzeigt, wie viele gerade und ungerade Zahlen gefunden wurden. **Hier ist eine mögliche Lösung:** ```bash #!/bin/bash echo "Gib eine Zahl zwischen 1 und 10 ein:" read number if [ $number -lt 1 ] || [ $number -gt 10 ]; then echo "Die Zahl muss zwischen 1 und 10 liegen." exit 1 fi even_count=0 odd_count=0 for i in $(seq 1 $number) do if [ $((i % 2)) -eq 0 ]; then echo "$i ist gerade" even_count=$((even_count + 1)) else echo "$i ist ungerade" odd_count=$((odd_count + 1)) fi done echo "Zusammenfassung:" echo "Gerade Zahlen: $even_count" echo "Ungerade Zahlen: $odd_count" ``` ## Fazit Kontrollstrukturen sind das Rückgrat jedes Bash-Skripts. Sie ermöglichen es dir, komplexe Logik zu implementieren und deine Skripte dynamisch und anpassungsfähig zu gestalten. Mit if-else Anweisungen kannst du Entscheidungen treffen, case Anweisungen helfen dir, übersichtlich zwischen verschiedenen Optionen zu wählen, und Schleifen ermöglichen es dir, Aktionen zu wiederholen und über Daten zu iterieren. In diesem Artikel haben wir die grundlegenden Kontrollstrukturen in Bash behandelt: if-else Anweisungen, case Anweisungen, for Schleifen sowie while und until Schleifen. Jede dieser Strukturen hat ihre eigenen Stärken und Anwendungsfälle. Mit der Zeit und durch Übung wirst du ein Gefühl dafür entwickeln, wann du welche Struktur am besten einsetzt. Denk daran, dass gute Bash-Skripte nicht nur funktionieren, sondern auch lesbar und wartbar sein sollten. Verwende aussagekräftige Variablennamen, kommentiere deinen Code und strukturiere ihn sauber. Je komplexer deine Skripte werden, desto wichtiger wird es, diese Prinzipien zu beachten. In unserem nächsten Artikel werden wir uns mit Funktionen in Bash beschäftigen – einem mächtigen Werkzeug, um deinen Code zu organisieren und wiederzuverwenden. **Bis dahin, happy scripting!**