```bash
 nano zahlen.sh
```

```sh
#!/bin/bash

for zahl in 1 2 3 4;
    do
        printf "Zahl ist die ${zahl}\n"
    done
```
Anschließend ausführbar machen

```sh
 chmod u+x zahlen.sh
```


```sh
#!/bin/bash
data=zentrum
for fach in Deutsch Sport Mathe Physik; 
do
        for name in King Lion Duck; 
		do
                mkdir -p $data/$fach/$name
                touch $data/$fach/$name/${name}_adresse.txt
                touch $data/$fach/$name/${name}_bankdaten.txt
        done
done
```
## Variablen
Variablennamen werden in `{}` geschrieben, um sie klar zu referenzieren.
```sh
my_var="hello"
echo "${my_var}world"  # Gibt "helloworld" aus
```
## Arrays
```sh
my_array=("apple" "banana" "cherry")
echo "${my_array[@]}"
```

```sh
for item in "${my_array[@]}"; do
  echo "$item"
done
```


## Eckige [] statt runder Klammern ()

In vielen Programmiersprachen werden runde Klammern `()` verwendet, um Bedingungen oder Ausdrücke zu gruppieren.  
In Bash und anderen Shell-Skriptsprachen jedoch eckige Klammern `[]` oder doppelte eckige Klammern `[[]]` 

### Bash (Shell-Skript)

- **Einfache eckige Klammern `[ ... ]`**:
  ```bash
  if [ "$variable" = "value" ]; then
    echo "Die Variable ist gleich value."
  fi
  ```

- **Doppelte eckige Klammern `[[ ... ]]`**:
  ```bash
  if [[ "$variable" == "value" && -f "datei" ]]; then
    echo "Die Variable ist gleich value und die Datei existiert."
  fi
  ```



### Erklärung

- **Bash**: Verwendet eckige Klammern, um Bedingungen zu definieren. Dies ist eine spezielle Syntax für Shell-Skripte.
- **Andere Sprachen**: Verwenden in der Regel runde Klammern, um Bedingungen oder Ausdrücke zu gruppieren.



## Shellskript: Namen aus einer Datei lesen + Ordner erstellen

```bash
#!/bin/bash

# Datei, die die Namen enthält
datei="namen.txt"

# Überprüfen, ob die Datei existiert
if [[ ! -f "$datei" ]]; then
  echo "Die Datei $datei existiert nicht."
  exit 1
fi

# Zeilenweise die Datei lesen und Ordner erstellen
while IFS= read -r name; do
  # Leere Zeilen überspringen
  if [[ -n "$name" ]]; then
    # Ordner erstellen
    mkdir -p "$name"
    echo "Ordner $name erstellt."
  fi
done < "$datei"
```

### Erklärung:
- `#!/bin/bash`: Gibt an, dass das Skript mit der Bash-Shell ausgeführt werden soll.
- `datei="namen.txt"`: Der Name der Datei, die die Namen enthält. Du kannst diesen Namen ändern, um eine andere Datei zu verwenden.
- `if [[ ! -f "$datei" ]]; then`: Überprüft, ob die Datei existiert. Wenn nicht, gibt das Skript eine Fehlermeldung aus und beendet sich.
- `while IFS= read -r name; do`: Liest die Datei zeilenweise.
- `if [[ -n "$name" ]]; then`: Überprüft, ob die Zeile nicht leer ist.
- `mkdir -p "$name"`: Erstellt einen Ordner mit dem Namen aus der Zeile. Der Parameter `-p` sorgt dafür, dass keine Fehlermeldung ausgegeben wird, wenn der Ordner bereits existiert.
- `echo "Ordner $name erstellt."`: Gibt eine Bestätigungsmeldung aus.

`IFS` steht für "Internal Field Separator" und ist eine spezielle Umgebungsvariable in der Unix-Shell, die verwendet wird, um die Zeichen zu definieren, die als Worttrenner (Delimiter) fungieren, wenn die Shell eine Zeichenkette in einzelne Wörter aufteilt. Standardmäßig enthält `IFS` die Zeichen Leerzeichen, Tabulator und Zeilenumbruch.

### Verwendung von `IFS`

- **Standardwert von `IFS`**: Normalerweise sind dies Leerzeichen, Tabulatoren und Zeilenumbrüche. Das bedeutet, dass diese Zeichen verwendet werden, um Eingaben in einzelne Felder zu trennen.

- **Ändern von `IFS`**: Du kannst `IFS` ändern, um andere Zeichen als Trennzeichen zu verwenden. Dies ist besonders nützlich, wenn du Dateien oder Zeichenketten verarbeitest, die andere Trennzeichen verwenden.

### Beispiel

Im vorherigen Skript wurde `IFS=` verwendet, um sicherzustellen, dass führende und nachfolgende Leerzeichen in den Zeilen der Datei nicht entfernt werden. Hier ist, was passiert:

```bash
while IFS= read -r name; do
  # Verarbeitung der Zeile
done < "$datei"
```

- **`IFS=`**: Setzt `IFS` auf ein leeres Zeichen, sodass keine Zeichen als Trennzeichen verwendet werden. Dies bedeutet, dass die gesamte Zeile als ein einziges Feld gelesen wird, unabhängig von Leerzeichen oder Tabulatoren.

- **`read -r name`**: Liest jede Zeile der Datei in die Variable `name`. Der Parameter `-r` verhindert, dass Backslashes als Escape-Zeichen interpretiert werden.

Durch das Setzen von `IFS` auf ein leeres Zeichen wird sichergestellt, dass die Zeilen genau so gelesen werden, wie sie in der Datei stehen, ohne dass sie in mehrere Teile aufgeteilt werden.