[Golang] 反序列化中的隐式转换设计问题讨论

背景

在反序列化的时候，需要一个 interface 用来接收反序列化的内容，如下代码所示

func doNormal(data []byte) (*Student, error) {
    s := &Student{}
    if err := json.Unmarshal(data, s); err != nil {
    	return nil, err
    }
    return s, nil
}

然而为了使代码更加简化，习惯性得使用了命名返回值，导致反序列化失败

func doBug(data []byte) (s *Student, _ error) {
    return s, json.Unmarshal(data, s)
}

原因是因为 json.Unmarshal 中发现 s 是一个 nil ，直接 return error, 但将参数改成二级指针就 work 了

func doSimple(data []byte) (s *Student, _ error) {
    return s, json.Unmarshal(data, &s)
}

于是有了几个疑问：

1. 这里二级指针能 work 的原因是啥？
2. 这里二级指针指向的也是一个 nil 的一级指针，它能 work ，为啥直接使用一个 nil 的一级指针不行，这样设计的原因是啥？

开始分析

通过分析 json.Unmarshal 的代码可以发现 indirect 函数,这个函数会将二级指针反解成一级指针，并且发现一级指针是 nil 的时候，会初始化一个 Student

大概过程是如下所示

var p * Student
var pp ** Student = &p

v := reflect.ValueOf(pp).Elem() // v is nil

v.Set(reflect.New(v.Type().Elem())) // v is not nil

问题

1. 使用二级指针的方式还有啥坑吗，大家是怎么简化反/序列化代码的呢？
2. 这里二级指针指向的也是一个 nil 的一级指针，而直接使用一个 nil 的一级指针就直接报错，这样设计的原因是啥？

完整的 indirect 代码如下

// indirect walks down v allocating pointers as needed,
// until it gets to a non-pointer.
// If it encounters an Unmarshaler, indirect stops and returns that.
// If decodingNull is true, indirect stops at the first settable pointer so it
// can be set to nil.
func indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
	// Issue #24153 indicates that it is generally not a guaranteed property
	// that you may round-trip a reflect.Value by calling Value.Addr().Elem()
	// and expect the value to still be settable for values derived from
	// unexported embedded struct fields.
	//
	// The logic below effectively does this when it first addresses the value
	// (to satisfy possible pointer methods) and continues to dereference
	// subsequent pointers as necessary.
	//
	// After the first round-trip, we set v back to the original value to
	// preserve the original RW flags contained in reflect.Value.
	v0 := v
	haveAddr := false

	// If v is a named type and is addressable,
	// start with its address, so that if the type has pointer methods,
	// we find them.
	if v.Kind() != reflect.Pointer && v.Type().Name() != "" && v.CanAddr() {
		haveAddr = true
		v = v.Addr()
	}
	for {
		// Load value from interface, but only if the result will be
		// usefully addressable.
		if v.Kind() == reflect.Interface && !v.IsNil() {
			e := v.Elem()
			if e.Kind() == reflect.Pointer && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Pointer) {
				haveAddr = false
				v = e
				continue
			}
		}

		if v.Kind() != reflect.Pointer {
			break
		}

		if decodingNull && v.CanSet() {
			break
		}

		// Prevent infinite loop if v is an interface pointing to its own address:
		//     var v interface{}
		//     v = &v
		if v.Elem().Kind() == reflect.Interface && v.Elem().Elem() == v {
			v = v.Elem()
			break
		}
		if v.IsNil() {
			v.Set(reflect.New(v.Type().Elem()))
		}
		if v.Type().NumMethod() > 0 && v.CanInterface() {
			if u, ok := v.Interface().(Unmarshaler); ok {
				return u, nil, reflect.Value{}
			}
			if !decodingNull {
				if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
					return nil, u, reflect.Value{}
				}
			}
		}

		if haveAddr {
			v = v0 // restore original value after round-trip Value.Addr().Elem()
			haveAddr = false
		} else {
			v = v.Elem()
		}
	}
	return nil, nil, v
}