Jak můžete pracovat s řetězci v jazyce Go?

V jazyce Go jsou řetězce neměnné sekvence bajtů.

Hlavní způsoby práce s řetězci:

Vytváření:

// Literál řetězce
s1 := "Hello, Go!"

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

Konkatenace:

s3 := "World"
result := s1 + " " + s3 // Použití operátoru +

Pro velké množství konkatenací je efektivnější použít strings.Builder:

import "strings"

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

Délka:

V bajtech:
```
byteLength := len(s1)
```

V znacích (runech):

runeLength := utf8.RuneCountInString(s1) // Vyžaduje import "unicode/utf8"

Přístup ke znakům (rune) a iterace: V jazyce Go jsou řetězce složeny z bajtů, ale při iteraci pomocí range jsou dekódovány do rune (kódových bodů Unicode).
```
import "fmt"

for index, runeValue := range s1 {
    fmt.Printf("Index: %d, Rune: %c, Typ: %T\n", index, runeValue, runeValue)
}
```
Přímý přístup podle indexu vrací bajt, nikoli rune:
```
b := s1[0] // Vrací bajt 'H'
```

Transformace:

Na pole bajtů:
```
byteSlice := []byte(s1)
```
Na pole rune:
```
runeSlice := []rune(s1)
```

Balíček strings: Poskytuje mnoho užitečných funkcí pro práci s řetězci:
- strings.Contains(s, substr): Kontrola přítomnosti podřetězce.
- strings.HasPrefix(s, prefix): Kontrola, zda řetězec začíná určitým prefixem.
- strings.HasSuffix(s, suffix): Kontrola, zda řetězec končí určitým sufixem.
- strings.Index(s, substr): Vyhledání prvního výskytu podřetězce.
- strings.ReplaceAll(s, old, new): Nahrazení všech výskytů podřetězce.
- strings.Split(s, sep): Rozdělení řetězce podle oddělovače.
- strings.Join(a []string, sep string): Spojení pole řetězců s oddělovačem.
- strings.ToLower(s): Převod na malá písmena.
- strings.ToUpper(s): Převod na velká písmena.
- strings.TrimSpace(s): Odstranění bílých znaků z začátku a konce.
Balíček fmt: Pro formátovaný výstup a načítání řetězců.

Balíček strconv: Pro převod řetězců na číselné typy a naopak.

import "strconv"

i, err := strconv.Atoi("123") // Řetězec na int
s := strconv.Itoa(i)         // Int na řetězec

Neměnnost řetězců je důležitá a znamená, že jakákoli operace, která se zdá být modifikací řetězce (například konkatenace nebo Replace), ve skutečnosti vytváří nový řetězec.