Wie können Sie mit Strings in der Programmiersprache…

In Go sind Strings unveränderliche Sequenzen von Bytes.

Die wichtigsten Methoden zur Arbeit mit Strings:

Erstellung:

// String-Literal
s1 := "Hello, Go!"

// Aus einem Byte-Array
byteArray := []byte{'H', 'e', 'l', 'l', 'o'}
s2 := string(byteArray)

Verkettung:

s3 := "World"
result := s1 + " " + s3 // Verwendung des + Operators

Für viele Verkettungen ist die Verwendung von strings.Builder effizienter:

import "strings"

var sb strings.Builder
sb.WriteString("Hello")
sb.WriteString(", ")
sb.WriteString("World!")
result2 := sb.String()

Länge:

In Bytes:
```
byteLength := len(s1)
```

In Zeichen (Runen):

runeLength := utf8.RuneCountInString(s1) // Erfordert Import "unicode/utf8"

Zugriff auf Zeichen (Runen) und Iteration: In Go bestehen Strings aus Bytes, aber bei der Iteration mit range werden sie in Runen (Unicode-Codepunkte) decodiert.
```
import "fmt"

for index, runeValue := range s1 {
    fmt.Printf("Index: %d, Rune: %c, Typ: %T\n", index, runeValue, runeValue)
}
```
Direkter Zugriff nach Index gibt ein Byte zurück, nicht eine Rune:
```
b := s1[0] // Gibt das Byte 'H' zurück
```

Konvertierung:

Zu Byte-Slice:
```
byteSlice := []byte(s1)
```
Zu Rune-Slice:
```
runeSlice := []rune(s1)
```

Paket strings: Bietet viele nützliche Funktionen für die Arbeit mit Strings:
- strings.Contains(s, substr): Prüft, ob eine Teilzeichenkette enthalten ist.
- strings.HasPrefix(s, prefix): Prüft, ob die Zeichenkette mit einem Präfix beginnt.
- strings.HasSuffix(s, suffix): Prüft, ob die Zeichenkette mit einem Suffix endet.
- strings.Index(s, substr): Sucht die erste Vorkommen einer Teilzeichenkette.
- strings.ReplaceAll(s, old, new): Ersetzt alle Vorkommen einer Teilzeichenkette.
- strings.Split(s, sep): Teilt die Zeichenkette anhand eines Trennzeichens.
- strings.Join(a []string, sep string): Verbindet einen Slice von Strings mit einem Trennzeichen.
- strings.ToLower(s): Wandelt in Kleinbuchstaben um.
- strings.ToUpper(s): Wandelt in Großbuchstaben um.
- strings.TrimSpace(s): Entfernt Leerraumzeichen am Anfang und Ende.
Paket fmt: Für formatierte Ausgabe und Ein- und Ausgabe von Strings.

Paket strconv: Für die Umwandlung von Strings in numerische Typen und umgekehrt.

import "strconv"

i, err := strconv.Atoi("123") // String zu int
s := strconv.Itoa(i)         // Int zu String

Die Unveränderlichkeit von Strings ist wichtig und bedeutet, dass jede Operation, die eine String-Änderung zu sein scheint (z.B. Verkettung oder Replace), tatsächlich eine neue String erstellt.

Wie können Sie mit Strings in der Programmiersprache Go arbeiten?