Go Academy · Lekcja

Konwersje typów w Go

Jawne konwersje, aliasy typów i typy zdefiniowane

Lekcja 4 z 412 kroki

Konwersje typów w Go 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 jawne konwersje

Go nigdy nie konwertuje niejawnie typów. Zapobiega to subtelnym błędom, w których mniejsza liczba całkowita po cichu przepełnia większą lub liczba zmiennoprzecinkowa traci precyzję.

Konwersje trzeba zapisywać jawnie: T(value)
Kompilator wykrywa niezgodne typy podczas kompilacji
Dzięki temu kod Go jest przewidywalny i bezpieczny

Konwersje liczbowe

Konwertowanie między typami numerycznymi polega na użyciu typu docelowego jako wywołania funkcji:

package main

func main() {
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)
    _ = u
}

Ryzyko obcięcia

Konwersja z większego typu na mniejszy obcina wartość. Nie jest zgłaszany błąd — należy zachować ostrożność:

package main

func main() {
    big := int64(300)
    small := int8(big) // 300 % 256 = 44 — silent truncation!
    _ = small
}

Konwersje między string i []byte

Konwersja między typami string i []byte kopiuje dane:

package main

func main() {
    s := "hello"
    b := []byte(s)   // string to byte slice
    b[0] = 'H'
    s2 := string(b)  // byte slice to string
    _ = s2
}

string i []rune

W celu bezpiecznej obsługi znaków Unicode należy konwertować na []rune:

package main

func main() {
    s := "Merhaba"
    runes := []rune(s)
    _ = len(runes) // character count, not byte count
}

Pakiet strconv

Do konwersji między napisami a liczbami należy używać pakietu strconv:

import "strconv"

func main() {
    n, err := strconv.Atoi("42")   // string -> int
    s := strconv.Itoa(123)          // int -> string
    _ = n; _ = err; _ = s
}

strconv.ParseFloat i FormatFloat

Bezpieczne analizowanie i formatowanie napisów zmiennoprzecinkowych:

import "strconv"

func main() {
    f, err := strconv.ParseFloat("3.14", 64)
    if err != nil { return }
    s := strconv.FormatFloat(f, 'f', 2, 64) // "3.14"
    _ = s
}

Aliasy typów a typy zdefiniowane

Go rozróżnia aliasy typów i typy zdefiniowane:

type Celsius float64 — nowy typ zdefiniowany; wymaga jawnej konwersji do typu float64 i z niego
type Celsius = float64 — alias; można go stosować zamiennie z typem float64

Przykład typu zdefiniowanego

Typy zdefiniowane zwiększają czytelność API i zapobiegają przypadkowemu mieszaniu typów:

type Celsius float64
type Fahrenheit float64

func CtoF(c Celsius) Fahrenheit {
    return Fahrenheit(c*9/5 + 32)
}

func main() {
    boiling := Celsius(100)
    _ = CtoF(boiling)
}

Konwersje interfejsów

Każdą wartość można przekonwertować na typ interfejsu, który ta wartość spełnia. Konwersja w drugą stronę wymaga asercji typu:

var i interface{} = "hello"
s, ok := i.(string) // type assertion
if ok {
    _ = s // safe to use
}

Szybkie sprawdzenie

Jaka funkcja konwertuje napis na typ int w języku Go?

Odpowiedz w interaktywnej lekcji

Podsumowanie: konwersje typów

Najważniejsze informacje dotyczące konwersji typów w języku Go:

Go nigdy nie wykonuje niejawnych konwersji — należy używać składni T(value)
Konwersje liczbowe mogą powodować obcięcie wartości — należy jawnie uwzględnić to ryzyko
[]byte(s) i string(b) kopiują dane
Do konwersji między napisami a liczbami należy używać strconv.Atoi / strconv.Itoa
Typy zdefiniowane wymagają jawnych konwersji, natomiast aliasy nie

Następny kurs: sterowanie przepływem za pomocą if, for i switch.

Bezpłatny start

Ucz się Go dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 51
Lekcje: 203

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Konwersje typów w Go” jest bezpłatna?

Tak — pełny tekst „Konwersje typów w Go” 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 „Konwersje typów w Go”?

Jawne konwersje, aliasy typów i typy zdefiniowane Ć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 „Konwersje typów w Go”?

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