El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Reflexión

Siguiente ►
►

La reflexión en Go es una poderosa característica que permite a los programas inspeccionar y manipular objetos en tiempo de ejecución. Esto es particularmente útil para tareas como la serialización, la validación de datos y la creación de frameworks. En este módulo, exploraremos los conceptos básicos de la reflexión, cómo usar el paquete reflect y algunos ejemplos prácticos.

Contenido

  1. ¿Qué es la reflexión?
  2. El paquete reflect
  3. Inspección de tipos
  4. Manipulación de valores
  5. Ejemplos prácticos
  6. Ejercicios

  1. ¿Qué es la reflexión?

La reflexión es la capacidad de un programa para examinar su propia estructura, especialmente los tipos. En Go, esto se logra mediante el paquete reflect, que permite inspeccionar y modificar los valores y tipos en tiempo de ejecución.

  1. El paquete reflect

El paquete reflect es la base de la reflexión en Go. Proporciona varias funciones y tipos que permiten trabajar con la reflexión. Los dos tipos más importantes en este paquete son reflect.Type y reflect.Value.

  • reflect.Type: Representa el tipo de un valor.
  • reflect.Value: Representa el valor en sí mismo.

  1. Inspección de tipos

Para inspeccionar el tipo de un valor, utilizamos la función reflect.TypeOf. Aquí hay un ejemplo:

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    fmt.Println("type:", reflect.TypeOf(x))
}

Explicación

  • reflect.TypeOf(x): Devuelve el tipo del valor x, en este caso float64.

  1. Manipulación de valores

Para manipular valores, utilizamos la función reflect.ValueOf. Aquí hay un ejemplo:

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(x)
    fmt.Println("value:", v)
    fmt.Println("type:", v.Type())
    fmt.Println("kind:", v.Kind())
    fmt.Println("float value:", v.Float())
}

Explicación

  • reflect.ValueOf(x): Devuelve un reflect.Value que contiene el valor de x.
  • v.Type(): Devuelve el tipo del valor.
  • v.Kind(): Devuelve el "kind" del valor, que es una categoría más general que el tipo (por ejemplo, float64 es de kind float).
  • v.Float(): Devuelve el valor como un float64.

  1. Ejemplos prácticos

Ejemplo 1: Modificación de un valor

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    p := reflect.ValueOf(&x)
    v := p.Elem()
    v.SetFloat(7.1)
    fmt.Println(x)
}

Explicación

  • reflect.ValueOf(&x): Obtenemos un reflect.Value que contiene un puntero a x.
  • p.Elem(): Obtenemos el valor al que apunta el puntero.
  • v.SetFloat(7.1): Modificamos el valor a 7.1.

Ejemplo 2: Iteración sobre los campos de una struct

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{"Alice", 30}
    v := reflect.ValueOf(p)
    for i := 0; i < v.NumField(); i++ {
        fmt.Printf("Field %d: %v\n", i, v.Field(i))
    }
}

Explicación

  • reflect.ValueOf(p): Obtenemos un reflect.Value que contiene la struct p.
  • v.NumField(): Devuelve el número de campos en la struct.
  • v.Field(i): Devuelve el valor del campo i.

  1. Ejercicios

Ejercicio 1: Inspección de tipos

Escribe un programa que tome una variable de cualquier tipo y use la reflexión para imprimir su tipo y valor.

Ejercicio 2: Modificación de valores

Escribe un programa que tome un puntero a una variable de tipo int y use la reflexión para modificar su valor.

Ejercicio 3: Iteración sobre una struct

Escribe un programa que tome una struct con al menos tres campos de diferentes tipos y use la reflexión para imprimir los nombres y valores de sus campos.

Soluciones

Solución 1: Inspección de tipos

package main

import (
    "fmt"
    "reflect"
)

func inspectTypeAndValue(x interface{}) {
    v := reflect.ValueOf(x)
    fmt.Println("Type:", v.Type())
    fmt.Println("Value:", v)
}

func main() {
    var x float64 = 3.4
    inspectTypeAndValue(x)
}

Solución 2: Modificación de valores

package main

import (
    "fmt"
    "reflect"
)

func modifyValue(x interface{}) {
    p := reflect.ValueOf(x)
    if p.Kind() == reflect.Ptr && !p.Elem().CanSet() {
        fmt.Println("Cannot set value")
        return
    }
    v := p.Elem()
    if v.Kind() == reflect.Int {
        v.SetInt(42)
    }
}

func main() {
    var x int = 10
    modifyValue(&x)
    fmt.Println(x)
}

Solución 3: Iteración sobre una struct

package main

import (
    "fmt"
    "reflect"
)

type Example struct {
    Name  string
    Age   int
    Score float64
}

func printStructFields(s interface{}) {
    v := reflect.ValueOf(s)
    t := v.Type()
    for i := 0; i < v.NumField(); i++ {
        fmt.Printf("Field %s: %v\n", t.Field(i).Name, v.Field(i))
    }
}

func main() {
    e := Example{"Alice", 30, 95.5}
    printStructFields(e)
}

Conclusión

En este módulo, hemos explorado la reflexión en Go, aprendiendo a inspeccionar y manipular tipos y valores en tiempo de ejecución utilizando el paquete reflect. La reflexión es una herramienta poderosa que puede ser utilizada para una variedad de tareas avanzadas en programación. Con los ejemplos y ejercicios proporcionados, deberías tener una buena comprensión de cómo aplicar la reflexión en tus propios proyectos.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados