通过reflect为任意类型指针字段设值遇赋值错误，求解决方案

我有一个包含任意类型字段的不完整结构体，需要用另一个更新结构体补全其中所有为nil的指针字段。我写了两段Go代码尝试实现，但都失败了：

• 第一种尝试报错：reflect.Value.Set using unaddressable value
• 第二种尝试参考Stack Overflow方案，报错：value of type *interface {} is not assignable to type *string，尝试类型转换也会触发panic

请指点如何正确完成赋值或类型转换。

原代码 #

func main() {
    var incomplete any = struct {
        ID      string
        Name    *string
        Address *string
    }{
        ID:      "Some ID",
        Name:    toPtr("some Name"),
        Address: nil,
    }

    var update any = struct {
        Name    *string
        Address *string
    }{
        Name:    toPtr("Other name which won't be applied"),
        Address: toPtr("my/location"),
    }

    existingV := reflect.ValueOf(incomplete)
    existingT := reflect.TypeOf(incomplete)
    for i := 0; i < existingV.NumField(); i++ {
        existingField := existingV.Field(i)
        if existingField.IsValid() {
            if existingField.Kind() == reflect.Ptr {
                if existingField.IsNil() {
                    existingFieldT := existingT.Field(i)
                    newValue := getUpdatedField(update, existingFieldT.Name, existingFieldT.Type)

                    // Attempt 1: will fail with reflect.Value.Set using unaddressable value                
                    // reflect.ValueOf(incomplete).FieldByName(existingFieldT.Name).Set(reflect.ValueOf(newValuePtr))

                    // Attempt 2: reflect.Set: value of type *interface {} is not assignable to type *string
                    v := reflect.ValueOf(&incomplete).Elem()
                    tmp := reflect.New(v.Elem().Type()).Elem()
                    tmp.Set(v.Elem())
                    byName := tmp.FieldByName(existingFieldT.Name)
                    newValuePtr := &newValue
                    newReflectValue := reflect.ValueOf(newValuePtr)
                    // newReflectValueConv := newReflectValue.Convert(byName.Type()) // panic
                    byName.Set(newReflectValue) // panic 
                    v.Set(tmp)
                }
            }
        }
    }
}

// for the sake of completeness, probably not relevant
func getUpdatedField(updatedData any, fieldName string, fieldType reflect.Type) (value any) {
    updatedT := reflect.TypeOf(updatedData)
    for i := 0; i < updatedT.NumField(); i++ {
        if updatedT.Field(i).Name == fieldName {
            v := reflect.Indirect(reflect.ValueOf(updatedData)).Field(i)
            if fieldType == updatedT.Field(i).Type && v.CanInterface() {
                return v.Interface()
            } else {
                return nil
            }
        }
    }
    return nil
}

func toPtr(str string) *string {
    return &str
}

错误原因分析 #

1. 第一个错误：reflect.ValueOf(incomplete)返回的是值类型的反射值，不可寻址。因为incomplete是存储在any中的结构体值，不是指针，直接操作它的字段无法修改原数据，且反射值不支持Set操作。
2. 第二个错误：newValue是any类型，&newValue得到的是*any指针，但目标字段类型是*string，类型不匹配。直接取any变量的地址无法转换成目标指针类型，导致赋值失败。

正确实现方案 #

核心要点：

• 确保操作的是可寻址的反射值：需要将原结构体以指针形式传入反射，或者把incomplete包装成指针后再处理。
• 直接使用更新字段的原始反射值：getUpdatedField返回的已经是目标类型的指针（比如*string），不需要再取地址，直接转换成反射值即可赋值。

修正后的完整代码 #

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 将原结构体改为指针类型，确保反射时可寻址
    var incomplete any = &struct {
        ID      string
        Name    *string
        Address *string
    }{
        ID:      "Some ID",
        Name:    toPtr("some Name"),
        Address: nil,
    }

    var update any = struct {
        Name    *string
        Address *string
    }{
        Name:    toPtr("Other name which won't be applied"),
        Address: toPtr("my/location"),
    }

    // 获取原结构体的指针反射值，并解引用到结构体值
    existingV := reflect.ValueOf(incomplete).Elem()
    existingT := existingV.Type()

    for i := 0; i < existingV.NumField(); i++ {
        existingField := existingV.Field(i)
        // 只处理nil的指针字段
        if existingField.IsValid() && existingField.Kind() == reflect.Ptr && existingField.IsNil() {
            fieldMeta := existingT.Field(i)
            newValue := getUpdatedField(update, fieldMeta.Name, fieldMeta.Type)

            // 找到匹配的更新值则赋值
            if newValue != nil {
                existingField.Set(reflect.ValueOf(newValue))
            }
        }
    }

    // 打印结果验证
    fmt.Printf("%+v\n", incomplete)
}

func getUpdatedField(updatedData any, fieldName string, fieldType reflect.Type) any {
    updatedV := reflect.ValueOf(updatedData)
    // 如果更新数据是指针，先解引用
    if updatedV.Kind() == reflect.Ptr {
        updatedV = updatedV.Elem()
    }
    updatedT := updatedV.Type()

    for i := 0; i < updatedT.NumField(); i++ {
        field := updatedT.Field(i)
        if field.Name == fieldName && field.Type == fieldType {
            fieldV := updatedV.Field(i)
            if fieldV.CanInterface() {
                return fieldV.Interface()
            }
        }
    }
    return nil
}

func toPtr(str string) *string {
    return &str
}

关键修正点说明 #

1. 原结构体改为指针：将incomplete定义为结构体指针，这样reflect.ValueOf(incomplete).Elem()得到的是可寻址的结构体反射值，支持Set操作。
2. 直接使用newValue赋值：getUpdatedField返回的已经是匹配类型的指针（比如*string），所以reflect.ValueOf(newValue)得到的反射值类型与目标字段完全一致，直接调用Set即可完成赋值。
3. 优化getUpdatedField：增加对更新数据是指针的处理，确保能正确获取字段值。

内容的提问来源于stack exchange，提问作者NotX