goLanguage Reflection: Three Laws to Help You Understand the Essence of Reflection

Three laws of Go language reflection: Everything is a value: Values ​​of all types can be stored in interface{}. Types are static: the type information obtained does not change once it is determined. Value is dynamic: a reflected Value represents a specific instance and its value can be accessed and modified.

Go Language reflection: The three laws help you understand the essence of reflection

Go Language reflection is a powerful mechanism that allows We obtain and manipulate runtime type information. Understanding the Three Laws of Reflection is crucial as it helps us grasp their essence.

First Law: Everything has a value

In Go, all types of values ​​can be stored in the interface{} type. Reflection implements the underlying mechanism of this type. This means we can use the reflect package to manipulate instances of any type.

For example:

type User struct {
    Name string
    Age  int
}

func PrintUserInfo(u interface{}) {
    v := reflect.ValueOf(u)
    fmt.Println(v.Type())
    fmt.Println(v.NumField())
    for i := 0; i < v.NumField(); i++ {
        fmt.Printf("%s: %v\n", v.Type().Field(i).Name, v.Field(i).Interface())
    }
}

Second Law: Type is static

Reflection operations are performed on specific type values. In other words, once we obtain the reflection information for a type, it will no longer change. This ensures stable reflection operation.

For example:

type Point struct {
    X, Y int
}

func main() {
    pt := &Point{1, 2}
    t := reflect.TypeOf(pt)
    fmt.Println(t.Name()) // 输出: Point
}

The third law: Value is dynamic

Reflection Value Represents an instance of a specific type. Not only can it access type information, but it can also modify the instance's value.

For example:

type User struct {
    Name string
    Age  int
}

func main() {
    u := &User{Name: "Alice", Age: 25}
    v := reflect.ValueOf(u)
    // 修改字段值
    v.Elem().FieldByName("Name").SetString("Bob")
    fmt.Println(u.Name) // 输出: Bob
}

Practical case: type checking and field extraction

Common use cases for reflection include type checking and extracting field values ​​from unknown types .

// 类型检查
func IsUser(v interface{}) bool {
    return reflect.TypeOf(v).Name() == "User"
}

// 字段提取
func GetFieldName(v interface{}) string {
    return reflect.TypeOf(v).Field(0).Name
}

By understanding the three laws of reflection, you can master the essence of Go language reflection and make full use of its powerful features.

The above is the detailed content of goLanguage Reflection: Three Laws to Help You Understand the Essence of Reflection. For more information, please follow other related articles on the PHP Chinese website!