Hoe werken strings in de programmeertaal Go?

Strings in Go zijn onveranderlijke sequenties van bytes. Ze vertegenwoordigen een "byte-snij" ([]byte) met garantie op onveranderlijkheid.

Belangrijke kenmerken:

• Onveranderlijkheid: Na creatie kan een string niet worden gewijzigd. Elke operatie die lijkt op een wijziging, creëert in feite een nieuwe string.
• Representatie: Standaard vertegenwoordigen strings in Go UTF-8-gecodeerde tekst. Ze zijn echter gewoon byte-sequenties; interpretatie als UTF-8 gebeurt bij het werken met runen.
• Runen: Unicode-tekens in Go worden weergegeven door het type rune, dat een alias is voor int32. Iteratie over een string met range decodeert automatisch UTF-8 en geeft runen en hun beginindices in bytes.
• Lengte: De functie len(s) geeft het aantal bytes in de string, niet het aantal tekens (runen). Voor het aantal runen moet je utf8.RuneCountInString(s) gebruiken of itereren met range.
• Concatenatie: Voor het samenvoegen van strings wordt de operator + gebruikt. Dit creëert een nieuwe string. Voor efficiënte samenvoeging van veel strings wordt strings.Builder aanbevolen.

Voorbeelden:

// Declaratie van een string
str := "Hello, 世界"

// Lengte van de string (in bytes)
byteLen := len(str) // 13 (H(1) e(1) l(1) l(1) o(1) ,(1)  (1) 世(3) 界(3))

// Iteratie over de runen
runeCount := 0
for index, runeValue := range str {
	// index - beginindex van de rune in bytes
	// runeValue - de rune
	runeCount++
	// fmt.Printf("Index: %d, Runes: %c (Waarde: %d)\n", index, runeValue, runeValue)
}
// runeCount - aantal runen (9)

// Toegang tot een byte op index
// Let op: dit is een byte, geen teken!
// byteAtIndex := str[0] // 'H'
// byteAtIndex := str[7] // Beginbyte van het teken '世'

// String concatenatie
newStr := str + "!"

// Gebruik van strings.Builder voor efficiënte concatenatie
// import "strings"
var builder strings.Builder
builder.WriteString("Hello, ")
builder.WriteString("World")
efficientStr := builder.String() // "Hello, World"