El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Reflexió

Següent ►
►

La reflexió és una característica poderosa en Go que permet als programes inspeccionar i manipular objectes en temps d'execució. Aquesta capacitat és especialment útil per a la creació de biblioteques genèriques, frameworks i eines de depuració. En aquest tema, explorarem els conceptes bàsics de la reflexió en Go, com utilitzar-la i alguns exemples pràctics.

Conceptes Bàsics de la Reflexió

Què és la Reflexió?

La reflexió és la capacitat d'un programa per examinar la seva pròpia estructura, especialment els tipus. En Go, la reflexió es basa en el paquet reflect, que proporciona les eines necessàries per treballar amb tipus i valors en temps d'execució.

Paquet reflect

El paquet reflect és el cor de la reflexió en Go. Proporciona funcions i tipus per treballar amb valors i tipus en temps d'execució.

import "reflect"

Tipus Clau en el Paquet reflect

  • reflect.Type: Representa el tipus d'un valor.
  • reflect.Value: Representa el valor d'un objecte.

Utilitzant la Reflexió

Obtenint el Tipus d'un Valor

Per obtenir el tipus d'un valor en temps d'execució, utilitzem la funció reflect.TypeOf.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x int = 42
    t := reflect.TypeOf(x)
    fmt.Println("Type:", t)
}

Obtenint el Valor d'un Objecte

Per obtenir el valor d'un objecte en temps d'execució, utilitzem la funció reflect.ValueOf.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x int = 42
    v := reflect.ValueOf(x)
    fmt.Println("Value:", v)
}

Modificant Valors amb Reflexió

Per modificar un valor utilitzant la reflexió, primer hem de tenir un reflect.Value que sigui adreçable (addressable). Això significa que hem de passar un punter al valor.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x int = 42
    v := reflect.ValueOf(&x).Elem()
    v.SetInt(100)
    fmt.Println("Modified Value:", x)
}

Exemples Pràctics

Inspeccionant Estructures

Podem utilitzar la reflexió per inspeccionar els camps d'una estructura.

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{"Alice", 30}
    t := reflect.TypeOf(p)
    v := reflect.ValueOf(p)

    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        value := v.Field(i)
        fmt.Printf("%s: %v\n", field.Name, value)
    }
}

Cridant Funcions Dinàmicament

Podem utilitzar la reflexió per cridar funcions dinàmicament.

package main

import (
    "fmt"
    "reflect"
)

func Add(a, b int) int {
    return a + b
}

func main() {
    fn := reflect.ValueOf(Add)
    args := []reflect.Value{reflect.ValueOf(10), reflect.ValueOf(20)}
    result := fn.Call(args)
    fmt.Println("Result:", result[0].Int())
}

Errors Comuns i Consells

Error: "reflect.Value.SetInt using unaddressable value"

Aquest error es produeix quan intentes modificar un valor que no és adreçable. Assegura't de passar un punter al valor que vols modificar.

Consell: Utilitza la Reflexió amb Precaució

La reflexió és una eina poderosa, però també pot ser perillosa si no es fa servir correctament. Pot introduir errors difícils de depurar i pot afectar el rendiment del teu programa. Utilitza-la només quan sigui absolutament necessari.

Exercicis Pràctics

Exercici 1: Inspecciona una Estructura

Crea una funció que prengui qualsevol estructura i imprimeixi els noms i valors dels seus camps.

Exercici 2: Modifica un Valor

Crea una funció que prengui un punter a un enter i el modifiqui a través de la reflexió.

Exercici 3: Crida una Funció Dinàmicament

Crea una funció que prengui una funció i una llista d'arguments, i cridi la funció amb aquests arguments utilitzant la reflexió.

Solucions

Solució a l'Exercici 1

package main

import (
    "fmt"
    "reflect"
)

func PrintStructFields(s interface{}) {
    v := reflect.ValueOf(s)
    t := v.Type()

    for i := 0; i < v.NumField(); i++ {
        fmt.Printf("%s: %v\n", t.Field(i).Name, v.Field(i).Interface())
    }
}

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{"Alice", 30}
    PrintStructFields(p)
}

Solució a l'Exercici 2

package main

import (
    "fmt"
    "reflect"
)

func ModifyValue(x interface{}) {
    v := reflect.ValueOf(x).Elem()
    v.SetInt(100)
}

func main() {
    var x int = 42
    ModifyValue(&x)
    fmt.Println("Modified Value:", x)
}

Solució a l'Exercici 3

package main

import (
    "fmt"
    "reflect"
)

func CallFunction(fn interface{}, args ...interface{}) []reflect.Value {
    fnValue := reflect.ValueOf(fn)
    reflectArgs := make([]reflect.Value, len(args))
    for i, arg := range args {
        reflectArgs[i] = reflect.ValueOf(arg)
    }
    return fnValue.Call(reflectArgs)
}

func Add(a, b int) int {
    return a + b
}

func main() {
    result := CallFunction(Add, 10, 20)
    fmt.Println("Result:", result[0].Int())
}

Conclusió

La reflexió és una característica avançada de Go que permet als programes inspeccionar i manipular objectes en temps d'execució. Tot i que és una eina poderosa, s'ha d'utilitzar amb precaució per evitar errors i problemes de rendiment. Amb els coneixements adquirits en aquest tema, ara estàs preparat per utilitzar la reflexió en els teus projectes de Go.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats