How to Retrieve the Value Address of Non-Pointer Fields Using Reflection in Go?

Retrieving Value Address Using Reflection

Reflecting on an interface enables one to traverse its fields. However, obtaining the address of a non-pointer field presents a challenge. This article addresses this issue by examining the limitations of pointer dereferencing and introduces a solution.

Problem Overview

Consider the following code:

<code class="go">type Z struct {
    Id int
}

type V struct {
    Id int
    F Z
}

type T struct {
    Id int
    F V
}</code>

The function InspectStruct recursively traverses a structure and lists its field details, including the address. Here's a simplified implementation:

<code class="go">func InspectStruct(o interface{}) {
    val := reflect.ValueOf(o)

    if val.Kind() == reflect.Interface && !val.IsNil() {
        val = val.Elem()
    }
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }

    for i := 0; i < val.NumField(); i++ {
        valueField := val.Field(i)

        if valueField.Kind() == reflect.Ptr {
            valueField = valueField.Elem()
        }

        address := "not-addressable"
        if valueField.CanAddr() {
            address = fmt.Sprint(valueField.Addr().Pointer())
        }

        fmt.Printf("Field Name: %s,\t Field Value: %v,\t Address: %v\n", val.Type().Field(i).Name, valueField.Interface(), address)

        if valueField.Kind() == reflect.Struct {
            InspectStruct(valueField.Interface())
        }
    }
}</code>

Running this function on an instance of type T yields:

Field Name: Id,  Field Value: 1,     Address: 408125440
Field Name: F,   Field Value: {2 {3}},   Address: 408125444 
Field Name: Id,  Field Value: 2,     Address: not-addressable
Field Name: F,   Field Value: {3},   Address: not-addressable
Field Name: Id,  Field Value: 3,     Address: not-addressable

As you can observe, the addresses of non-pointer fields ("Id" and "F" of type "Z" and "V") are not accessible.

Solution

The issue stems from dereferencing the value obtained from valueField.Interface(). This returns an interface{} which, when used in a field value, may result in losing the address information.

Here's a modified solution that addresses this:

<code class="go">func InspectStructV(val reflect.Value) {
    if val.Kind() == reflect.Interface && !val.IsNil() {
        val = val.Elem()
    }
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }

    for i := 0; i < val.NumField(); i++ {
        valueField := val.Field(i)

        if valueField.Kind() == reflect.Ptr {
            valueField = valueField.Elem()
        }

        address := "not-addressable"
        if valueField.CanAddr() {
            address = fmt.Sprintf("0x%X", valueField.Addr().Pointer())
        }

        fmt.Printf("Field Name: %s,\t Field Value: %v,\t Address: %v\n", val.Type().Field(i).Name, valueField.Interface(), address)

        if valueField.Kind() == reflect.Struct {
            InspectStructV(valueField)
        }
    }
}

func InspectStruct(v interface{}) {
    InspectStructV(reflect.ValueOf(v))
}</code>

By passing a reflect.Value instead of an interface{} to InspectStructV, the address of the field can be correctly obtained.

Conclusion

When traversing non-pointer fields in a structure using reflection, it's crucial to preserve the reflect.Value instead of relying on valueField.Interface(). By passing reflect.Value to the recursive InspectStructV function, you can successfully retrieve the addresses of fields at any depth in the structure.

The above is the detailed content of How to Retrieve the Value Address of Non-Pointer Fields Using Reflection in Go?. For more information, please follow other related articles on the PHP Chinese website!