Cum sunt structurate șirurile în limbajul de programare Go?

Un șir în Go este o secvență imuabilă de octeți.

Caracteristici cheie:

• Imuabilitate: după crearea sa, șirul nu poate fi modificat.
• Reprezentare: este stocat ca un pointer și o lungime. Pointerul indică către primul octet al secvenței în memorie. Lungimea este numărul de octeți.
• Codificare: șirurile în Go nu conțin informații despre codificare. Sunt adesea folosite pentru stocarea UTF-8, dar pot conține orice octet.
• Iterare pe octeți: ciclul for index, value range string la iterarea peste un șir returnează indexul și rune-ul (int32), nu octetul.
• Iterare pe rune-uri: un rune reprezintă un punct de cod Unicode. Go folosește UTF-8, deci un rune poate ocupa între 1 și 4 octeți.
• Obținerea unui subșir: operația de tăiere string[start:end] creează un nou șir care indică aceeași zonă de memorie, dar cu limite diferite.

Exemple:

// Declarare și inițializare
var s string
s = "Привет" // Literal de șir în Go - secvență de octeți,
             // de obicei interpretată ca UTF-8

// Lungimea șirului în octeți
byteLength := len(s) // 12, deoarece "П", "р", "и", "в", "е", "т" sunt caractere multibyte în UTF-8

// Iterare pe rune-uri
runeCount := 0
for index, runeValue := range s {
    // index - indexul de început al rune-ului în octeți
    // runeValue - valoarea rune-ului (int32)
    _ = index // utilizarea unui identificator anonim _ pentru variabile neutilizate
    // fmt.Printf("Index: %d, Rune: %c (U+%04X)\n", index, runeValue, runeValue)
    runeCount++
}
// runeCount va fi 6

// Iterare pe octeți
byteCount := 0
for i := 0; i < len(s); i++ {
    // s[i] - octet la indexul i
    _ = s[i] // utilizarea unui identificator anonim
    // fmt.Printf("Octet la indexul %d: %d\n", i, s[i])
    byteCount++
}
// byteCount va fi 12

// Obținerea unui subșir (tăiere de octeți)
// Important: tăierea de octeți poate rupe un rune multibyte
// sub := s[0:5] // Poate fi o secvență UTF-8 invalidă

// Utilizarea pachetelor strings sau unicode/utf8 pentru lucru sigur cu rune

Comparativ cu tăierea de octeți ([]byte):

Caracteristică	String	[]byte
Modificabilitate	Nu	Da
Reprezentare	Poințer + Lungime	Poințer + Lungime + Capacitate
Tip	Primitiv încorporat	Slice (felie)
Utilizare	Text imuabil	Date modificabile (octeți)

Conversie între string și []byte:

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

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