Sie kennen das Grundgerüst eines Skribts

#!/bin/bash

# Ein einfaches Bash-Skript
echo "Hallo, Welt!"

• #! nennt man Shebang.
• /bin/bash gibt an, dass das Skript mit der Bash-Shell ausgeführt werden soll.
• Der echo-Befehl gibt eine Nachricht auf der Konsole aus.

Sie können ein Skript ausführbar machen und starten

rechte setzen eins von beiden:

chmod +x script.sh

chmod 544 script.sh

ausführen:

./script.sh

In einem Skript Kommentare einfügen

#!/bin/bash

# Das ist ein Kommentar
echo "Hallo, Welt!"  # Dies gibt "Hallo, Welt!" auf der Konsole aus

# Mehrzeilige Kommentare:
# Jede Zeile muss mit einem # beginnen,
# da Bash keine Block-Kommentare wie /* */ in C hat.

Shellvariablen

$0 – Skriptname

#!/bin/bash
echo "Skriptname: $0"

Aufruf in der Konsole:

./skript.sh

Ausgabe:

Skriptname: ./skript.sh

$# – Anzahl der Argumente

Code (skript.sh):

#!/bin/bash
echo "Anzahl der Argumente: $#"

Aufruf mit Argumenten:

./skript.sh Hallo Welt 123

Ausgabe:

Anzahl der Argumente: 3

$1 - $n – Positionsparameter (Argumente)

Code(Skript.sh):

#!/bin/bash
echo "Erstes Argument: $1"
echo "Zweites Argument: $2"
echo "Drittes Argument: $3"

Aufruf mit Argumenten:

./skript.sh Apfel Banane Kirsche

Ausgabe:

Erstes Argument: Apfel
Zweites Argument: Banane
Drittes Argument: Kirsche

Mit Variablen rechnen in Bash

Variablen definieren und ausgeben:

#!/bin/bash

# Variable definieren
name="Alice"
alter=25

# Variable ausgeben
echo "Name: $name"
echo "Alter: $alter"

Ausgabe:

Name: Alice
Alter: 25

Mit Variablen rechnen:

Bash unterstützt arithmetische Berechnungen mit $(()):

#!/bin/bash

# Zahlen definieren
a=10
b=5

# Rechnen
summe=$((a + b))
differenz=$((a - b))
produkt=$((a * b))
quotient=$((a / b))
rest=$((a % b))

# Ausgabe
echo "Summe: $summe"
echo "Differenz: $differenz"
echo "Produkt: $produkt"
echo "Quotient: $quotient"
echo "Rest: $rest"

Ausgabe:

Summe: 15
Differenz: 5
Produkt: 50
Quotient: 2
Rest: 0

Mit Kommabeträgen rechnen (bc verwenden)

Bash kann nicht direkt mit Dezimalzahlen rechnen, aber mit bc geht es:

#!/bin/bash

# Zahlen mit Komma
x=5.5
y=2.2

# Berechnung mit bc
summe=$(echo "$x + $y" | bc)
echo "Summe: $summe"

Ausgabe:

Summe: 7.7

Sie können Benutzereingaben einlesen und den Wert von Variablen ausgeben

Einfache Benutzereingabe mit read

#!/bin/bash

# Eingabe einlesen
echo "Wie heißt du?"
read name

# Variable ausgeben
echo "Hallo, $name!"

Ausführung & Ausgabe:

$ ./skript.sh
Wie heißt du?
Alice
Hallo, Alice!

Mehrere Eingaben auf einmal

#!/bin/bash

echo "Gib deinen Vornamen und Nachnamen ein:"
read vorname nachname

echo "Hallo, $vorname $nachname!"

Ausgabe:

$ ./skript.sh
Gib deinen Vornamen und Nachnamen ein:
Max Mustermann
Hallo, Max Mustermann!

Eine Zahl einlesen und damit rechnen

#!/bin/bash

echo "Gib eine Zahl ein:"
read zahl

doppelt=$((zahl * 2))

echo "Das Doppelte von $zahl ist $doppelt."

Ausgabe:

$ ./skript.sh
Gib eine Zahl ein:
10
Das Doppelte von 10 ist 20.

