Clever use of reflection in Go language

Go language reflection is an introspection mechanism, implemented through the reflect package, that allows a program to inspect and modify its own structures, fields, and methods. Using reflection, you can obtain reflection objects of types and values, inspect types, access and modify fields, and call methods. One practical application is to use reflection to perform unified operations on different types that implement a specific interface, such as the Number interface in the summation example.

Reflection in Go language: clever use

Reflection is an introspection mechanism that allows a program to inspect and modify itself structure, fields and methods. In the Go language, reflection is implemented through the reflect package.

Basic usage

The basis of reflection is the type reflect.Type and the value reflect.Value. reflect.Type represents a Go type, while reflect.Value represents a specific value. To get the reflect.Type of a type, you can use the reflect.TypeOf() function:

type Person struct {
    Name string
    Age  int
}

p := Person{"John", 30}
typ := reflect.TypeOf(p)

To get the reflect.Value## of a value #, you can use reflect.ValueOf() Function:

v := reflect.ValueOf(p)

Check the type

Using reflection, we can check the type of the value:

fmt.Println(typ.Name()) // 输出: Person
fmt.Println(v.Kind()) // 输出: struct

Access fields

You can use the

reflect.Value.Field() method to access the fields of the structure. This method returns a reflect.Value, indicating the value of the field:

nameField := v.FieldByName("Name")
fmt.Println(nameField.String()) // 输出: John

Modify the field

through

reflect.Value.Set( ) method, you can also modify the fields of the structure:

nameField.SetString("Alice")
fmt.Println(p.Name) // 输出: Alice

Method call

Reflection also allows calling methods. Use the

reflect.Value.Method() method to get a method object, and then use the reflect.Method.Call() method to call it:

ageMethod := v.MethodByName("GetAge")
result := ageMethod.Call([]reflect.Value{})
fmt.Println(result[0].Int()) // 输出: 30

Practical combat Case

The following is an actual case using reflection:

type Number interface {
    Int() int
}

func Sum(numbers []Number) int {
    total := 0
    v := reflect.ValueOf(numbers)
    for i := 0; i < v.Len(); i++ {
        total += v.Index(i).MethodByName("Int").Call([]reflect.Value{})[0].Int()
    }
    return total
}

type IntNumber int

func (n IntNumber) Int() int {
    return int(n)
}

type FloatNumber float64

func (n FloatNumber) Int() int {
    return int(n)
}

func main() {
    numbers := []Number{IntNumber(4), FloatNumber(5.3), IntNumber(6)}
    fmt.Println(Sum(numbers)) // 输出: 15
}

In this case, we define a

Number interface and some types that implement it. The Sum() function uses reflection to call the Int() method on all values ​​of type Number in the slice, and sums the results.

The above is the detailed content of Clever use of reflection in Go language. For more information, please follow other related articles on the PHP Chinese website!