Asercje typów i przełączniki typów
Bezpieczne asercje typów i wzorce switch
Asercje typów i przełączniki typów to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 3 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.
Asercje typów
Asercja typu wyodrębnia konkretną wartość z interfejsu. Jej składnia to x.(T):
package main
import "fmt"
func main() {
var i interface{} = "hello"
s := i.(string) // panics if wrong type
fmt.Println(s, len(s)) // hello 5
}Bezpieczna asercja z dwiema wartościami
Użyj składni comma-ok, aby uniknąć paniki w przypadku nieprawidłowych typów:
package main
import "fmt"
func main() {
var i interface{} = 42
s, ok := i.(string)
fmt.Println(s, ok) // "" false
n, ok := i.(int)
fmt.Println(n, ok) // 42 true
}Przełącznik typów
Przełącznik typów porównuje dynamiczny typ wartości interfejsu z wieloma typami:
package main
import "fmt"
func describe(i interface{}) string {
switch v := i.(type) {
case int: return fmt.Sprintf("int: %d", v)
case string: return fmt.Sprintf("string: %q", v)
case bool: return fmt.Sprintf("bool: %v", v)
default: return fmt.Sprintf("unknown: %T", v)
}
}
func main() {
fmt.Println(describe(42))
fmt.Println(describe("hi"))
fmt.Println(describe(3.14))
}Przełącznik typów dla error
Przełączniki typów są szczególnie przydatne do kategoryzowania błędów:
package main
import ("errors"; "fmt")
type NotFoundError struct{ Name string }
func (e *NotFoundError) Error() string { return e.Name + " not found" }
type PermError struct{}
func (e *PermError) Error() string { return "permission denied" }
func handle(err error) {
switch e := err.(type) {
case *NotFoundError: fmt.Println("missing:", e.Name)
case *PermError: fmt.Println("perm error")
default: fmt.Println("other:", e)
}
}
func main() {
handle(&NotFoundError{"user"})
handle(errors.New("generic"))
}Asercja do interfejsu
Możesz wykonać asercję do innego typu interfejsowego, a nie tylko do typów konkretnych. Jest to przydatne do sprawdzania, czy obiekt obsługuje opcjonalne zachowanie:
package main
import "fmt"
type Flusher interface{ Flush() }
type Writer interface{ Write(string) }
type BufferedWriter struct{ buf string }
func (b *BufferedWriter) Write(s string) { b.buf += s }
func (b *BufferedWriter) Flush() { fmt.Println(b.buf); b.buf = "" }
func maybeFlush(w Writer) {
if f, ok := w.(Flusher); ok { f.Flush() }
}
func main() {
bw := &BufferedWriter{}
bw.Write("hello")
maybeFlush(bw)
}Asercja na pustym interfejsie
Wykonanie asercji na pustym interfejsie powoduje panikę. Zawsze upewnij się, że interfejs nie ma wartości nil, zanim wykonasz asercję:
package main
import "fmt"
func safePrint(i interface{}) {
if i == nil {
fmt.Println("nil")
return
}
fmt.Printf("%T: %v\n", i, i)
}
func main() {
safePrint(nil)
safePrint(42)
}Alternatywa dla reflect.TypeOf
Aby wyświetlić typ bez wykonywania asercji, użyj fmt.Sprintf("%T", v) lub reflect.TypeOf(v):
package main
import ("fmt"; "reflect")
func main() {
v := []int{1, 2, 3}
fmt.Printf("%T\n", v) // []int
fmt.Println(reflect.TypeOf(v)) // []int
}Asercja typu a konwersja
Asercja typu: wyodrębnia typ konkretny z interfejsu. Konwersja typu: zmienia jeden typ konkretny na inny zgodny typ. Są to różne operacje:
package main
import "fmt"
func main() {
var i interface{} = int32(5)
n := i.(int32) // assertion — OK
big := int64(n) // conversion — OK
fmt.Println(n, big)
}Wzorzec comma-ok w select
Wzorzec comma-ok działa również przy odbieraniu z kanału, aby wykryć jego zamknięcie. W Go konsekwentnie stosuje się tę samą zwięzłą konstrukcję.
Kiedy używać przełączników typów
Typowe zastosowania:
- Deserializacja JSON z polami
interface{} - Kategoryzowanie błędów
- Obsługa komunikatów protokołu
- Opcjonalne sprawdzanie interfejsów (Flusher, Closer itd.)
Szybkie sprawdzenie
Jaki jest wynik nieudanej asercji typu bez zabezpieczenia?
Podsumowanie
Najważniejsze informacje:
x.(T)powoduje panikę dla nieprawidłowego typu;x, ok := x.(T)jest bezpieczne- Przełączniki typów obsługują wiele typów w przejrzysty sposób
- Wykonuj asercję do interfejsów, aby sprawdzać opcjonalne możliwości
- Nigdy nie wykonuj asercji na interfejsie o wartości nil
Zadanie praktyczne
Napisz funkcję sum(values []any) float64, która za pomocą przełącznika typu obsługuje wartości int, float64 i string (parsując string), a pozostałe pomija.
Często zadawane pytania
Czy lekcja „Asercje typów i przełączniki typów” jest bezpłatna?
Tak — pełny tekst „Asercje typów i przełączniki typów” 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 „Asercje typów i przełączniki typów”?
Bezpieczne asercje typów i wzorce switch Ć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 3 z 4.
Ile czasu zajmuje lekcja „Asercje typów i przełączniki typów”?
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
- Definiowanie i implementowanie interfejsów
- Podstawowe interfejsy biblioteki standardowej
- Asercje typów i przełączniki typów
- Kompozycja interfejsów i dobre praktyki