前两天开始学习golang，发现reflect.Valueof()和 Value.Elem()相当困惑。这两个函数/方法有什么区别以及如何正确使用它们？

两个函数/方法都返回一个值，并且根据 go 文档

ValueOf returns a new Value initialized to the concrete value stored in the interface i. ValueOf(nil) returns the zero Value.

Elem returns the value that the interface v contains or that the pointer v points to. It panics if v's Kind is not Interface or Ptr. It returns the zero Value if v is nil.

我从 stackoverflow 上的帖子中找到了这段代码，但仍然不明白何时使用 .Elem()

func SetField(obj interface{}, name string, value interface{}) error {
    
    // won't work if I remove .Elem()
    structValue := reflect.ValueOf(obj).Elem()
    
    structFieldValue := structValue.FieldByName(name)

    if !structFieldValue.IsValid() {
        return fmt.Errorf("No such field: %s in obj", name)
    }

    if !structFieldValue.CanSet() {
        return fmt.Errorf("Cannot set %s field value", name)
    }

    structFieldType := structFieldValue.Type()

    // won't work either if I add .Elem() to the end
    val := reflect.ValueOf(value)
    if structFieldType != val.Type() {

        return fmt.Errorf("Provided value %v type %v didn't match obj field type %v",val,val.Type(),structFieldType)
    }

    structFieldValue.Set(val)
    return nil
}

最佳答案

reflect.ValueOf()是一个函数，将其视为反射的入口点。当您有一个“非反射”值时，例如 string 或 int，您可以使用 reflect.ValueOf() 来获取reflect.Value它的描述符。

Value.Elem()是 reflect.Value 的方法。所以你只能在你已经有一个 reflect.Value 的情况下使用它。您可以使用 Value.Elem() 获取由原始 reflect.Value 包裹的值指向的值 (reflect.Value)。请注意，您也可以使用 reflect.Indirect()为了这。 Value.Elem() 还有另一个“用例”，但它更“高级”，我们在答案的末尾返回。

要“离开”反射，您可以使用一般的 Value.Interface()方法，它以 interface{} 的形式返回包装值。

例如:

var i int = 3
var p *int = &i
fmt.Println(p, i)

v := reflect.ValueOf(p)
fmt.Println(v.Interface()) // This is the p pointer

v2 := v.Elem()
fmt.Println(v2.Interface()) // This is i's value: 3

这将输出(在 Go Playground 上尝试):

0x414020 3
0x414020
3

有关 Go 反射的精彩介绍，请阅读 The Go Blog: The Laws of Reflection .尽管如果你只是开始使用 Go，我会专注于其他事情并为以后的冒险留下反射(reflection)。

Value.Elem() 的另一个用例

这是一个高级主题，所以如果您不理解它，请不要 panic 。你不需要。

我们看到当指针被包裹在 reflect.Value 中时，Value.Elem() 是如何用于“导航”的。 Value.Elem() 的文档说:

Elem returns the value that the interface v contains or that the pointer v points to.

因此，如果 reflect.Value 包装了一个接口(interface)值，Value.Elem() 也可用于获取包装在该接口(interface)值中的具体值。

Go 中的接口(interface)是它自己的主题，对于内部结构，您可以阅读 Go Data Structures: Interfaces拉斯考克斯。同样，不一定是 Go 初学者的主题。

基本上，无论您传递给 reflect.ValueOf() 的任何值，如果它还不是接口(interface)值，它将隐式包装在 interface{} 中。如果传递的值已经是接口(interface)值，则存储在其中的具体值将作为 interface{} 传递。如果您将指针传递给接口(interface)(这在 Go 中非常罕见!)，则第二个“用例”会出现。

因此，如果您将指针传递给接口(interface)，该指针将被包装在 interface{} 值中。您可以使用 Value.Elem() 获取指向的值，这将是一个接口(interface)值(不是具体值)，并使用 Value.Elem() 再次这会给你具体的值(value)。

这个例子说明了这一点:

var r io.Reader = os.Stdin // os.Stdin is of type *os.File which implements io.Reader

v := reflect.ValueOf(r) // r is interface wrapping *os.File value
fmt.Println(v.Type())   // *os.File

v2 := reflect.ValueOf(&r)            // pointer passed, will be wrapped in interface{}
fmt.Println(v2.Type())               // *io.Reader
fmt.Println(v2.Elem().Type())        // navigate to pointed: io.Reader (interface type)
fmt.Println(v2.Elem().Elem().Type()) // 2nd Elem(): get concrete value in interface: *os.File

在 Go Playground 上试试.

关于go - go 中的 reflect.ValueOf() 和 Value.Elem() 有什么区别？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/57388657/