Bash-Crashkurs: Skripting-Grundlagen - Versionsgeschichte

Thomas.will am 14. Juli 2026 um 10:17 Uhr

2026-07-14T10:17:36Z

Thomas.will am 14. Juli 2026 um 10:17 Uhr

2026-07-14T10:17:23Z

Thomas.will am 11. Juli 2026 um 13:49 Uhr

2026-07-11T13:49:22Z

Thomas.will: /* if */

2026-07-11T12:57:25Z

Thomas.will: /* Testausdrücke: */

2026-07-11T12:53:41Z

Testausdrücke:

Thomas.will: /* Testausdrücke: */

2026-07-11T12:52:22Z

Testausdrücke:

Thomas.will: /* Testausdrücke: */

2026-07-11T12:48:53Z

Testausdrücke:

Änderungen zeigen

Thomas.will am 11. Juli 2026 um 12:46 Uhr

2026-07-11T12:46:24Z

Thomas.will: /* cut (Wiederholung aus 5101) */

2026-07-11T12:44:13Z

cut (Wiederholung aus 5101)

Thomas.will: Die Seite wurde neu angelegt: „= Bash-Crashkurs: Skripting-Grundlagen = Dieser Kurs vermittelt die Bash-Mechanismen, die für ein eigenes Skript zur Netzwerkkonfiguration gebraucht werden.…“

2026-07-11T12:43:23Z

Die Seite wurde neu angelegt: „= Bash-Crashkurs: Skripting-Grundlagen = Dieser Kurs vermittelt die Bash-Mechanismen, die für ein eigenes Skript zur Netzwerkkonfiguration gebraucht werden.…“

Neue Seite

= Bash-Crashkurs: Skripting-Grundlagen =

Dieser Kurs vermittelt die Bash-Mechanismen, die für ein eigenes Skript zur Netzwerkkonfiguration gebraucht werden. Jeder Abschnitt führt einen Baustein ein. Am Ende schreibt ihr daraus selbst ein vollständiges Skript.

== Variablensubstitution ==

Eine Variable wird ohne Leerzeichen um das <code>=</code> gesetzt:

<syntaxhighlight lang="bash">
NAME="server01"
</syntaxhighlight>

Der Wert wird ausgelesen, indem man ein <code>$</code> vor den Namen setzt – dieser Vorgang heißt Variablensubstitution: Bash ersetzt <code>$NAME</code> durch den gespeicherten Wert, bevor der Befehl ausgeführt wird.

<syntaxhighlight lang="bash">
echo $NAME
echo "$NAME"
</syntaxhighlight>

In Anführungszeichen referenzieren, sonst gibt's bei Leerzeichen oder Sonderzeichen im Wert Probleme (Bash zerlegt den Wert sonst an Leerzeichen in mehrere Wörter).

;Übung
<pre>
Setzt eine Variable ADDR mit dem Wert 10.2XX.0.10/24 und gebt sie einmal ohne und einmal mit Anführungszeichen aus.
</pre>

== Kommandosubstitution ==

Mit <code>$(...)</code> wird nicht der Text eines Befehls ausgeführt, sondern seine Ausgabe als Wert eingesetzt – das nennt man Kommandosubstitution:

<syntaxhighlight lang="bash">
DATUM=$(date +%Y-%m-%d)
echo "$DATUM"
</syntaxhighlight>

<code>$(date +%Y-%m-%d)</code> wird zuerst ausgeführt, die Ausgabe des Befehls landet dann in <code>DATUM</code>.

;Übung
<pre>
Speichert die Ausgabe von "hostname" in einer Variable HOST und gebt sie aus.
</pre>

== cut (Wiederholung aus 5101) ==

<code>cut</code> zerschneidet Text an einem Trennzeichen:

<syntaxhighlight lang="bash">
echo "server01.it2XX.int" | cut -d'.' -f1
# server01
echo "server01.it2XX.int" | cut -d'.' -f2-
# it2XX.int
</syntaxhighlight>

<code>-d'.'</code> setzt den Punkt als Trennzeichen, <code>-f1</code> nimmt das erste Feld, <code>-f2-</code> alles ab dem zweiten Feld bis zum Ende.

Kombiniert mit Kommandosubstitution lässt sich das Ergebnis direkt in eine Variable schreiben:

<syntaxhighlight lang="bash">
SHORT=$(echo "server01.it2XX.int" | cut -d'.' -f1)
</syntaxhighlight>

;Übung
<pre>
Zerlegt "server01.it2XX.int" mit cut und Kommandosubstitution in SHORT (server01) und DOM (it2XX.int).
</pre>

== Testausdrücke: [[ ]] ==

<code>[[ ]]</code> prüft eine Bedingung und liefert wahr oder unwahr (als Exit-Code, 0 = wahr, ungleich 0 = unwahr):

<syntaxhighlight lang="bash">
[[ "$X" == 1 ]] # wahr, wenn X gleich 1 ist
[[ -z "$VAR" ]] # wahr, wenn VAR leer ist
[[ -n "$VAR" ]] # wahr, wenn VAR NICHT leer ist
</syntaxhighlight>

Mehrere Bedingungen lassen sich mit <code>||</code> (ODER) oder <code>&&</code> (UND) verknüpfen:

<syntaxhighlight lang="bash">
[[ -z "$FQDN" || -z "$ADDR" ]]
</syntaxhighlight>

;Übung
<pre>
Testet direkt auf der Kommandozeile:
X=1
[[ "$X" == 1 ]] && echo "wahr" || echo "unwahr"
X=""
[[ -z "$X" ]] && echo "leer" || echo "nicht leer"
</pre>

== if ==

<code>[[ ]]</code> allein tut noch nichts außer prüfen – erst <code>if</code> reagiert auf das Ergebnis:

<syntaxhighlight lang="bash">
if [[ -z "$FQDN" ]]; then
echo "FQDN fehlt!"
exit 1
fi
</syntaxhighlight>

Aufbau: <code>if BEDINGUNG; then</code> ... <code>fi</code> (schließt den Block, "if" rückwärts geschrieben). Optional gibt es <code>else</code> für den Alternativfall und <code>elif</code> für eine weitere Bedingung.

<syntaxhighlight lang="bash">
if [[ -z "$FQDN" ]]; then
echo "FQDN fehlt!"
else
echo "FQDN ist $FQDN"
fi
</syntaxhighlight>

;Übung
<pre>
Schreibt ein if, das prüft, ob die Variable ADDR leer ist. Falls ja: Fehlermeldung ausgeben und mit exit 1 abbrechen.
</pre>

== while ==

<code>while</code> wiederholt einen Block, solange eine Bedingung wahr ist:

<syntaxhighlight lang="bash">
i=1
while [[ $i -le 3 ]]; do
echo "Durchlauf $i"
i=$((i+1))
done
</syntaxhighlight>

<code>while BEDINGUNG; do</code> ... <code>done</code>. Wichtig: die Bedingung muss sich im Schleifenkörper irgendwann ändern, sonst läuft die Schleife endlos.

;Übung
<pre>
Schreibt eine while-Schleife, die von 1 bis 5 zählt und jede Zahl ausgibt.
</pre>

== Heredoc ==

Ein Heredoc schreibt mehrzeiligen Text in eine Datei, ohne für jede Zeile ein eigenes echo zu brauchen:

<syntaxhighlight lang="bash">
cat <<HERE > /tmp/test.txt
Zeile 1
Zeile 2
HERE
</syntaxhighlight>

Alles zwischen <code><<HERE</code> und der abschließenden Zeile <code>HERE</code> wird an <code>cat</code> übergeben. <code>></code> schreibt (überschreibt) die Datei, <code>>></code> hängt an. Variablen werden innerhalb des Heredocs per Variablensubstitution ganz normal ersetzt:

<syntaxhighlight lang="bash">
cat <<HERE > /tmp/test.txt
Adresse: $ADDR
HERE
</syntaxhighlight>

;Übung
<pre>
Schreibt mit einem Heredoc eine Datei /tmp/netztest.txt, die die Werte von ADDR und DOM enthält.
</pre>

== Variablen übergeben über $1, $2, ... ==

Beim Aufruf eines Skripts landen die übergebenen Werte automatisch in nummerierten Variablen:

<syntaxhighlight lang="bash">
./skript.sh server01 10.2XX.0.10

echo "$1" # server01
echo "$2" # 10.2XX.0.10
</syntaxhighlight>

<code>$0</code> ist der Skriptname selbst, <code>$1</code> das erste Argument, <code>$2</code> das zweite, usw. <code>$#</code> gibt die Anzahl der übergebenen Argumente aus.