Sie können in einem Skript auf die beim Aufruf übergebenen Parameter zugreifen

Alle Argumente auf einmal ausgeben ($@ & $*)

#!/bin/bash

echo "Alle Argumente mit \"\$@\": $@"
echo "Alle Argumente mit \"\$*\": $*"

Aufruf & Ausgabe:

$ ./skript.sh Eins Zwei Drei
Alle Argumente mit "$@": Eins Zwei Drei
Alle Argumente mit "$*": Eins Zwei Drei

Durch alle Argumente iterieren

#!/bin/bash

echo "Alle Argumente einzeln:"
for arg in "$@"; do
    echo "$arg"
done

Aufruf & Ausgabe:

$ ./skript.sh A B C
Alle Argumente einzeln:
A
B
C

Erklärung:

1. "$@" enthält alle übergebenen Argumente, wobei jedes Argument als eigener Wert behandelt wird.
2. for arg in "$@" bedeutet:
3. Die for-Schleife geht jedes Argument aus "$@" einzeln durch.
4. Jedes Argument wird der Variablen arg zugewiesen.
5. Der Code innerhalb der Schleife (echo "$arg") wird für jedes Argument ausgeführt.

Sie kennen die Syntax von if [ ] .. then .. else .. fi und können Operatoren für Zahlen, Text, Dateien, Rechte und logische Operatoren korrekt anwenden

Syntax einer if-Anweisung in Bash:

if [ BEDINGUNG ]; then
    # Codeblock falls BEDINGUNG wahr ist
else
    # Codeblock falls BEDINGUNG falsch ist
fi

Operatoren in Bash:

Numerische Vergleiche:

Operator	Bedeutung
-eq	Gleich (equal)
-ne	Ungleich (not equal)
-lt	Kleiner als (less than)
-le	Kleiner oder gleich (less than or equal)
-gt	Größer als (greater than)
-ge	Größer oder gleich (greater than or equal)

Beispiel:

a=10
b=20

if [ "$a" -lt "$b" ]; then
    echo "a ist kleiner als b"
fi

String-Vergleiche:

Operator	Bedeutung
=	Gleich (equal)
!=	Ungleich (not equal)
-z	String ist leer (zero-length)
-n	String ist nicht leer (non-zero-length)

Beispiel:

name="Alice"

if [ "$name" = "Alice" ]; then
    echo "Hallo Alice!"
else
    echo "Wer bist du?"
fi

Dateiprüfungen:

Operator	Bedeutung
-e DATEI	Datei existiert
-f DATEI	Datei ist eine reguläre Datei
-d VERZEICHNIS	Ist ein Verzeichnis
-s DATEI	Datei ist nicht leer
-r DATEI	Datei ist lesbar
-w DATEI	Datei ist schreibbar
-x DATEI	Datei ist ausführbar

Beispiel:

if [ -f "/etc/passwd" ]; then
    echo "Die Datei /etc/passwd existiert"
fi

Logische Operatoren

