Go Academy · Lektion

Runor kontra byte

Förstå Go-strängars interna uppbyggnad

Lektion 1 av 413 steg

Runor kontra byte är en gratis lektion i Go Academy på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Go Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Go Academy innehåller totalt 4 lektioner.

Vad är en Go-sträng?

I Go är en string en oföränderlig sekvens av byte. Byten innehåller vanligtvis UTF-8-kodad text, men Go kräver aldrig det.

Du kan inte ändra en sträng på plats.
Dess len räknar byte, inte tecken.

package main

import "fmt"

func main() {
    s := "Go"
    fmt.Println(s)
    fmt.Println(len(s))
}

Byte bakom kulisserna

Om du indexerar en sträng med s[i] får du tillbaka en enda byte (typen byte, en alias för uint8).

För vanlig ASCII-text är varje tecken exakt en byte.

package main

import "fmt"

func main() {
    s := "ABC"
    fmt.Println(s[0])
    fmt.Println(s[1])
    fmt.Println(s[2])
}

En byte är ett tal

Eftersom en byte bara är ett tal visar utskrift av s[0] 65 (ASCII-koden för A), inte bokstaven.

Om du vill se tecknet konverterar du byten tillbaka till en sträng.

package main

import "fmt"

func main() {
    s := "ABC"
    fmt.Println(string(s[0]))
}

Vad är en rune?

En rune är en alias för int32 och representerar en enda Unicode-kodpunkt.

En rune kan omfatta flera byte när den kodas som UTF-8.
Använd runes när du bryr dig om tecken, inte råa byte.

package main

import "fmt"

func main() {
    var r rune = 'A'
    fmt.Println(r)
    fmt.Println(string(r))
}

Flerbytes tecken

Tecken som inte är ASCII tar mer än en byte i UTF-8. En sträng som "héllo" innehåller fler byte än bokstäver.

Observera att len rapporterar antalet byte, vilket är större än den synliga längden.

package main

import "fmt"

func main() {
    s := "héllo"
    fmt.Println(len(s))
}

Iterera över en sträng

En for range-loop över en sträng avkodar UTF-8 automatiskt. Varje iteration ger:

byteindexet där runen börjar,
själva runen.

package main

import "fmt"

func main() {
    for i, r := range "héllo" {
        fmt.Println(i, string(r))
    }
}

Räkna tecken korrekt

Om du vill räkna tecken i stället för byte konverterar du strängen till en []rune och tar dess längd.

Det ger antalet kodpunkter.

package main

import "fmt"

func main() {
    s := "héllo"
    runes := []rune(s)
    fmt.Println(len(runes))
}

Indexering med rune

När du har en []rune kan du indexera den för att på ett tillförlitligt sätt få det N:te tecknet, även i text med flerbytes tecken.

package main

import "fmt"

func main() {
    runes := []rune("héllo")
    fmt.Println(string(runes[1]))
}

Strängar till byte och tillbaka

Du kan konvertera fritt mellan en sträng och en []byte.

[]byte(s) ger de råa byten.
string(b) bygger upp texten igen.

package main

import "fmt"

func main() {
    b := []byte("Go")
    fmt.Println(b)
    fmt.Println(string(b))
}

Bygga en sträng från runes

En slice med runes konverteras tillbaka till en sträng på samma sätt. Det är praktiskt efter att du har redigerat enskilda tecken.

package main

import "fmt"

func main() {
    runes := []rune{'G', 'o', '!'}
    fmt.Println(string(runes))
}

Sammanfattning: byte kontra runes

En snabb mental modell:

byte = en rå byte (uint8), len(s) räknar dessa.
rune = en Unicode-kodpunkt (int32), range ger dessa.
Använd []rune när du räknar eller indexerar tecken.

package main

import "fmt"

func main() {
    s := "café"
    fmt.Println(len(s))
    fmt.Println(len([]rune(s)))
}

Snabbkontroll

Testa din förståelse av runes och byte.

Besvara frågan i den interaktiva lektionen

Sammanfattning: runes kontra byte

Du har lärt dig att Go-strängar är oföränderliga bytesekvenser, vanligtvis i UTF-8.

byte är en rå byte; len räknar byte.
rune är en Unicode-kodpunkt; range avkodar dem.
Konvertera med []byte(s) och []rune(s) för att arbeta på rätt nivå.

package main

import "fmt"

func main() {
    s := "Go語"
    fmt.Println("bytes:", len(s))
    fmt.Println("runes:", len([]rune(s)))
}

Gratis att börja

Lär dig Go med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Runor kontra byte” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Go Academy, inklusive ”Runor kontra byte”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Go Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Runor kontra byte”?

Förstå Go-strängars interna uppbyggnad Ni övar på Go Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Go Academy?

Du behöver inga förkunskaper. Utbildningen i Go Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Runor kontra byte”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Go Academy-lektionen?

Ja. Varje Go Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Go Academy