Aserciones de tipo y switches de tipo
Aserciones de tipo seguras y patrones con switch
Aserciones de tipo y switches de tipo es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.
Aserciones de tipo
Una aserción de tipo extrae el valor concreto de una interfaz. La sintaxis es 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
}Aserción segura de dos valores
Utilice la forma comma-ok para evitar panics con tipos incorrectos:
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
}Switch de tipos
Un switch de tipos compara el tipo dinámico de un valor de interfaz con varios tipos:
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))
}Switch de tipos para error
Los switches de tipos resultan especialmente útiles para clasificar errores:
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"))
}Aserción a una interfaz
Puede hacer una aserción a otro tipo de interfaz, no solo a tipos concretos. Es útil para comprobar si un objeto admite un comportamiento opcional:
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)
}Aserción sobre una interfaz nil
Hacer una aserción sobre una interfaz nil provoca un panic. Asegúrese siempre de que la interfaz no sea nil antes de hacer la aserción:
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)
}Alternativa a reflect.TypeOf
Para imprimir el tipo sin hacer una aserción, utilice fmt.Sprintf("%T", v) o 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
}Aserción de tipo frente a conversión
Aserción de tipo: extrae el tipo concreto de una interfaz. Conversión de tipo: cambia un tipo concreto por otro tipo compatible. Son operaciones diferentes:
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)
}Patrón comma-ok en select
El patrón comma-ok también funciona al recibir valores de un canal para detectar si está cerrado. En Go se utiliza de forma coherente el mismo lenguaje conciso.
Cuándo usar type switches
Casos de uso habituales:
- Deserialización de JSON con campos
interface{} - Categorización de errores
- Enrutamiento de mensajes de protocolo
- Comprobación opcional de interfaces (Flusher, Closer, etc.)
Comprobación rápida
¿Cuál es el resultado de una aserción de tipo no segura que falla?
Repaso
Ideas clave:
x.(T)provoca un panic si el tipo es incorrecto;x, ok := x.(T)es seguro- Los type switches gestionan varios tipos de forma clara
- Realice aserciones a interfaces para comprobar capacidades opcionales
- No realice nunca una aserción sobre una interfaz nil
Ejercicio práctico
Escriba una función sum(values []any) float64 que utilice un type switch para gestionar valores de tipo int, float64 y string (analice la cadena), e ignore los demás.
Preguntas frecuentes
¿La lección «Aserciones de tipo y switches de tipo» es gratis?
Sí — el texto completo de «Aserciones de tipo y switches de tipo» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Aserciones de tipo y switches de tipo»?
Aserciones de tipo seguras y patrones con switch Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Go Academy?
No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Aserciones de tipo y switches de tipo»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Go Academy?
Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Definición e implementación de interfaces
- Interfaces principales de la biblioteca estándar
- Aserciones de tipo y switches de tipo
- Composición de interfaces y buenas prácticas