Typassertioner och typeswitchar
Säkra typassertioner och switchmönster
Typassertioner och typeswitchar är en gratis lektion i Go Academy på CoddyKit. Detta är lektion 3 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.
Typassertioner
En typassertion extraherar det konkreta värdet från ett gränssnitt. Syntaxen är 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
}Säker assertion med två värden
Använd formen med komma och ok för att undvika panik vid fel typ:
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
}Typväxling
En typväxling jämför den dynamiska typen hos ett gränssnittsvärde med flera typer:
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))
}Typväxling för error
Typväxlingar är särskilt användbara för att kategorisera fel:
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"))
}Assertion till ett gränssnitt
Det går att göra en assertion till en annan gränssnittstyp, inte bara till konkreta typer. Det är användbart för att kontrollera om ett objekt stöder valfritt beteende:
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)
}Assertion på nil-gränssnitt
En assertion på ett nil-gränssnitt orsakar panik. Kontrollera alltid att gränssnittet inte är nil innan assertionen görs:
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)
}Alternativ till reflect.TypeOf
Om typen ska skrivas ut utan en assertion kan fmt.Sprintf("%T", v) eller reflect.TypeOf(v) användas:
package main
import ("fmt"; "reflect")
func main() {
v := []int{1, 2, 3}
fmt.Printf("%T\n", v) // []int
fmt.Println(reflect.TypeOf(v)) // []int
}Typassertion kontra typkonvertering
Typassertion: extrahera den konkreta typen från ett interface. Typkonvertering: ändra en konkret typ till en annan kompatibel typ. Det är olika operationer:
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)
}Comma-ok i select
Comma-ok-mönstret fungerar även vid mottagning från kanaler för att upptäcka en stängd kanal. Samma kortfattade idiom används konsekvent i Go.
När type switch ska användas
Vanliga användningsområden:
- JSON-unmarshaling med fält av typen
interface{} - Fe kategorisering
- Hantering av protokollmeddelanden
- Valfri kontroll av interface (Flusher, Closer med flera)
Snabbkontroll
Vad blir resultatet av en misslyckad typassertion utan säkerhetskontroll?
Sammanfattning
Viktiga slutsatser:
x.(T)orsakar en panic vid fel typ;x, ok := x.(T)är säkert- Type switch hanterar flera typer på ett tydligt sätt
- Gör assertions mot interface för att kontrollera valfria funktioner
- Gör aldrig en assertion på ett nil-interface
Övningsuppgift
Skriv en funktion sum(values []any) float64 som använder en type switch för att hantera värden av typerna int, float64 och string (tolka strängen), och hoppar över övriga värden.
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
Vanliga frågor
Är lektionen ”Typassertioner och typeswitchar” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Go Academy, inklusive ”Typassertioner och typeswitchar”, 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 ”Typassertioner och typeswitchar”?
Säkra typassertioner och switchmönster 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 3 av 4.
Hur lång tid tar lektionen ”Typassertioner och typeswitchar”?
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
- Definiera och implementera gränssnitt
- Centrala gränssnitt i standardbiblioteket
- Typassertioner och typeswitchar
- Gränssnittskomposition och bästa praxis