modul:m122:learningunits:lu01:ueberblick

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Nächste Überarbeitung		 Vorhergehende Überarbeitung
modul:m122:learningunits:lu01:ueberblick [2024/11/08 06:41] – angelegt msutermodul:m122:learningunits:lu01:ueberblick [2024/11/11 14:20] (aktuell) – [Eingebaute Variablen:] msuter
Zeile 1: Zeile 1:
 ====== LU01b - Überblick ====== ====== LU01b - Überblick ======
-Shellprogrammierung mit **Bash** ist eine leistungsstarke und vielseitige Methode, um Aufgaben auf Linux- und Unix-Systemen zu automatisieren und Prozesse zu steuern. Die **Bash-Shell** (Bourne Again SHell) ist eine der am weitesten verbreiteten Unix-Shells und bietet eine breite Palette von Funktionen zur Verwaltung und Steuerung von Systemaufgaben. 
  
-### 1. Was ist Shellprogrammierung? 
  
-Eine Shell ist eine Schnittstelle zwischen Benutzer und Betriebssystem. Sie ermöglicht es, Befehle einzugeben, Programme auszuführen und Systemprozesse zu steuern. **Shellprogrammierung** oder **Shell-Scripting** bedeutet, mehrere Befehle in einem Skript zu kombinieren, um sie automatisiert und wiederholt auszuführen. Ein **Shell-Skript** ist einfach eine Textdatei mit einer Liste von Befehlen, die in der Reihenfolge ausgeführt werden, wie sie im Skript stehen.+===== Die Grundlagen eines Bash-Skripts =====
  
-### 2. Die Grundlagen eines Bash-Skripts 
  
 Ein Bash-Skript beginnt normalerweise mit einer sogenannten **Shebang**-Zeile, die angibt, welche Shell zur Ausführung verwendet werden soll. Für Bash-Skripte sieht die Shebang wie folgt aus: Ein Bash-Skript beginnt normalerweise mit einer sogenannten **Shebang**-Zeile, die angibt, welche Shell zur Ausführung verwendet werden soll. Für Bash-Skripte sieht die Shebang wie folgt aus:
  
-```bash+<code bash>
 #!/bin/bash #!/bin/bash
-```+</code>
  
 Ein einfaches Beispiel: Ein einfaches Beispiel:
  
-```bash+<code bash>
 #!/bin/bash #!/bin/bash
 # Mein erstes Bash-Skript # Mein erstes Bash-Skript
 echo "Hallo, Welt!" echo "Hallo, Welt!"
-```+</code>
  
 Speichern Sie dieses Skript in einer Datei, z. B. `hallo.sh`, und machen Sie die Datei ausführbar: Speichern Sie dieses Skript in einer Datei, z. B. `hallo.sh`, und machen Sie die Datei ausführbar:
  
-```bash+<code bash>
 chmod +x hallo.sh chmod +x hallo.sh
 ./hallo.sh ./hallo.sh
-```+</code>
  
 Das Skript gibt dann den Text "Hallo, Welt!" aus. Das Skript gibt dann den Text "Hallo, Welt!" aus.
  
-### 3. Variablen und ihre Verwendung+===== Variablen und ihre Verwendung ===== 
  
 In Bash können Sie Variablen verwenden, um Daten zu speichern und diese im Skript wiederzuverwenden. In Bash können Sie Variablen verwenden, um Daten zu speichern und diese im Skript wiederzuverwenden.
  
-#### Beispiel:+==== Beispiel: ==== 
  
-```bash+<code bash>
 #!/bin/bash #!/bin/bash
 NAME="Max" NAME="Max"
 echo "Hallo, $NAME!" echo "Hallo, $NAME!"
-```+</code>
  
 Variablen werden ohne das `$`-Zeichen deklariert (`NAME="Max"`), aber mit `$` aufgerufen (`$NAME`). Variablen werden ohne das `$`-Zeichen deklariert (`NAME="Max"`), aber mit `$` aufgerufen (`$NAME`).
  
-#### Eingebaute Variablen:+===== Eingebaute Variablen: ===== 
  
 Bash enthält viele vordefinierte Variablen. Einige wichtige Beispiele: Bash enthält viele vordefinierte Variablen. Einige wichtige Beispiele:
  
-- `$0`: Der Name des Skripts. +  * `$0`: Der Name des Skripts. 
-- `$1`, `$2`, ...: Übergabeparameter an das Skript. +  * `$1`, `$2`, ...: Übergabeparameter an das Skript. 
-- `$#`: Anzahl der Übergabeparameter. +  * `$#`: Anzahl der Übergabeparameter. 
-- `$?`: Rückgabewert des letzten Befehls.+  * `$?`: Rückgabewert des letzten Befehls.
  
-#### Beispiel:+====  Beispiel: ====
  
-```bash+<code bash>
 #!/bin/bash #!/bin/bash
 echo "Das Skript heißt $0" echo "Das Skript heißt $0"
 echo "Der erste Parameter ist $1" echo "Der erste Parameter ist $1"
 echo "Anzahl der Parameter: $#" echo "Anzahl der Parameter: $#"
-```+</code>
  
-### 4. Kontrollstrukturen+===== Kontrollstrukturen ===== 
 + 
 + 
 +==== Bedingte Anweisungen (if-else) ====
  
-#### Bedingte Anweisungen (if-else) 
  
 Mit `if`-Bedingungen lassen sich Verzweigungen definieren: Mit `if`-Bedingungen lassen sich Verzweigungen definieren:
  
-```bash+<code bash>
 #!/bin/bash #!/bin/bash
 NUMBER=5 NUMBER=5
Zeile 77: Zeile 79:
     echo "$NUMBER ist nicht größer als 3"     echo "$NUMBER ist nicht größer als 3"
 fi fi
-```+</code>
  
 **Vergleichsoperatoren:** **Vergleichsoperatoren:**
