Jak możesz pracować z łańcuchami w języku Go?

W języgu Go łańcuchy są niezmienniczymi sekwencjami bajtów.

Główne sposoby pracy z łańcuchami:

Tworzenie:

// Literal łańcucha
s1 := "Hello, Go!"

// Z tablicy bajtów
byteArray := []byte{'H', 'e', 'l', 'l', 'o'}
s2 := string(byteArray)

Konkatenacja:

s3 := "World"
result := s1 + " " + s3 // Użycie operatora +

Przy dużej liczbie konkatenacji bardziej efektywne jest użycie strings.Builder:

import "strings"

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

Długość:

W bajtach:
```
byteLength := len(s1)
```

W znakach (rune):

runeLength := utf8.RuneCountInString(s1) // Wymaga importu "unicode/utf8"

Dostęp do znaków (rune) i iteracja: W Go łańcuchy składają się z bajtów, ale podczas iteracji za pomocą range są dekodowane na runy (punkty kodowe Unicode).
```
import "fmt"

for index, runeValue := range s1 {
    fmt.Printf("Indeks: %d, Rune: %c, Typ: %T\n", index, runeValue, runeValue)
}
```
Bezpośredni dostęp po indeksie zwraca bajt, nie runę:
```
b := s1[0] // Zwraca bajt 'H'
```

Konwersja:

Na tablicę bajtów:
```
byteSlice := []byte(s1)
```
Na tablicę run:
```
runeSlice := []rune(s1)
```

Pakiet strings: Zapewnia wiele przydatnych funkcji do pracy z łańcuchami:
- strings.Contains(s, substr): Sprawdza, czy zawiera podłańcuch.
- strings.HasPrefix(s, prefix): Sprawdza, czy zaczyna się od prefiksu.
- strings.HasSuffix(s, suffix): Sprawdza, czy kończy się na sufiksie.
- strings.Index(s, substr): Szuka pierwszego wystąpienia podłańcucha.
- strings.ReplaceAll(s, old, new): Zamienia wszystkie wystąpienia podłańcucha.
- strings.Split(s, sep): Dzieli łańcuch według separatora.
- strings.Join(a []string, sep string): Łączy slice łańcuchów.
- strings.ToLower(s): Konwertuje na małe litery.
- strings.ToUpper(s): Konwertuje na wielkie litery.
- strings.TrimSpace(s): Usuwa spacje z początku i końca.
Pakiet fmt: Do formatowanego wyjścia i wczytywania łańcuchów.

Pakiet strconv: Do konwersji łańcuchów na typy liczbowe i odwrotnie:

import "strconv"

i, err := strconv.Atoi("123") // Z łańcucha na int
s := strconv.Itoa(i) // Z int na łańcuch

Niezmienniczość łańcuchów jest ważna i oznacza, że każda operacja, która wydaje się modyfikować łańcuch (np. konkatenacja lub Replace), w rzeczywistości tworzy nowy łańcuch.