Rune e byte
Comprendere i meccanismi interni delle stringhe Go
Rune e byte è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.
Che cos'è una stringa Go?
In Go, una string è una sequenza immutabile di byte. I byte contengono solitamente testo codificato in UTF-8, ma Go non lo impone.
- Non può modificare una stringa direttamente.
- Il suo
lenconta i byte, non i caratteri.
package main
import "fmt"
func main() {
s := "Go"
fmt.Println(s)
fmt.Println(len(s))
}I byte dietro le quinte
L'indicizzazione di una stringa con s[i] restituisce un singolo byte (di tipo byte, alias di uint8).
Nel testo ASCII semplice, ogni carattere occupa esattamente un byte.
package main
import "fmt"
func main() {
s := "ABC"
fmt.Println(s[0])
fmt.Println(s[1])
fmt.Println(s[2])
}Un byte è un numero
Poiché un byte è semplicemente un numero, la stampa di s[0] mostra 65 (il codice ASCII di A), non la lettera.
Per visualizzare il carattere, converta nuovamente il byte in una stringa.
package main
import "fmt"
func main() {
s := "ABC"
fmt.Println(string(s[0]))
}Che cos'è una rune?
Una rune è un alias di int32 e rappresenta un singolo punto di codice Unicode.
- Una rune può occupare più byte quando viene codificata in UTF-8.
- Utilizzi le rune quando le interessano i caratteri, non i byte grezzi.
package main
import "fmt"
func main() {
var r rune = 'A'
fmt.Println(r)
fmt.Println(string(r))
}Caratteri multibyte
I caratteri non ASCII occupano più di un byte in UTF-8. Una stringa come "héllo" contiene più byte che lettere.
Noti che len restituisce il numero di byte, che è maggiore della lunghezza visibile.
package main
import "fmt"
func main() {
s := "héllo"
fmt.Println(len(s))
}Scorrere una stringa
Un ciclo for range su una stringa decodifica automaticamente UTF-8. Ogni iterazione restituisce:
- l'indice del byte in cui inizia la rune,
- la rune stessa.
package main
import "fmt"
func main() {
for i, r := range "héllo" {
fmt.Println(i, string(r))
}
}Contare correttamente i caratteri
Per contare i caratteri invece dei byte, converta la stringa in una []rune e calcoli la sua lunghezza.
In questo modo ottiene il numero di punti di codice.
package main
import "fmt"
func main() {
s := "héllo"
runes := []rune(s)
fmt.Println(len(runes))
}Indicizzazione tramite rune
Una volta ottenuta una []rune, può indicizzarla per ottenere in modo affidabile l'N-esimo carattere, anche con testo multibyte.
package main
import "fmt"
func main() {
runes := []rune("héllo")
fmt.Println(string(runes[1]))
}Da stringhe a byte e viceversa
Può convertire liberamente una stringa in una []byte e viceversa.
[]byte(s)restituisce i byte grezzi.string(b)ricostruisce il testo.
package main
import "fmt"
func main() {
b := []byte("Go")
fmt.Println(b)
fmt.Println(string(b))
}Costruire una stringa da rune
Una slice di rune può essere riconvertita in una stringa nello stesso modo. È utile dopo aver modificato singolarmente i caratteri.
package main
import "fmt"
func main() {
runes := []rune{'G', 'o', '!'}
fmt.Println(string(runes))
}Riepilogo: byte e rune a confronto
Un modello mentale rapido:
byte= un byte grezzo (uint8);len(s)conta questi byte.rune= un punto di codice Unicode (int32);rangerestituisce questi punti.- Utilizzi
[]runequando deve contare o indicizzare i caratteri.
package main
import "fmt"
func main() {
s := "café"
fmt.Println(len(s))
fmt.Println(len([]rune(s)))
}Verifica rapida
Verifichi la sua comprensione delle rune e dei byte.
Riepilogo: rune e byte
Ha imparato che le stringhe Go sono sequenze immutabili di byte, generalmente in UTF-8.
byteè un byte grezzo;lenconta i byte.runeè un punto di codice Unicode;rangelo decodifica.- Converta con
[]byte(s)e[]rune(s)per lavorare al livello appropriato.
package main
import "fmt"
func main() {
s := "Go語"
fmt.Println("bytes:", len(s))
fmt.Println("runes:", len([]rune(s)))
}Domande Frequenti
La lezione «Rune e byte» è gratuita?
Sì — il testo completo di «Rune e byte» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.
Cosa imparerò in «Rune e byte»?
Comprendere i meccanismi interni delle stringhe Go Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Go Academy?
Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Rune e byte»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Go Academy?
Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.