-- `-eq`: gleich (==) +  * `-eq`: gleich (''=='') 
-- `-ne`: ungleich (!=) +  * `-ne`: ungleich (''!='') 
-- `-lt`: kleiner als (<) +  * `-lt`: kleiner als (''<'') 
-- `-gt`: größer als (>) +  * `-gt`: größer als (''>'') 
-- `-le`: kleiner oder gleich (<=) +  * `-le`: kleiner oder gleich (''<''''='') 
-- `-ge`: größer oder gleich (>=)+  * `-ge`: größer oder gleich (''>='') 
 + 
 +==== Schleifen (for, while) ====
  
-#### Schleifen (for, while) 
  
 **for-Schleife:** **for-Schleife:**
  
-```bash+<code bash>
 #!/bin/bash #!/bin/bash
 for i in 1 2 3 4 5; do for i in 1 2 3 4 5; do
     echo "Zahl: $i"     echo "Zahl: $i"
 done done
-```+</code>
  
 **while-Schleife:** **while-Schleife:**
  
-```bash+<code bash>
 #!/bin/bash #!/bin/bash
 COUNTER=1 COUNTER=1
Zeile 107: Zeile 110:
     ((COUNTER++))     ((COUNTER++))
 done done
-```+</code> 
 + 
 +===== Funktionen =====
  
-### 5. Funktionen 
  
 Funktionen sind nützlich, um wiederverwendbare Codeblöcke zu definieren: Funktionen sind nützlich, um wiederverwendbare Codeblöcke zu definieren:
  
-```bash+<code bash>
 #!/bin/bash #!/bin/bash
 # Funktion definieren # Funktion definieren
Zeile 123: Zeile 127:
 begruesse "Maria" begruesse "Maria"
 begruesse "Max" begruesse "Max"
-```+</code> 
 + 
 +===== Nützliche Befehle in Bash-Skripten =====
  
-### 6. Nützliche Befehle in Bash-Skripten 
  
-- **`echo`**: Gibt Text aus. +  * **`echo`**: Gibt Text aus. 
-- **`read`**: Liest Benutzereingaben. +  * **`read`**: Liest Benutzereingaben. 
-- **`expr`**: Rechnet einfache arithmetische Ausdrücke. +  * **`expr`**: Rechnet einfache arithmetische Ausdrücke. 
-- **`test`** oder `[ ... ]`: Prüft Bedingungen (Dateien, Strings, Zahlen). +  * **`test`** oder `[ ... ]`: Prüft Bedingungen (Dateien, Strings, Zahlen). 
-- **`exit`**: Beendet das Skript und gibt einen Status zurück.+  * **`exit`**: Beendet das Skript und gibt einen Status zurück.
  
 Beispiel für Benutzereingabe und Arithmetik: Beispiel für Benutzereingabe und Arithmetik:
  
-```bash+<code bash>
 #!/bin/bash #!/bin/bash
 echo "Gib eine Zahl ein:" echo "Gib eine Zahl ein:"
Zeile 143: Zeile 148:
 sum=$(expr $num1 + $num2) sum=$(expr $num1 + $num2)
 echo "Die Summe ist: $sum" echo "Die Summe ist: $sum"
-```+</code>
  
-### 7. Fehlerbehandlung+===== Fehlerbehandlung =====
  
 Mit `$?` kann der Rückgabewert des letzten Befehls überprüft werden. Ein Wert von `0` bedeutet Erfolg, jeder andere Wert zeigt einen Fehler an. Mit `$?` kann der Rückgabewert des letzten Befehls überprüft werden. Ein Wert von `0` bedeutet Erfolg, jeder andere Wert zeigt einen Fehler an.
  
-```bash+<code bash>
 #!/bin/bash #!/bin/bash
 mkdir /testverzeichnis mkdir /testverzeichnis
Zeile 157: Zeile 162:
     echo "Verzeichnis erfolgreich erstellt"     echo "Verzeichnis erfolgreich erstellt"
 fi fi
-```+</code>
  
-### 8. Praktische Tipps+===== Praktische Tipps =====
  
-- Verwenden Sie **Kommentare** (`#`), um den Code lesbarer zu machen. +  * Verwenden Sie **Kommentare** (`#`), um den Code lesbarer zu machen. 
-- Testen Sie Skripte Schritt für Schritt, insbesondere bei komplexen Aufgaben. +  * Testen Sie Skripte Schritt für Schritt, insbesondere bei komplexen Aufgaben. 
-- Nutzen Sie **Debugging**-Modi mit `bash -x script.sh`, um zu sehen, wie Befehle ausgeführt werden.+  * Nutzen Sie **Debugging**-Modi mit `bash -x script.sh`, um zu sehen, wie Befehle ausgeführt werden.
  
-### Fazit+===== Fazit =====
  
 Die Shellprogrammierung mit Bash bietet eine Vielzahl von Möglichkeiten, wiederkehrende Aufgaben zu automatisieren und effiziente Workflows zu schaffen. Mit grundlegenden Kenntnissen in Variablen, Kontrollstrukturen und Funktionen können Sie bereits erste nützliche Skripte erstellen. Die Shellprogrammierung mit Bash bietet eine Vielzahl von Möglichkeiten, wiederkehrende Aufgaben zu automatisieren und effiziente Workflows zu schaffen. Mit grundlegenden Kenntnissen in Variablen, Kontrollstrukturen und Funktionen können Sie bereits erste nützliche Skripte erstellen.
  • modul/m122/learningunits/lu01/ueberblick.1731044465.txt.gz
  • Zuletzt geändert: 2024/11/08 06:41
  • von msuter