golang reflection method

1. The concept of reflection

In programming, reflection refers to the ability to obtain program structure information at runtime. A simple explanation is that the program can check its own status, properties and methods at runtime without having to determine all this information at compile time. Reflection allows Go language programs to have flexibility and capabilities similar to other dynamic languages.

In the Go language, to implement reflection, you can use the reflect package, which provides a large amount of meta-information about types and values, which can be used dynamically when the program is running.

2. Application of reflection

Reflection has a wide range of application scenarios in the Go language. For example:

1. When writing a general function, it is difficult to predict the specific type of the incoming parameters, so you can use reflection to dynamically obtain the information of the incoming parameters.

2. When writing an ORM framework, you can automatically map objects to tables in the database, or you can query data from the database and use reflection to automatically map to corresponding objects.

3. Many frameworks and tools use reflection to read configuration files or parse command parameters.

3. Types of reflection

In Go language, there are two main types of reflection:

1.Type

Type is the type information , which represents a type in Go, which can be a basic data type, structure, function, pointer, array, slice, interface, etc.

2.Value

Value represents a value, which can be any type of value. It wraps the data value and type information of an instance, and provides a series of operation instances. method.

4. Basic operations of reflection

1. Obtain type information

Use the reflect.TypeOf() function to obtain the type information of any value. The syntax is as follows:

func TypeOf(i interface{}) Type

For example, we want to get the type information of the "hello" string:

t := reflect.TypeOf("hello")
fmt.Println(t.Kind())  // 输出：string

2. Get the value information

Use the reflect.ValueOf() function to get the value information of any value , the syntax is as follows:

func ValueOf(i interface{}) Value

For example, we want to get the value information of the "hello" string variable:

value := reflect.ValueOf("hello")
fmt.Println(value.String()) // 输出：hello

3. Get the type and value information of the variable

If you want To obtain the type and value information of variables at the same time, you can use the reflect.TypeOf() and reflect.ValueOf() methods together, as follows:

var age int = 22
t := reflect.TypeOf(age)                // 变量类型信息
v := reflect.ValueOf(age)               // 变量值信息
fmt.Println(t.Kind(), v.Int())          // 输出：int 22

4. Set the value of the variable through reflection

Use Reflection can dynamically modify the value of a variable. You need to use the Value type method Set() in the reflect package. The syntax is as follows:

func (v Value) Set(x Value)

Among them, the type of the x parameter should be consistent with the type of v, otherwise an error will be reported.

For example, we change the value of the age variable to 33:

v := reflect.ValueOf(&age)
v.Elem().SetInt(33)
fmt.Println(age)                     // 输出：33

5. Modify the value of the structure members through reflection

Use reflection to dynamically modify the structure members For values, you need to use the Value type in the reflect package and the method FieldByName() in the Type type. The syntax is as follows:

func (v Value) FieldByName(name string) Value

For example, we define a Person structure and modify the values ​​of its members name and age:

type Person struct {
    name string
    age  int
}

func main() {
    p := Person{name: "Mike", age: 22}
    v := reflect.ValueOf(&p).Elem()
    v.FieldByName("name").SetString("Tom")
    v.FieldByName("age").SetInt(33)
    fmt.Println(p)                         // 输出：{Tom 33}
}

6. Calling functions through reflection

Using reflection to dynamically call functions, you need to use the Value type in the reflect package and the method Call() in the Type type. The syntax is as follows:

func (v Value) Call(args []Value) []Value

Among them, the args parameter is the input parameter of the function, and the return value is the output parameter of the function.

For example, we define an Add function and call the Add function through reflection:

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

func main() {
    var params []reflect.Value
    params = append(params, reflect.ValueOf(1))
    params = append(params, reflect.ValueOf(2))
    result := reflect.ValueOf(Add).Call(params)
    fmt.Println(result[0].Int())           // 输出：3
}

The above are the basic operations of reflection in the Go language. Reflection gives the Go language more powerful capabilities and Flexibility, we can also flexibly use reflection to implement some functions during development.

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