Shell-Grundlagen: String-Operationen

Einführung

In diesem Lab lernen Sie die grundlegenden String-Operationen im Shell-Scripting kennen. Die Arbeit mit Zeichenketten (Strings) ist essenziell, um Daten in verschiedenen Skripting-Aufgaben zu manipulieren und zu extrahieren. Sie werden Konzepte wie das Ermitteln der String-Länge, das Finden von Zeichenpositionen, das Extrahieren von Teilstrings und das Ersetzen von String-Teilen untersuchen. Diese Fähigkeiten sind entscheidend für eine effiziente Textverarbeitung in Shell-Skripten.

Kurzübersicht

Hier ist eine schnelle Übersicht der String-Operationen, die wir in diesem Lab behandeln werden:

Operation	Syntax	Beschreibung	Beispiel
String-Länge	`${#string}`	Berechnet die Anzahl der Zeichen in einem String	`${#"hello"}` ergibt `5`
Zeichenposition finden	`$(expr index "$string" "$char")`	Findet die Position eines Zeichens (1-basiert)	`$(expr index "abcdef" "c")` ergibt `3`
Teilstring extrahieren	`${string:start:length}`	Extrahiert einen Teil des Strings (0-basiert)	`${"hello":1:3}` ergibt `ell`
Erstes Vorkommen ersetzen	`${string/pattern/replacement}`	Ersetzt das erste Vorkommen eines Musters	`${"hello"/l/L}` ergibt `heLlo`
Alle Vorkommen ersetzen	`${string//pattern/replacement}`	Ersetzt alle Vorkommen eines Musters	`${"hello"//l/L}` ergibt `heLLo`
Am Anfang ersetzen	`${string/#pattern/replacement}`	Ersetzt Muster nur, wenn es am String-Anfang steht	`${"hello"/#he/HE}` ergibt `HEllo`
Am Ende ersetzen	`${string/%pattern/replacement}`	Ersetzt Muster nur, wenn es am String-Ende steht	`${"hello"/%lo/LO}` ergibt `helLO`

Erstellen einer Skriptdatei

Beginnen wir damit, eine Skriptdatei zu erstellen, in der wir unsere String-Operationen schreiben werden.

Öffnen Sie Ihr Terminal in der WebIDE. Im Terminal geben Sie Befehle ein, um mit dem Linux-System zu interagieren.
Navigieren Sie in das Projektverzeichnis:
```
cd ~/project
```
Dieser Befehl wechselt Ihr aktuelles Verzeichnis zu ~/project. Das Symbol ~ steht für Ihr Home-Verzeichnis.
Erstellen Sie eine neue Datei namens string_operations.sh:
```
touch string_operations.sh
```
Der Befehl touch erstellt eine neue, leere Datei. Falls die Datei bereits existiert, wird lediglich der Zeitstempel aktualisiert.
Öffnen Sie die Datei im WebIDE-Editor. Klicken Sie dazu auf den Dateinamen im Datei-Explorer auf der linken Seite Ihrer WebIDE.
Fügen Sie die folgende Shebang-Zeile ganz oben in der Datei ein, um den Interpreter festzulegen:
```
#!/bin/bash
```
Diese Zeile, "Shebang" genannt, weist das System an, die Bash-Shell zu verwenden, um dieses Skript zu interpretieren. Es ist immer die erste Zeile eines Shell-Skripts.

String-Länge

Lernen wir nun, wie man die Länge einer Zeichenkette ermittelt.

Fügen Sie den folgenden Code in Ihre Datei string_operations.sh ein:
```
echo "Step 2: String Length"

STRING="Hello, World!"
LENGTH=${#STRING}

echo "The string is: $STRING"
echo "Its length is: $LENGTH"
```
Lassen Sie uns das Schritt für Schritt durchgehen:
- Zuerst verwenden wir einen echo-Befehl, um eine Überschrift für diesen Abschnitt anzuzeigen.
```
echo "Step 2: String Length"
```
- Als Nächstes definieren wir eine Variable namens STRING und weisen ihr den Wert "Hello, World!" zu.
```
STRING="Hello, World!"
```
  In Bash benötigen wir keine speziellen Schlüsselwörter, um Variablen zu definieren. Wir schreiben einfach den Variablennamen, gefolgt vom Gleichheitszeichen und dem Wert.
