What is the usage of golang reflect

Golang is a popular programming language that is efficient, concise and reliable. It has a built-in reflection mechanism that allows the code to receive information about the object structure at runtime. This reflection mechanism makes using Golang more convenient.

The reflection mechanism refers to an information mechanism that can dynamically operate objects while the program is running. Using reflection, a program can obtain runtime information, including object values, types, and methods, without the programmer having to explicitly tell the program this information. This information can be used to parse data, deserialize objects, inject dependencies, and implement program processing mechanisms such as ORM, DI, and AOP.

The reflection package of Go language is implemented in reflect. It contains two main types: Type and Value. Type stores information about the data type, and Value stores information about the data value. The main steps in using the reflect package include defining types, creating values ​​and manipulating those values ​​using reflection methods.

Define type: In Go language, the keyword for defining type is type. If you need to nest or process types, you can use struct.

Create a value: In the Go language, the keyword for creating a value is make. When using the reflection mechanism, you need to use the interface{} type to pass any type of value. This type can be converted to any type. After receiving this type, use reflect.ValueOf(v) to convert it to a reflectable value.

Use reflection methods to operate these values: In Go language, you can use reflection methods to obtain value information, modify values, obtain structure fields, and other operations. Through the reflection method, data can be dynamically modified to enhance the scalability of applications.

Next let’s take a look at some specific examples:

1. Get/modify the value

You can use reflect.ValueOf(v) to get a value object. This value object represents the actual value and type information. You can use some methods to operate on this object, such as get and set.

package main

import (

"fmt"
"reflect"

)

func main() {

i := 1
iv := reflect.ValueOf(i)
fmt.Printf("%#v\n", iv)

iv.SetInt(2)
fmt.Printf("%#v\n", iv)
fmt.Println(i)

}

Output ：

reflect.ValueOf(1)
reflect.ValueOf(2)
2

2. Get/modify structure fields

A structure is a data type that consists of multiple fields. The reflection mechanism can obtain and modify the fields of the structure, thereby enhancing the flexibility of the application.

package main

import (

"fmt"
"reflect"

)

type person struct {

Name string
Age  int

}

func main () {

p := person{Name: "Alice", Age: 18}

st := reflect.ValueOf(&p).Elem()
f1 := st.FieldByName("Name")
f2 := st.FieldByName("Age")

fmt.Printf("field1: %#v, field2: %#v\n", f1, f2)

f1.SetString("Bob")
f2.SetInt(20)

fmt.Println(p)

}

Output:

field1: reflect.Value{typ:reflect.TypeOf(""), ptr:(uint8)( 0x10d7f19)}, field2: reflect.Value{typ:reflect.TypeOf(0), ptr:(int)(0x10d7f2c)}
{Bob 20}

3. Dynamic calling method

In Go language, structures can be accessed through methods. Through the reflection mechanism, we can dynamically call methods at runtime.

package main

import (

"fmt"
"reflect"

)

type Printer struct {
}

func (p Printer) Print (s string) {

fmt.Println(s)

}

func main() {

p := Printer{}

method := reflect.ValueOf(p).MethodByName("Print")
args := []reflect.Value{reflect.ValueOf("Hello World")}
method.Call(args)

}

Output:

Hello World

Summary

This article briefly introduces the usage of Golang's reflection mechanism, covering common operations such as obtaining/modifying values, obtaining/modifying structure fields and dynamically calling methods. The reflection mechanism makes applications more flexible, scalable and reliable. However, when using the reflection mechanism, issues such as performance and type conversion need to be carefully handled so as not to affect the efficiency and maintainability of the application.

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