Go Academy · Lekcja

Unicode i utf8

Obsługuj tekst wielobajtowy

Unicode i utf8 to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Dlaczego Unicode ma znaczenie

Współczesny tekst zawiera akcenty, emoji i niełacińskie systemy pisma. Unicode przypisuje każdemu znakowi liczbę nazywaną punktem kodowym.

Go przechowuje stringi jako UTF-8, czyli kodowanie o zmiennej szerokości tych punktów kodowych.

package main

import "fmt"

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

Liczba bajtów na znak jest różna

W UTF-8 jeden znak zajmuje od 1 do 4 bajtów:

Litery ASCII: 1 bajt.
Litery łacińskie ze znakami diakrytycznymi: zwykle 2 bajty.
Znaki CJK: zwykle 3 bajty.

package main

import "fmt"

func main() {
    fmt.Println(len("a"))
    fmt.Println(len("é"))
    fmt.Println(len("世"))
}

Pakiet unicode/utf8

Pakiet unicode/utf8 obsługuje kodowanie. utf8.RuneCountInString(s) poprawnie zlicza znaki, w przeciwieństwie do len.

package main

import (
    "fmt"
    "unicode/utf8"
)

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

Sprawdzanie poprawności UTF-8

Należy użyć utf8.ValidString(s), aby potwierdzić, że łańcuch zawiera poprawnie sformowany tekst UTF-8, zanim zostanie przetworzony.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    fmt.Println(utf8.ValidString("héllo"))
    fmt.Println(utf8.ValidString(string([]byte{0xff, 0xfe})))
}

Dekodowanie jednej runy

utf8.DecodeRuneInString(s) zwraca pierwszą runę oraz liczbę zużytych przez nią bajtów. Dzięki temu można ręcznie przechodzić po łańcuchu.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    r, size := utf8.DecodeRuneInString("世界")
    fmt.Println(string(r), size)
}

Pętla range dekoduje automatycznie

Pętla for range już wykonuje dekodowanie UTF-8. Indeks przy każdym kroku przesuwa się o rozmiar runy w bajtach.

package main

import "fmt"

func main() {
    for i, r := range "a世b" {
        fmt.Println(i, string(r))
    }
}

Pakiet unicode

Pakiet unicode klasyfikuje pojedyncze runy. Funkcje takie jak unicode.IsLetter i unicode.IsDigit odpowiadają na pytania dotyczące znaku.

package main

import (
    "fmt"
    "unicode"
)

func main() {
    fmt.Println(unicode.IsLetter('A'))
    fmt.Println(unicode.IsDigit('7'))
    fmt.Println(unicode.IsSpace(' '))
}

Zmiana wielkości liter run po runie

unicode.ToUpper i unicode.ToLower działają na pojedynczych runach, w tym na wielu literach innych niż ASCII.

package main

import (
    "fmt"
    "unicode"
)

func main() {
    fmt.Println(string(unicode.ToUpper('a')))
    fmt.Println(string(unicode.ToLower('Z')))
}

Bezpieczne zliczanie liter

Należy połączyć oba pakiety, aby zliczać wyłącznie litery w tekście zawierającym różne znaki, poprawnie obsługując każdą runę.

package main

import (
    "fmt"
    "unicode"
)

func main() {
    count := 0
    for _, r := range "a1 b2 世!" {
        if unicode.IsLetter(r) {
            count++
        }
    }
    fmt.Println(count)
}

Odwracanie tekstu według run

Aby bezpiecznie odwrócić tekst, należy odwracać runy, a nie bajty — w przeciwnym razie znaki wielobajtowe zostaną rozdzielone.

package main

import "fmt"

func main() {
    runes := []rune("a世b")
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    fmt.Println(string(runes))
}

Połączenie wszystkiego

Proste narzędzie podsumowujące: zgłasza długość w bajtach, liczbę run oraz informację, czy tekst jest poprawnym UTF-8.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "Go 世界!"
    fmt.Println("bytes:", len(s))
    fmt.Println("runes:", utf8.RuneCountInString(s))
    fmt.Println("valid:", utf8.ValidString(s))
}

Szybkie sprawdzenie

Wybierz właściwy sposób zliczania znaków.

Podsumowanie: Unicode i utf8

Potrafisz już swobodnie obsługiwać tekst wielobajtowy:

Łańcuchy w Go używają UTF-8, a znaki zajmują od 1 do 4 bajtów.
unicode/utf8 zlicza, sprawdza poprawność i dekoduje runy.
unicode klasyfikuje pojedyncze runy i zmienia ich wielkość liter.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "café 語"
    fmt.Println(utf8.RuneCountInString(s), "runes")
}

Często zadawane pytania

Czy lekcja „Unicode i utf8” jest bezpłatna?

Tak — pełny tekst „Unicode i utf8” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Unicode i utf8”?

Obsługuj tekst wielobajtowy Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Unicode i utf8”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy