Hoe zijn strings opgebouwd in de programmeertaal Go?

Een string in Go is een onveranderlijke sequentie van bytes.

Belangrijke kenmerken:

• Onveranderlijkheid: na creatie kan de string niet worden gewijzigd.
• Representatie: wordt opgeslagen als een pointer en lengte. De pointer wijst naar de eerste byte van de sequentie in het geheugen. De lengte is het aantal bytes.
• Codering: strings in Go bevatten geen informatie over de codering. Ze worden vaak gebruikt om UTF-8 op te slaan, maar kunnen elk byte bevatten.
• Iteratie over bytes: de for index, value range string loop geeft bij iteratie over een string de index en de rune (int32) terug, niet de byte.
• Iteratie over runen: een rune vertegenwoordigt een Unicode-codepunt. Go gebruikt UTF-8, dus een rune kan van 1 tot 4 bytes in beslag nemen.
• Substring verkrijgen: de slicing operatie string[start:end] maakt een nieuwe string die naar hetzelfde geheugenblok wijst, maar met andere grenzen.

Voorbeelden:

// Declaratie en initialisatie
var s string
s = "Привет" // String literal in Go - sequentie van bytes,
             // meestal geïnterpreteerd als UTF-8

// Lengte van de string in bytes
byteLength := len(s) // 12, omdat "П", "р", "и", "в", "е", "т" multibyte-tekens zijn in UTF-8

// Iteratie over runen
runeCount := 0
for index, runeValue := range s {
    // index - index van het begin van de rune in bytes
    // runeValue - waarde van de rune (int32)
    _ = index // gebruik van een anonieme placeholder _ voor niet-gebruikte variabelen
    // fmt.Printf("Index: %d, Rune: %c (U+%04X)\n", index, runeValue, runeValue)
    runeCount++
}
// runeCount zal 6 zijn

// Iteratie over bytes
byteCount := 0
for i := 0; i < len(s); i++ {
    // s[i] - byte op index i
    _ = s[i] // gebruik van een anonieme placeholder
    // fmt.Printf("Byte op index %d: %d\n", i, s[i])
    byteCount++
}
// byteCount zal 12 zijn

// Verkrijgen van een substring (slice van bytes)
// Belangrijk: slice van bytes kan een multibyte rune breken
// sub := s[0:5] // Dit kan een ongeldige UTF-8 sequentie zijn

// Gebruik van packages strings of unicode/utf8 voor veilige bewerking van runen

Vergelijking met slice van bytes ([]byte):

Kenmerk	String	[]byte
Wijzigbaarheid	Nee	Ja
Representatie	Pointer + Lengte	Pointer + Lengte + Capaciteit
Type	Ingebouwd primitief	Slice (deel)
Gebruik	Onveranderlijke tekst	Wijzigbare data (bytes)

Conversie tussen string en []byte:

// string -> []byte
byteSlice := []byte(s)

// []byte -> string
newString := string(byteSlice)