- Dann berechnen wir die Länge des Strings mit der Syntax ${#variable} und speichern das Ergebnis in der Variable LENGTH.
```
LENGTH=${#STRING}
```
  Der Ausdruck ${#variable} ist eine spezielle Shell-Parameter-Expansion, die die Anzahl der Zeichen im String zurückgibt.
- Schließlich geben wir sowohl den ursprünglichen String als auch seine Länge aus.
```
echo "The string is: $STRING"
echo "Its length is: $LENGTH"
```
  Das $-Symbol vor einem Variablennamen weist die Bash an, diesen durch den tatsächlichen Wert der Variable zu ersetzen.
Speichern Sie die Datei. In den meisten Editoren geht das mit Strg+S (oder Cmd+S auf dem Mac).
Machen Sie das Skript ausführbar:
```
chmod +x string_operations.sh
```
Dieser Befehl ändert die Dateiberechtigungen:
- chmod steht für "change mode" (Modus ändern).
- +x bedeutet "Ausführungsberechtigung hinzufügen".
- Ohne diesen Schritt wüsste das System nicht, dass diese Datei als Programm ausgeführt werden darf.
Führen Sie das Skript aus:
```
./string_operations.sh
```
Das Präfix ./ sagt der Shell, dass sie nach dem Skript im aktuellen Verzeichnis suchen soll. Ohne dieses Präfix würde die Shell nur in den Verzeichnissen suchen, die in Ihrer PATH-Umgebungsvariable definiert sind.

Sie sollten eine Ausgabe wie diese sehen:

Step 2: String Length
The string is: Hello, World!
Its length is: 13

Falls Sie diese Ausgabe nicht sehen, prüfen Sie bitte, ob Sie die Datei gespeichert und die Ausführungsrechte vergeben haben.

Zeichenposition finden

Als Nächstes lernen wir, wie man die Position eines bestimmten Zeichens innerhalb eines Strings findet.

Fügen Sie den folgenden Code in Ihre Datei string_operations.sh ein:
```
echo -e "\nStep 3: Finding Character Position"

STRING="abcdefghijklmnopqrstuvwxyz"
CHAR="j"

POSITION=$(expr index "$STRING" "$CHAR")

echo "The string is: $STRING"
echo "We're looking for the character: $CHAR"
echo "It is at position: $POSITION"
```
Details zum Code:
- Wir beginnen mit einem echo-Befehl, der die Option -e und die Escape-Sequenz \n nutzt.
```
echo -e "\nStep 3: Finding Character Position"
```
  - Die Option -e aktiviert die Interpretation von Escape-Sequenzen.
  - \n fügt einen Zeilenumbruch vor dem Text ein, um den Abschnitt optisch vom vorherigen abzutrennen.
- Danach definieren wir zwei Variablen:
```
STRING="abcdefghijklmnopqrstuvwxyz"
CHAR="j"
```
  - STRING enthält das gesamte Alphabet in Kleinbuchstaben.
  - CHAR enthält das Zeichen "j", nach dem wir suchen.
- Wir nutzen den Befehl expr index, um die Position zu ermitteln:
```
POSITION=$(expr index "$STRING" "$CHAR")
```
  - expr ist ein Werkzeug zum Auswerten von Ausdrücken.
  - Die Operation index sucht nach Zeichen in einem String.
  - Die $()-Syntax fängt die Ausgabe des Befehls ab und weist sie der Variable POSITION zu.
  - Wir setzen die Variablen in doppelte Anführungszeichen ("$STRING"), um Probleme mit Sonderzeichen zu vermeiden.
  - Wichtig: Dieser Befehl gibt Positionen beginnend bei 1 zurück (nicht 0).
- Zum Schluss geben wir die Ergebnisse aus:
```
echo "The string is: $STRING"
echo "We're looking for the character: $CHAR"
echo "It is at position: $POSITION"
```
Speichern Sie die Datei und führen Sie das Skript erneut aus:
```
./string_operations.sh
```

Die zusätzliche Ausgabe sollte so aussehen:

Step 3: Finding Character Position
The string is: abcdefghijklmnopqrstuvwxyz
We're looking for the character: j
It is at position: 10

Beachten Sie, dass die Position 1-basiert ist. Das bedeutet, das erste Zeichen steht an Position 1, nicht 0. Dies unterscheidet sich von vielen Programmiersprachen, in denen die Indizierung typischerweise bei 0 beginnt.

Teilstring-Extraktion

Nun lernen wir, wie man einen Teil aus einer Zeichenkette extrahiert.

Fügen Sie den folgenden Code in Ihre Datei string_operations.sh ein:

echo -e "\nStep 4: Substring Extraction"

STRING="The quick brown fox jumps over the lazy dog"
START=10
LENGTH=5

SUBSTRING=${STRING:$START:$LENGTH}

echo "The original string is: $STRING"
echo "Extracting 5 characters starting from position 10:"
echo "The substring is: $SUBSTRING"

Analyse des Codes:

Header mit Zeilenumbruch:

echo -e "\nStep 4: Substring Extraction"

Definition der Variablen:
```
STRING="The quick brown fox jumps over the lazy dog"
START=10
LENGTH=5
```
- STRING enthält einen Beispielsatz.
- START ist die Position, ab der wir extrahieren wollen (Position 10).
- LENGTH gibt an, wie viele Zeichen extrahiert werden sollen (5 Zeichen).
Verwendung der Bash-Syntax zur Teilstring-Extraktion:
```
SUBSTRING=${STRING:$START:$LENGTH}
```
- Die Syntax lautet ${variable:start_position:laenge}.
- Wichtig: Im Gegensatz zum Befehl expr index sind die Positionen hier 0-basiert. Das erste Zeichen befindet sich also an Position 0.

Ergebnisausgabe:

echo "The original string is: $STRING"
echo "Extracting 5 characters starting from position 10:"
echo "The substring is: $SUBSTRING"

Speichern Sie die Datei und führen Sie das Skript aus:
```
./string_operations.sh
```

Die Ausgabe sollte wie folgt ergänzt werden:

Step 4: Substring Extraction
The original string is: The quick brown fox jumps over the lazy dog
Extracting 5 characters starting from position 10:
The substring is: brown

Im Satz "The quick brown fox..." ist Position 10 (bei Zählung ab 0) das 'b' in "brown", und die folgenden 5 Zeichen ergeben das Wort "brown".

Denken Sie an den Unterschied bei der Indizierung:

Bei expr index (Schritt 3) beginnen Positionen bei 1.
Bei der Extraktion ${STRING:position:length} (Schritt 4) beginnen Positionen bei 0.

Dies ist eine häufige Fehlerquelle im Shell-Scripting. Merken Sie sich gut, welche Operation welches System nutzt.

String-Ersetzung

Zuletzt lernen wir, wie man Teile eines Strings durch andere ersetzt.

Fügen Sie diesen Code in Ihre Datei string_operations.sh ein:

echo -e "\nStep 5: String Replacement"

STRING="The quick brown fox jumps over the lazy dog"
echo "Original string: $STRING"

## Replace the first occurrence of 'o' with 'O'
NEW_STRING=${STRING/o/O}
echo "Replacing first 'o' with 'O': $NEW_STRING"

## Replace all occurrences of 'o' with 'O'
NEW_STRING=${STRING//o/O}
echo "Replacing all 'o' with 'O': $NEW_STRING"

## Replace 'The quick' with 'The slow' if it's at the beginning of the string
NEW_STRING=${STRING/#The quick/The slow}
echo "Replacing 'The quick' with 'The slow' at the beginning: $NEW_STRING"

## Replace 'dog' with 'cat' if it's at the end of the string
NEW_STRING=${STRING/%dog/cat}
echo "Replacing 'dog' with 'cat' at the end: $NEW_STRING"

Erläuterung der Ersetzungs-Operationen:

Erstes Vorkommen eines Zeichens ersetzen:
```
NEW_STRING=${STRING/o/O}
```
- Syntax: ${variable/muster/ersatz}.
- Findet das erste 'o' (in "brown") und ersetzt es durch 'O'. Alle weiteren 'o' bleiben unverändert.
Alle Vorkommen eines Zeichens ersetzen:
```
NEW_STRING=${STRING//o/O}
```
- Syntax: ${variable//muster/ersatz} (beachten Sie den doppelten Schrägstrich).
- Ersetzt JEDES 'o' im gesamten String durch ein 'O'.
Muster am Anfang des Strings ersetzen:
```
NEW_STRING=${STRING/#The quick/The slow}
```
- Syntax: ${variable/#muster/ersatz}.
- Das #-Symbol erzwingt, dass das Muster am Anfang stehen muss.
Muster am Ende des Strings ersetzen:
```
NEW_STRING=${STRING/%dog/cat}
```
- Syntax: ${variable/%muster/ersatz}.
- Das %-Symbol erzwingt, dass das Muster am Ende stehen muss.

Speichern Sie die Datei und führen Sie das Skript ein letztes Mal aus:
```
./string_operations.sh
```

Die finale Ausgabe sollte so aussehen:

Step 5: String Replacement
Original string: The quick brown fox jumps over the lazy dog
Replacing first 'o' with 'O': The quick brOwn fox jumps over the lazy dog
Replacing all 'o' with 'O': The quick brOwn fOx jumps Over the lazy dOg
Replacing 'The quick' with 'The slow' at the beginning: The slow brown fox jumps over the lazy dog
Replacing 'dog' with 'cat' at the end: The quick brown fox jumps over the lazy cat

Diese Ersetzungs-Operationen sind mächtige Werkzeuge. Sie ermöglichen gezielte Manipulationen, was besonders bei der Datenverarbeitung, Textformatierung oder dem Bearbeiten von Dateiinhalten nützlich ist.

Zusammenfassung

In diesem Lab haben Sie verschiedene grundlegende String-Operationen im Shell-Scripting gelernt und praktisch angewendet:

Erstellen und Ausführen eines Shell-Skripts.
Berechnen der String-Länge mit ${#string}.
Finden der Zeichenposition mit $(expr index "$string" "$char").
Extrahieren eines Teilstrings mit ${string:start:length}.
Durchführen verschiedener Ersetzungs-Operationen:
- ${string/pattern/replacement} – Erstes Vorkommen ersetzen.
- ${string//pattern/replacement} – Alle Vorkommen ersetzen.
- ${string/#pattern/replacement} – Am Anfang des Strings ersetzen.
- ${string/%pattern/replacement} – Am Ende des Strings ersetzen.

Diese Fähigkeiten bilden das Fundament für komplexere Textverarbeitungsaufgaben. Während Sie weiter mit Shell-Skripten arbeiten, werden Ihnen diese Operationen bei der Analyse und Manipulation von Textdaten in Ihren Projekten unschätzbare Dienste leisten. Denken Sie daran: Übung ist der Schlüssel – experimentieren Sie ruhig mit verschiedenen Strings und Operationen!

Grundlegende String-Operationen