Llamadas dinámicas a funciones
Llamada a funciones y asignación de valores mediante reflect
Llamadas dinámicas a funciones 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.
reflect.Value.Call
Value.Call(args) llama a la función representada por Value con los argumentos proporcionados (como un []reflect.Value) y devuelve los resultados como un []reflect.Value.
fn := reflect.ValueOf(add)
results := fn.Call([]reflect.Value{
reflect.ValueOf(2),
reflect.ValueOf(3),
})
fmt.Println(results[0].Int()) // 5Comprobación de tipos de argumentos
Asegúrese de que los tipos de los argumentos coincidan con la firma de la función antes de llamar. Los tipos incompatibles provocan un pánico.
t := reflect.TypeOf(fn)
if t.NumIn() != len(args) { panic("wrong arg count") }
for i, arg := range args {
if !reflect.TypeOf(arg).AssignableTo(t.In(i)) { panic("type mismatch") }
}Funciones variádicas
Llame a una función variádica con Value.Call (expandiendo el slice) o Value.CallSlice (pasando los argumentos variádicos como un valor slice):
sum := reflect.ValueOf(func(ns ...int) int {
total := 0
for _, n := range ns { total += n }
return total
})
args := reflect.ValueOf([]int{1,2,3})
results := sum.CallSlice([]reflect.Value{args})reflect.MakeFunc
reflect.MakeFunc crea una función nueva en tiempo de ejecución con un tipo determinado y un cuerpo envolvente. Se utiliza para generar funciones adaptadoras para interfaces.
t := reflect.TypeOf(func(int) string { return "" })
fn := reflect.MakeFunc(t, func(args []reflect.Value) []reflect.Value {
return []reflect.Value{reflect.ValueOf(strconv.Itoa(args[0].Interface().(int)))}
})Llamada a métodos por nombre
Obtenga un método por nombre y llámelo:
v := reflect.ValueOf(myObj)
m := v.MethodByName("Process")
if m.IsValid() {
m.Call(nil)
}Comprobación de la existencia de un método
Compruebe siempre m.IsValid() antes de llamar; MethodByName devuelve el Value cero si no encuentra el método, y llamar al Value cero provoca un pánico.
Casos de uso del despacho dinámico
Las llamadas dinámicas a funciones se utilizan en sistemas de plugins (llamar a funciones por nombre de cadena), frameworks de pruebas (llamar a funciones TestXxx), despachadores RPC (asignar nombres de métodos a handlers) y decoradores.
Rendimiento
reflect.Call es aproximadamente entre 10 y 50 veces más lento que una llamada directa. Almacene en caché el reflect.Value de las funciones llamadas con frecuencia y evítelo en bucles críticos.
Wrapper con seguridad de tipos
Envuelva las llamadas dinámicas en un helper tipado que realice una vez la lógica de reflect durante el arranque y llame repetidamente al Value almacenado en caché:
type Processor func(context.Context, []byte) ([]byte, error)
// Build at startup, reuse at request timeGestión del valor de error devuelto
Si la función devuelve un error como último resultado, extráigalo y compruébelo:
results := fn.Call(args)
if !results[len(results)-1].IsNil() {
return results[len(results)-1].Interface().(error)
}Alternativas a la reflexión
Si el conjunto de funciones se conoce en tiempo de compilación, utilice un mapa de valores de función (map[string]func(...)) en lugar de reflexión: es más seguro y rápido.
handlers := map[string]func(ctx context.Context, req []byte) []byte{
"greet": greetHandler,
}Comprobación rápida
¿Qué devuelve reflect.Value.Call?
Resumen: llamadas dinámicas a funciones
Puntos clave:
- Value.Call([]reflect.Value) invoca la función y devuelve []reflect.Value
- Compruebe m.IsValid() antes de llamar al resultado de MethodByName
- MakeFunc crea una función nueva con un tipo determinado en tiempo de ejecución
- Prefiera map[string]func a la reflexión cuando el conjunto de funciones sea conocido
Preguntas frecuentes
¿La lección «Llamadas dinámicas a funciones» es gratis?
Sí — el texto completo de «Llamadas dinámicas a funciones» 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 «Llamadas dinámicas a funciones»?
Llamada a funciones y asignación de valores mediante reflect 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 «Llamadas dinámicas a funciones»?
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
- reflect.Type y reflect.Value
- Inspección de campos y etiquetas de structs
- Llamadas dinámicas a funciones
- Reflection práctica: serializadores