Come sono strutturate le stringhe nel linguaggio di programmazione Go?

Una stringa in Go è una sequenza immutabile di byte.

Caratteristiche principali:

• Immutabilità: dopo la creazione, la stringa non può essere modificata.
• Rappresentazione: viene memorizzata come un puntatore e una lunghezza. Il puntatore punta al primo byte della sequenza in memoria. La lunghezza è il numero di byte.
• Codifica: le stringhe in Go non contengono informazioni sulla codifica. Sono spesso usate per memorizzare UTF-8, ma possono contenere qualsiasi byte.
• Iterazione sui byte: il ciclo for index, value range string durante l'iterazione su una stringa restituisce l'indice e la rune (int32), non il byte.
• Iterazione sulle rune: una rune rappresenta un punto di codice Unicode. Go utilizza UTF-8, quindi una rune può occupare da 1 a 4 byte.
• Ottenere una sottostringa: l'operazione di slicing string[start:end] crea una nuova stringa che punta alla stessa sezione di memoria, ma con limiti diversi.

Esempi:

// Dichiarazione e inizializzazione
var s string
s = "Привет" // Letterale di stringa in Go - sequenza di byte,
             // generalmente interpretata come UTF-8

// Lunghezza della stringa in byte
byteLength := len(s) // 12, poiché "П", "р", "и", "в", "е", "т" sono caratteri multibyte in UTF-8

// Iterazione sulle rune
runeCount := 0
for index, runeValue := range s {
    // index - indice di inizio della rune in byte
    // runeValue - valore della rune (int32)
    _ = index // uso di un identificatore anonimo _ per variabile non usata
    // fmt.Printf("Indice: %d, Rune: %c (U+%04X)\n", index, runeValue, runeValue)
    runeCount++
}
// runeCount sarà 6

// Iterazione sui byte
byteCount := 0
for i := 0; i < len(s); i++ {
    // s[i] - byte all'indice i
    _ = s[i] // uso di un identificatore anonimo
    // fmt.Printf("Byte all'indice %d: %d\n", i, s[i])
    byteCount++
}
// byteCount sarà 12

// Ottenere una sottostringa (slicing di byte)
// Importante: lo slicing di byte può interrompere una rune multibyte
// sub := s[0:5] // Potrebbe essere una sequenza UTF-8 non valida

// Uso di pacchetti strings o unicode/utf8 per lavorare in modo sicuro con le rune

Confronto con lo slicing di byte ([]byte):

Caratteristica	Stringa	[]byte
Mutabilità	No	Sì
Rappresentazione	Puntatore + Lunghezza	Puntatore + Lunghezza + Capacità
Tipo	Primitive incorporato	Slice (fetta)
Uso	Testo immutabile	Dati modificabili (byte)

Conversione tra string e []byte:

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

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