{{Hinweis|Diese Positionsparameter merken sich nur die Reihenfolge, nicht was gemeint ist. Der Aufrufer muss genau wissen, dass Argument 1 der FQDN ist und Argument 2 die Adresse. Vertauscht man die Reihenfolge, gibt es keine Fehlermeldung, nur falsche Werte.}}

;Übung
<pre>
Schreibt ein Skript args.sh, das $1 und $2 ausgibt. Ruft es mit zwei, dann mit nur einem Argument auf. Was steht dann in $2?
</pre>

== Robuster mit getopts ==

Das Problem von <code>$1</code>/<code>$2</code>: feste Reihenfolge, keine Namen, kein "diese Option ist optional". <code>getopts</code> löst das, indem Optionen mit Buchstaben und in beliebiger Reihenfolge übergeben werden:

<syntaxhighlight lang="bash">
./skript.sh -f server01.it2XX.int -a 10.2XX.0.10/24
</syntaxhighlight>

statt

<syntaxhighlight lang="bash">
./skript.sh server01.it2XX.int 10.2XX.0.10/24
</syntaxhighlight>

Ein Options-String wie <code>"f:a:"</code> legt fest, welche Buchstaben erlaubt sind. Ein Doppelpunkt hinter einem Buchstaben bedeutet: diese Option erwartet einen Wert.

<syntaxhighlight lang="bash">
while getopts "f:a:" opt; do
case $opt in
f) FQDN="$OPTARG" ;;
a) ADDR="$OPTARG" ;;
*) echo "Ungültige Option" >&2; exit 1 ;;
esac
done
</syntaxhighlight>

<code>getopts</code> liest bei jedem Schleifendurchlauf die nächste Option. Der Buchstabe landet in <code>$opt</code>, ein eventueller Wert automatisch in <code>$OPTARG</code>. Im <code>case</code> wird pro Buchstabe die passende Variable befüllt. Der Zweig <code>*)</code> fängt unbekannte Optionen ab; <code>>&2</code> schickt die Fehlermeldung nach stderr, <code>exit 1</code> beendet das Skript mit Fehlercode.

;Übung
<pre>
Schreibt ein Skript foo.sh, das die Optionen -f und -a mit getopts einliest und beide Werte ausgibt.
Testet danach:
./foo.sh -f
./foo.sh -z
Was landet in $opt in beiden Fällen?
</pre>

== Abschlussaufgabe: Das vollständige Skript ==

Baut jetzt aus den Bausteinen oben ein Skript, das per Kommandozeile FQDN, IP-Adresse, Gateway und Nameserver entgegennimmt und daraus eine statische Netzwerkkonfiguration schreibt.

;Anforderungen
* Optionen <code>-f</code> (FQDN), <code>-a</code> (Adresse/CIDR), <code>-g</code> (Gateway), <code>-n</code> (Nameserver), alle mit Wert, über getopts eingelesen
* Fehlt eine der vier Angaben, Fehlermeldung mit Nutzungshinweis und <code>exit 1</code>
* FQDN mit cut und Kommandosubstitution in <code>SHORT</code> und <code>DOM</code> zerlegen
* <code>/etc/network/interfaces</code> per Heredoc schreiben (Loopback + statisches Interface <code>enp0s3</code>)
* Hostname mit <code>hostnamectl set-hostname</code> setzen

{{Hinweis|Testet euer Skript zuerst mit fehlenden Optionen und mit einer unbekannten Option, bevor ihr den vollständigen Aufruf prüft.}}

[[Kategorie:Shellscripting]]
[[Kategorie:Linux Grundlagen]]

← Nächstältere Version		Version vom 14. Juli 2026, 10:17 Uhr
Zeile 1:		Zeile 1:
−	= Bash-Crashkurs: Skripting-Grundlagen =	+	== Bash-Crashkurs: Skripting-Grundlagen ==

	Dieser Kurs vermittelt die Bash-Mechanismen, die für ein eigenes Skript zur Netzwerkkonfiguration gebraucht werden. Jeder Abschnitt führt einen Baustein ein. Am Ende schreibt ihr daraus selbst ein vollständiges Skript.		Dieser Kurs vermittelt die Bash-Mechanismen, die für ein eigenes Skript zur Netzwerkkonfiguration gebraucht werden. Jeder Abschnitt führt einen Baustein ein. Am Ende schreibt ihr daraus selbst ein vollständiges Skript.

