Anatomy of Go reflection: understanding its principles and usage

Introduction: The reflection function of the Go language allows developers to inspect and modify the code structure at runtime, and obtain type and value metadata through the built-in interface. Principle: Based on the built-in interfaces reflect.Type (type metadata), reflect.Value (value metadata) and reflect.Kind (basic type name enumeration). Usage: Check type, modify value. Practical example: Create a custom type and use reflection to generate JSON output.

Analysis of Go reflection: understanding its principles and usage

Introduction

Reflection It is an advanced feature of programming languages ​​that allows applications to inspect and modify the structure of their own code at runtime. The reflection support in the Go language is very powerful, allowing developers to go deep into the application and dynamically perform type checking, value modification, and code generation.

Principle

Go reflection is based on a set of built-in interfaces:

• reflect.Type: represents Go Type metadata.
• reflect.Value: Metadata representing a Go value, including its type and underlying value.
• reflect.Kind: An enumeration type that defines the names of various basic types.

By using these interfaces, you can obtain various information about Go types and values, such as type names, field names, and method signatures.

Usage

Checking the type

The following code shows how to check the http.Request type Field:

import (
    "fmt"
    "reflect"

    "net/http"
)

func main() {
    req := http.Request{}
    t := reflect.TypeOf(req)
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fmt.Printf("%s: %s\n", field.Name, field.Type)
    }
}

Modify value

Reflection can also modify Go values. The following code shows how to modify the URL field in http.Request:

import (
    "net/http"
    "reflect"
)

func main() {
    req := http.Request{}

    // 获取 URL 字段的 reflect.Value
    field := reflect.ValueOf(&req).Elem().FieldByName("URL")

    // 检查 URL 字段是否可设置
    if field.CanSet() {
        // 动态设置 URL 字段
        newURL := &http.URL{Host: "example.com"}
        field.Set(reflect.ValueOf(newURL))
    }
}

Practical case

In the following practical case, we use reflection to create a custom type and use it to generate JSON output:

import (
    "encoding/json"
    "fmt"
    "reflect"
)

// 自定义类型
type Person struct {
    Name string
    Age  int
}

func main() {
    // 反射获取 Person 类型
    personType := reflect.TypeOf(Person{})

    // 创建 Person 值
    person := Person{"John", 30}

    // 创建 Person 值的 Value 对象
    personValue := reflect.ValueOf(person)

    // 构建 JSON 输出
    jsonOutput := fmt.Sprintf(`{"name": "%s", "age": %d}`,
        personValue.FieldByName("Name").String(),
        personValue.FieldByName("Age").Int(),
    )

    // 输出 JSON
    fmt.Println(jsonOutput)
}

The above is the detailed content of Anatomy of Go reflection: understanding its principles and usage. For more information, please follow other related articles on the PHP Chinese website!