Hoe kun je werken met strings in de programmeertaal…

In Go zijn strings onveranderlijke sequenties van bytes.

De belangrijkste manieren om met strings te werken:

Aanmaken:

// Stringliteraal
s1 := "Hello, Go!"

// Van een byte-array
byteArray := []byte{'H', 'e', 'l', 'l', 'o'}
s2 := string(byteArray)

Samenvoegen:

s3 := "World"
result := s1 + " " + s3 // Gebruik van de + operator

Voor veel samenvoegingen is het efficiënter om strings.Builder te gebruiken:

import "strings"

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

Lengte:

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

In tekens (runes):

runeLength := utf8.RuneCountInString(s1) // Vereist import "unicode/utf8"

Toegang tot tekens (runes) en iteratie: In Go bestaan strings uit bytes, maar bij iteratie met range worden ze gedecodeerd in runes (Unicode-codepunten).
```
import "fmt"

for index, runeValue := range s1 {
    fmt.Printf("Index: %d, Rune: %c, Type: %T\n", index, runeValue, runeValue)
}
```
Directe toegang via index geeft een byte terug, niet een rune:
```
b := s1[0] // Geeft de byte 'H'
```

Conversie:

Naar byte-slice:
```
byteSlice := []byte(s1)
```
Naar rune-slice:
```
runeSlice := []rune(s1)
```

strings-pakket: Biedt veel nuttige functies voor werken met strings:
- strings.Contains(s, substr): Controleert of een substring aanwezig is.
- strings.HasPrefix(s, prefix): Controleert of de string begint met een prefix.
- strings.HasSuffix(s, suffix): Controleert of de string eindigt met een suffix.
- strings.Index(s, substr): Zoekt de eerste voorkomen van een substring.
- strings.ReplaceAll(s, old, new): Vervangt alle voorkomen van een substring.
- strings.Split(s, sep): Splitst de string op basis van een scheidingsteken.
- strings.Join(a []string, sep string): Voegt een slice van strings samen met een scheidingsteken.
- strings.ToLower(s): Zet om naar kleine letters.
- strings.ToUpper(s): Zet om naar hoofdletters.
- strings.TrimSpace(s): Verwijdert spaties aan het begin en einde.
fmt-pakket: Voor geformatteerde output en input.

strconv-pakket: Voor conversie tussen strings en numerieke types:

import "strconv"

i, err := strconv.Atoi("123") // Van string naar int
s := strconv.Itoa(i) // Van int naar string

De onveranderlijkheid van strings is belangrijk en betekent dat elke operatie die lijkt te modificeren (bijvoorbeeld concatenatie of Replace) in feite een nieuwe string creëert.

Hoe kun je werken met strings in de programmeertaal Go?