← Nächstältere Version		Version vom 14. Juli 2026, 10:17 Uhr
Zeile 1:		Zeile 1:
−	~~= Bash-Crashkurs: Skripting-Grundlagen =~~
−
−	Dieser Kurs vermittelt die Bash-Mechanismen, die für ein eigenes Skript zur Netzwerkkonfiguration gebraucht werden. Jeder Abschnitt führt einen Baustein ein. Am Ende schreibt ihr daraus selbst ein vollständiges Skript.
−
−	~~== Variablensubstitution ==~~
−
−	~~Eine Variable wird ohne Leerzeichen um das <code>=</code> gesetzt:~~
−
−	~~<syntaxhighlight lang="bash">~~
−	~~NAME="server01"~~
−	~~</syntaxhighlight>~~
−
−	Der Wert wird ausgelesen, indem man ein <code>$</code> vor den Namen setzt – dieser Vorgang heißt Variablensubstitution: Bash ersetzt <code>$NAME</code> durch den gespeicherten Wert, bevor der Befehl ausgeführt wird.
−
−	~~<syntaxhighlight lang="bash">~~
−	~~echo $NAME~~
−	~~echo "$NAME"~~
−	~~</syntaxhighlight>~~
−
−	~~In Anführungszeichen referenzieren, sonst gibt's bei Leerzeichen oder Sonderzeichen im Wert Probleme (Bash zerlegt den Wert sonst an Leerzeichen in mehrere Wörter).~~
−
−	~~;Übung~~
−	~~<pre>~~
−	~~Setzt eine Variable ADDR mit dem Wert 10.2XX.0.10/24 und gebt sie einmal ohne und einmal mit Anführungszeichen aus.~~
−	~~</pre>~~
−
−	~~== Kommandosubstitution ==~~
−
−	~~Mit <code>$(...)</code> wird nicht der Text eines Befehls ausgeführt, sondern seine Ausgabe als Wert eingesetzt – das nennt man Kommandosubstitution:~~
−
−	~~<syntaxhighlight lang="bash">~~
−	~~DATUM=$(date +%Y-%m-%d)~~
−	~~echo "$DATUM"~~
−	~~</syntaxhighlight>~~
−
−	~~<code>$(date +%Y-%m-%d)</code> wird zuerst ausgeführt, die Ausgabe des Befehls landet dann in <code>DATUM</code>.~~
−
−	~~;Übung~~
−	~~<pre>~~
−	~~Speichert die Ausgabe von "hostname" in einer Variable HOST und gebt sie aus.~~
−	~~</pre>~~
−
−	~~== cut (Wiederholung aus 5101) ==~~
−
−	~~<code>cut</code> zerschneidet Text an einem Trennzeichen:~~
−
−	~~<syntaxhighlight lang="bash">~~
−	~~echo "server01.it2XX.int" \| cut -d'.' -f1~~
−	~~# server01~~
−	~~echo "server01.it2XX.int" \| cut -d'.' -f2-~~
−	~~# it2XX.int~~
−	~~</syntaxhighlight>~~
−
−	~~<code>-d'.'</code> setzt den Punkt als Trennzeichen, <code>-f1</code> nimmt das erste Feld, <code>-f2-</code> alles ab dem zweiten Feld bis zum Ende.~~
−
−	~~Kombiniert mit Kommandosubstitution lässt sich das Ergebnis direkt in eine Variable schreiben:~~
−
−	~~<syntaxhighlight lang="bash">~~
−	~~SHORT=$(echo "server01.it2XX.int" \| cut -d'.' -f1)~~
−	~~</syntaxhighlight>~~
−
−	~~;Übung~~
−	~~<pre>~~
−	~~Zerlegt "server01.it2XX.int" mit cut und Kommandosubstitution in SHORT (server01) und DOM (it2XX.int).~~
−	~~</pre>~~
−
	= Bash-Crashkurs: Skripting-Grundlagen =		= Bash-Crashkurs: Skripting-Grundlagen =

@@ Zeile 217: / Zeile 217: @@
 <pre>
 Schreibt ein case, das eine Variable FARBE gegen "rot", "gruen" und "blau" prüft und jeweils eine passende Meldung ausgibt. Für alles andere: "unbekannte Farbe".
 </pre>

