Use reflect.TypeOf() and reflect.ValueOf() to get the type and value of the variable, where ValueOf returns a copy; 2. You can traverse the structure fields through reflection to obtain the field name, type and label information; 3. To modify the value, you need to pass a pointer and call Elem() to get the addressable value, and you need to check CanSet(); 4. You can traverse the structure fields and set a new value according to the type; 5. Get the method through MethodByName() and call it with Call(); 6. You can determine whether the type implements a specific method or interface; the reflection performance is low, so you should avoid using a hot path. When modifying the value, you must pass a pointer. The field that has not been exported cannot be modified. Type judgment is preferred to use Kind(). This mechanism is very practical in JSON serialization, ORM and configuration parsing.

In Go, reflection is a powerful mechanism that allows programs to check the types and values of variables at runtime, and even modify them. Go's reflect package provides the main functions to implement reflection. Here are a few common examples to illustrate how to use Go's reflection.

1. Reflection of basic types and values

Use reflect.TypeOf() and reflect.ValueOf() to get the type and value of a variable.

 package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x int = 42

    t := reflect.TypeOf(x) // Type information v := reflect.ValueOf(x) // Value information fmt.Println("Type:", t) // int
    fmt.Println("Value:", v) // 42
    fmt.Println("Kind:", v.Kind()) // int
}

Note: reflect.ValueOf(x) returns a copy of x , not a reference.

2. Get structure field information

Reflection is often used to process structures, such as obtaining field names, types, labels, etc.

 type User struct {
    Name string `json:"name"`
    Age int `json:"age"`
}

func main() {
    var u User
    t := reflect.TypeOf(u)

    for i := 0; i < t.NumField(); i {
        field := t.Field(i)
        fmt.Printf("Field name: %s, Type: %s, JSON tag: %s\n",
            field.Name, field.Type, field.Tag.Get("json"))
    }
}

Output:

 Field name: Name, Type: string, JSON tag: name
Field name: Age, Type: int, JSON Tag: age

3. Modify the value of the variable (need to pass in pointer)

If you want to modify the value through reflection, you must pass in a pointer, otherwise it will be panic.

 func main() {
    var x int = 10
    v := reflect.ValueOf(&x) // Pass in pointer elem := v.Elem() // Get the value pointed to by the pointer if elem.CanSet() {
        elem.SetInt(20)
    }

    fmt.Println(x) // Output: 20
}

elem.CanSet() determines whether the value can be modified (for example, fields that are not exported cannot be set).

4. Traversing and setting structure fields

 type Person struct {
    Name string
    Age int
}

func main() {
    p := Person{Name: "Alice", Age: 0}
    v := reflect.ValueOf(&p).Elem() // Get the modifiable value pointed to by the pointer for i := 0; i < v.NumField(); i {
        field := v.Field(i)
        if field.CanSet() && field.Kind() == reflect.Int {
            field.SetInt(25)
        }
    }

    fmt.Printf("% v\n", p) // {Name:Alice Age:25}
}

5. Calling method (by reflection)

 type Greeter struct{}

func (g Greeter) SayHello(name string) {
    fmt.Println("Hello,", name)
}

func main() {
    g := Greeter{}
    v := reflect.ValueOf(g)

    // Get method method:= v.MethodByName("SayHello")
    if method.IsValid() {
        args := []reflect.Value{reflect.ValueOf("Bob")}
        method.Call(args) // Output: Hello, Bob
    }
}

6. Determine whether the type implements an interface

 type Speaker interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string { return "Woof!" }

func main() {
    d := Dog{}
    t := reflect.TypeOf(d)
    _, ok := t.MethodByName("Speak")
    fmt.Println("Implements the Speak method:", ok) // true

    // Or more accurately determine whether the interface is implemented_, implements := reflect.TypeOf((*Speaker)(nil)).Elem().MethodByName("Speak")
    fmt.Println("Interface defines Speak:", implements)
}

Summary: Common operations for reflection

• reflect.TypeOf(v) → Get type
• reflect.ValueOf(v) → Get the value
• .Kind() → Basic types (such as int , struct , slice , etc.)
• .Elem() → Pointer, interface underlying value
• .Field(i) / .Method(i) → Get field or method
• .SetXXX() → Modify the value (requires addressable)
• .Call() → Call method

Things to note

• The reflection performance is low, so try to avoid using it in the hot path.
• When modifying values with reflection, a pointer must be passed in, otherwise it cannot be modified.
• Note whether the field can be exported (first letter), otherwise CanSet() is false.
• Use Kind() instead of Type() to judge type more, because Kind returns the underlying type.

Basically these common uses. Although Go's reflection is not as flexible as other languages, it is very practical in scenarios such as serialization (such as JSON), ORM, configuration parsing, etc.

The above is the detailed content of go by example reflection. For more information, please follow other related articles on the PHP Chinese website!