Several key points need to be mastered when using Golang's reflect package for reflection operation. 1. Understand reflect.Kind and reflect.Type. Kind() returns the underlying type types such as int, string, etc. TypeOf().Name() gets the complete type name. 2. To obtain and modify the value of the variable, use reflect.Value, pass in a pointer and call Elem() to ensure writability, and use SetFloat() and other methods to modify the value. 3. When traversing the structure field, the number of fields is obtained through NumField(), Field(i) obtains the field value, and the field name is obtained through Type().Field(i).Name and must be exportable. 4. Dynamically create objects with reflect.New(), methodByName() is required to call the method and check the validity, and parameters and return values must be processed as reflect.Value. 5. Pay attention to the high performance overhead when using reflection to avoid high-frequency loops; type mismatch will cause panic; embedded anonymous fields need to be manually expanded; empty interfaces may cause errors, so you should first judge the validity. It is recommended to use type assertions first, encapsulate common reflection operations, and print information during the debugging phase to troubleshoot problems.

Using Golang's reflect package for reflection is a link that many developers cannot avoid when writing general code. Although it looks a bit complicated, after mastering a few key points, you can flexibly deal with the dynamic processing of structures and interface values.

Understand reflect.Kind and reflect.Type

When you get a variable's reflect.Type or reflect.Value , the first step is usually to determine its type (Kind). For example, a variable may be int , string , struct , slice , etc.

 t := reflect.TypeOf(42)
fmt.Println(t.Kind()) // int

Note: Kind() returns the underlying type type, not the complete type name. For example, for custom types:

 type MyInt int
var a MyInt
fmt.Println(reflect.TypeOf(a).Kind()) // int

If you need complete type information, use TypeOf().Name() or combine it with the package path to identify it.

Common uses:

• Determine whether it is a pointer ( reflect.Ptr )
• Is it a structure ( reflect.Struct )
• Whether it is a slice or a map ( reflect.Slice , reflect.Map )

Get and modify the value of the variable: reflect.Value

If you want to read or modify the value of a variable through reflection, you need to use reflect.Value . for example:

 x := 3.14
v := reflect.ValueOf(&x).Elem()
v.SetFloat(2.71)
fmt.Println(x) // Output 2.71

Note here:

• If you pass in a non-pointer variable, the value you get is not writable ( CanSet() returns false)
• Make sure the type matches before modifying, otherwise it will be panic.
• Use .Interface() to turn the reflected value back to an empty interface

Some practical operations:

• Traversing the structure field: value.NumField()
• Get field name and value: value.Type().Field(i).Name , value.Field(i)
• Before setting the field value, make sure the field is exportable (first letter capitalization)

Dynamically create objects and call methods

Reflection is not limited to viewing data, it can also dynamically create objects, call functions or methods.

For example, you want to create an instance based on the type:

 t := reflect.TypeOf(time.Time{})
newInstance := reflect.New(t).Interface().(*time.Time)

Calling methods are also very common, such as automatically binding HTTP handler methods:

 method := value.MethodByName("MyMethod")
args := []reflect.Value{reflect.ValueOf(params)}
ret := method.Call(args)

Notes:

• The method being called must be exported (first letter capitalization)
• Both parameters and return values must be handled with reflect.Value type
• If you are not sure whether the method exists, check MethodByName().IsValid() first

Some pitfalls and suggestions in actual use

There are many places where reflections are prone to errors, so pay attention to the following points:

• High performance overhead : Try to avoid using reflection in high-frequency loops
• Type mismatch leads to panic : For example, use Int() to get the value of a string
• Processing of embedded fields in structure : Anonymous fields will not be automatically expanded during traversal, and manual judgment is required
• The problem of empty interface value : errors may be caused when reflecting the empty interface, remember to judge the validity first

Recommended practices:

• Try to replace reflection with type assertions unless general logic is really needed
• Write tool function encapsulate common reflection operations to reduce duplicate code
• Print type and value information during the debugging phase, which helps troubleshoot problems

Basically that's all. Golang's reflect package is powerful, but it is also easy to misuse. As long as you clarify the relationship between Type/Value and master common judgments and operation methods, it will not be too difficult to use in daily life.

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