Operator	Bedeutung
-a	Logisches UND (deprecated, besser && verwenden)
-o	Logisches ODER (deprecated, besser `
!	Negation

Alternative mit [[ ... ]] (empfohlen für komplexe Bedingungen):

if [[ "$a" -gt 5 && "$b" -lt 100 ]]; then
    echo "a ist größer als 5 UND b kleiner als 100"
fi

Sie kennen die Syntax der Mehrfachverzweigung mit case und können diese korrekt anwenden

Syntax von case

case VARIABLE in
    Muster1)
        # Codeblock für Muster1
        ;;
    Muster2)
        # Codeblock für Muster2
        ;;
    *)
        # Standardfall (optional)
        ;;
esac

🔹 ;; beendet jeden Fall (alternativ ;& oder ;;& für spezielle Fälle).
🔹 * ist der Default-Fall (wird ausgeführt, wenn kein anderes Muster passt).

Beispiele für case

1. Einfache Menüauswahl:

echo "Wähle eine Option: (start, stop, restart)"
read eingabe

case "$eingabe" in
    start)
        echo "Dienst wird gestartet..."
        ;;
    stop)
        echo "Dienst wird gestoppt..."
        ;;
    restart)
        echo "Dienst wird neu gestartet..."
        ;;
    *)
        echo "Ungültige Eingabe!"
        ;;
esac

1. Mehrere Muster pro Fall:

read -p "Gib eine Datei-Endung ein: " endung

case "$endung" in
    jpg|png|gif)
        echo "Das ist ein Bildformat."
        ;;
    mp3|wav)
        echo "Das ist ein Audioformat."
        ;;
    txt|md)
        echo "Das ist eine Textdatei."
        ;;
    *)
        echo "Unbekanntes Dateiformat."
        ;;
esac

Mehrere Muster werden mit | (Pipe) getrennt.

1. case mit regulären Ausdrücken (Erweiterte Muster)

read -p "Gib eine Zahl ein: " zahl

case "$zahl" in
    [0-9])
        echo "Das ist eine einstellige Zahl."
        ;;
    [1-9][0-9])
        echo "Das ist eine zweistellige Zahl."
        ;;
    *)
        echo "Das ist eine große Zahl oder keine Zahl."
        ;;
esac

[0-9] und [1-9][0-9] sind Muster, ähnlich wie reguläre Ausdrücke.

Spezialfälle: ;& und ;;&

;& (Weiter zur nächsten Bedingung, ohne Bedingung zu prüfen)

read -p "Gib eine Farbe ein: " farbe

case "$farbe" in
    rot)
        echo "Primärfarbe"
        ;&
    blau|gelb)
        echo "Diese Farbe ist wichtig!"
        ;;
    *)
        echo "Andere Farbe."
        ;;
esac

Hier wird für "rot" zwei Codeblöcke ausgeführt (rot + blau|gelb).

;;& (Springt zur nächsten Prüfung weiter)

read -p "Gib eine Nummer ein: " nummer

case "$nummer" in
    1)
        echo "Das ist Eins."
        ;;&
    [0-9])
        echo "Einstellige Zahl erkannt."
        ;;
    *)
        echo "Andere Zahl."
        ;;
esac

Wenn der Nutzer "1" eingibt, wird zuerst "Das ist Eins." ausgegeben und dann die nächste Bedingung geprüft ([0-9]).

Syntax	Verhalten
;;	Beendet den aktuellen Fall (Standardverhalten).
;&	Führt den nächsten Fall ohne Bedingungsprüfung aus.
;;&	Prüft die nächste Bedingung und führt sie aus, falls sie passt.

Das -p-Flag bei read in Bash steht für Prompt und ermöglicht es, eine Eingabeaufforderung direkt anzuzeigen, ohne echo zu verwenden.

Sie kennen die Syntax der while-Schleife und können diese korrekt anwenden

Syntax einer while-Schleife:

while [ BEDINGUNG ]; do
    # Befehle innerhalb der Schleife
done

🔹 Die Bedingung wird vor jeder Iteration geprüft.
🔹 Die Schleife läuft so lange, wie die Bedingung wahr ist.

1. Beispiel: Einfacher Zähler

#!/bin/bash

zahl=1

while [ "$zahl" -le 5 ]; do
    echo "Durchlauf $zahl"
    ((zahl++))  # Erhöht die Zahl um 1
done

Gibt Durchlauf 1 bis Durchlauf 5 aus.

1. Unendliche Schleife (while true)

while true; do
    echo "Diese Schleife läuft unendlich!"
    sleep 1  # Wartet 1 Sekunde
done

🔹 true ist immer wahr → Endlosschleife.
🔹 Beenden mit Strg + C.

1. while mit Benutzereingabe

read -p "Gib 'exit' ein, um zu stoppen: " input

while [ "$input" != "exit" ]; do
    echo "Du hast '$input' eingegeben. Versuche es erneut."
    read -p "Gib 'exit' ein, um zu stoppen: " input
done

echo "Programm beendet!"

💡 Die Schleife fragt immer wieder nach einer Eingabe, bis der Nutzer "exit" eingibt.

1. while mit until (Gegenteil)

Schleife	Läuft solange...
while	die Bedingung wahr ist
until	die Bedingung falsch ist

Beispiel mit until:

zahl=1

until [ "$zahl" -gt 5 ]; do
    echo "Durchlauf $zahl"
    ((zahl++))
done