@@ Zeile 162: / Zeile 162: @@
 </syntaxhighlight>
-{{Hinweis|<code>&&</code> und <code>||</code> werten nur so weit aus, wie nötig (Kurzschlussauswertung): Bei <code>A && B</code> wird <code>B</code> nur ausgeführt, wenn <code>A</code> wahr war; bei <code>A || B</code> wird <code>B</code> nur ausgeführt, wenn <code>A</code> unwahr war. Deshalb steht in <code>$?</code> nach <code>[[ ... ]] && echo "wahr" || echo "unwahr"</code> am Ende der Exit-Code des ausgeführten <code>echo</code>, nicht mehr der von <code>[[ ]]</code>.}}
+{{Hinweis|<code>&&</code> und <code>&#124;&#124;</code> werten nur so weit aus, wie nötig (Kurzschlussauswertung): Bei <code>A && B</code> wird <code>B</code> nur ausgeführt, wenn <code>A</code> wahr war; bei <code>A &#124;&#124; B</code> wird <code>B</code> nur ausgeführt, wenn <code>A</code> unwahr war. Deshalb steht in <code>$?</code> nach <code>[[ ... ]] && echo "wahr" &#124;&#124; echo "unwahr"</code> am Ende der Exit-Code des ausgeführten <code>echo</code>, nicht mehr der von <code>[[ ]]</code>.}}
 ;Übung

@@ Zeile 156: / Zeile 156: @@
 Das ist auch genau das, was <code>if</code> später intern auswertet: <code>if</code> prüft nichts anderes als <code>$?</code> des Befehls direkt danach.
-Mehrere Bedingungen lassen sich mit <code>||</code> (ODER) oder <code>&amp;&amp;</code> (UND) verknüpfen:
+Mehrere Bedingungen lassen sich mit <code>||</code> (ODER) oder <code>&&</code> (UND) verknüpfen:
 <syntaxhighlight lang="bash">
@@ Zeile 162: / Zeile 162: @@
 </syntaxhighlight>
-{{Hinweis|<code>&amp;&amp;</code> und <code>||</code> werten nur so weit aus, wie nötig (Kurzschlussauswertung): Bei <code>A &amp;&amp; B</code> wird <code>B</code> nur ausgeführt, wenn <code>A</code> wahr war; bei <code>A || B</code> wird <code>B</code> nur ausgeführt, wenn <code>A</code> unwahr war. Deshalb steht in <code>$?</code> nach <code>[[ ... ]] &amp;&amp; echo "wahr" || echo "unwahr"</code> am Ende der Exit-Code des ausgeführten <code>echo</code>, nicht mehr der von <code>[[ ]]</code>.}}
+{{Hinweis|<code>&&</code> und <code>||</code> werten nur so weit aus, wie nötig (Kurzschlussauswertung): Bei <code>A && B</code> wird <code>B</code> nur ausgeführt, wenn <code>A</code> wahr war; bei <code>A || B</code> wird <code>B</code> nur ausgeführt, wenn <code>A</code> unwahr war. Deshalb steht in <code>$?</code> nach <code>[[ ... ]] && echo "wahr" || echo "unwahr"</code> am Ende der Exit-Code des ausgeführten <code>echo</code>, nicht mehr der von <code>[[ ]]</code>.}}
 ;Übung

@@ Zeile 199: / Zeile 199: @@
 <pre>
 Schreibt ein if, das prüft, ob die Variable ADDR leer ist. Falls ja: Fehlermeldung ausgeben und mit exit 1 abbrechen.
 </pre>

@@ Zeile 41: / Zeile 41: @@
 </pre>
-== cut (Wiederholung aus dem Grundkurs) ==
+== cut (Wiederholung aus 5101) ==
 <code>cut</code> zerschneidet Text an einem Trennzeichen:
@@ Zeile 74: / Zeile 74: @@
 [[ -n "$VAR" ]]     # wahr, wenn VAR NICHT leer ist
 </syntaxhighlight>
 Mehrere Bedingungen lassen sich mit <code>||</code> (ODER) oder <code>&amp;&amp;</code> (UND) verknüpfen:
@@ Zeile 88: / Zeile 103: @@
 X=""
 [[ -z "$X" ]] && echo "leer" || echo "nicht leer"
 </pre>