在我们看一些使用反射的代码的时候，会发现，reflect.ValueOf 或 reflect.TypeOf 的参数有些地方使用的是指针参数，有些地方又不是指针参数，
但是好像这两者在使用上没什么区别，比如下面这样：

var a = 1
v1 := reflect.ValueOf(a)
v2 := reflect.ValueOf(&a)

fmt.Println(v1.Int())        // 1
fmt.Println(v2.Elem().Int()) // 1

它们的区别貌似只是需不需要使用 Elem() 方法，但这个跟我们是否传递指针给 reflect.ValueOf 其实关系不大，
相信没有人为了使用一下 Elem() 方法，就去传递指针给 reflect.ValueOf 吧。

那我们什么时候应该传递指针参数呢？

什么时候传递指针？

要回答这个问题，我们可以思考一下以下列出的几点内容：

1. 是否要修改变量的值，要修改就要用指针
2. 结构体类型：是否要修改结构体里的字段，要修改就要用指针
3. 结构体类型：是否要调用指针接收值方法，要调用就要用指针
4. 对于 chan、map、slice 类型，我们传递值和传递指针都可以修改其内容
5. 对于非 interface 类型，传递给 TypeOf 和 ValueOf 的时候都会转换为 interface 类型，如果本身就是 interface 类型，则不需转换。
6. 指针类型不可修改，但是可以修改指针指向的值。（v := reflect.ValueOf(&a)，v.CanSet() 是 false，v.Elem().CanSet() 是 true）
7. 字符串：我们可以对字符串进行替换，但不能修改字符串的某一个字符

大概总结下来，就是：如果我们想修改变量的内容，就传递指针，否则就传递值。对于某些复合类型如果其内部包含了底层数据的指针，
也是可以通过传值来修改其底层数据的，这些类型有 chan、map、slice。
又或者如果我们想修改结构体类型里面的指针类型字段，传递结构体的拷贝也能实现。

1. 通过传递指针修改变量的值

对于一些基础类型的变量，如果我们想修改其内容，就要传递指针。这是因为在 go 里面参数传递都是值传递，如果我们不传指针，
那么在函数内部拿到的只是参数的拷贝，对其进行修改，不会影响到外部的变量（事实上在对这种反射值进行修改的时候会直接 panic）。

传值无法修改变量本身

x := 1
v := reflect.ValueOf(x)

在这个例子中，v 中保存的是 x 的拷贝，对这份拷贝在反射的层面上做修改其实是没有实际意义的，因为对拷贝进行修改并不会影响到 x 本身。
我们在通过反射来修改变量的时候，我们的预期行为往往是修改变量本身。鉴于实际的使用场景，go 的反射系统已经帮我们做了限制了，
在我们对拷贝类型的反射对象进行修改的时候，会直接 panic。

传指针可以修改变量

x := 1
v := reflect.ValueOf(&x).Elem()

在这个例子中，我们传递了 x 的指针到 reflect.ValueOf 中，这样一来，v 指向的就是 x 本身了。
在这种情况下，我们对 v 的修改就会影响到 x 本身。

2. 通过传递指针修改结构体的字段

对于结构体类型，如果我们想修改其字段的值，也是要传递指针的。这是因为结构体类型的字段是值类型，如果我们不传递指针，
reflect.ValueOf 拿到的也是一份拷贝，对其进行修改并不会影响到结构体本身。当然，这种情况下，我们修改它的时候也会 panic。

type person struct {
	Name string
	Age  int
}

p := person{
    Name: "foo",
    Age:  30,
}
// v 本质上是指向 p 的指针
v := reflect.ValueOf(&p)

// v.CanSet() 为 false，v 是指针，指针本身是不能修改的
// v.Elem() 是 p 本身，是可以修改的

fmt.Println(v.Elem().FieldByName("Name").CanSet()) // true
fmt.Println(v.Elem().FieldByName("Age").CanSet())  // true

3. 结构体：获取指针接收值方法

对于结构体而言，如果我们想通过反射来调用指针接收者方法，那么我们需要传递指针。

在开始讲解这一点之前，需要就以下内容达成共识：

type person struct {
}

func (p person) M1() {
}

func (p *person) M2() {
}

func TestPerson(t *testing.T) {
	p := person{}
	v1 := reflect.ValueOf(p)
	v2 := reflect.ValueOf(&p)

	assert.Equal(t, 1, v1.NumMethod())
	assert.Equal(t, 2, v2.NumMethod())

	// v1 和 v2 都有 M1 方法
	assert.True(t, v1.MethodByName("M1").IsValid())
	assert.True(t, v2.MethodByName("M1").IsValid())

	// v1 没有 M2 方法
	// v2 有 M2 方法
	assert.False(t, v1.MethodByName("M2").IsValid())
	assert.True(t, v2.MethodByName("M2").IsValid())
}

在上面的代码中，p 只有一个方法 M1，而 &p 有两个方法 M1 和 M2。
但是在实际使用中，我们使用 p 来调用 M2 也是可以的，
p 之所以能调用 M2 是因为编译器帮我们做了一些处理，将 p 转换成了 &p，然后调用 M2。

但是在反射的时候，我们是无法做到这一点的，这个需要特别注意。如果我们想通过反射来调用指针接收者的方法，就需要传递指针。

4. 变量本身包含指向数据的指针

最好不要通过值的反射对象来修改值的数据，就算有些类型可以实现这种功能。

对于 chan、map、slice 这三种类型，我们可以通过 reflect.ValueOf 来获取它们的值，
但是这个值本身包含了指向数据的指针，因此我们依然可以通过反射系统修改其数据。但是，我们最好不这么用，从规范的角度，这是一种错误的操作。

通过值反射对象修改 chan、map 和 slice

在 go 中，chan、map、slice 这几种数据结构中，存储数据都是通过一个 unsafe.Pointer 类型的变量来指向实际存储数据的内存。
这是因为，这几种类型能够存储的元素个数都是不确定的，都需要根据我们指定的大小和存储的元素类型来进行内存分配。

正因如此，我们复制 chan、map、slice 的时候，虽然值被复制了一遍，但是存储数据的指针也被复制了，
这样我们依然可以通过拷贝的数据指针来修改其数据，如下面的例子：

func TestPointer1(t *testing.T) {
	// 数组需要传递引用才能修改其元素
	arr := [3]int{1, 2, 3}
	v1 := reflect.ValueOf(&arr)
	v1.Elem().Index(1).SetInt(100)
	assert.Equal(t, 100, arr[1])

	// chan 传值也可以修改其元素
	ch := make(chan int, 1)
	v2 := reflect.ValueOf(ch)
	v2.Send(reflect.ValueOf(10))
	assert.Equal(t, 10, <-ch)

	// map 传值也可以修改其元素
	m := make(map[int]int)
	v3 := reflect.ValueOf(m)
	v3.SetMapIndex(reflect.ValueOf(1), reflect.ValueOf(10))
	assert.Equal(t, 10, m[1])

	// slice 传值也可以修改其元素
	s := []int{1, 2, 3}
	v4 := reflect.ValueOf(s)
	v4.Index(1).SetInt(20)
	assert.Equal(t, 20, s[1])
}

slice 反射对象扩容的影响

但是，我们需要注意的是，对于 map 和 slice 类型，在其分配的内存容纳不下新的元素的时候，会进行扩容，
扩容之后，保存数据字段的指针就指向了一片新的内存了。
这意味着什么呢？这意味着，我们通过 map 和 slice 的值创建的反射值对象中拿到的那份数据指针已经跟旧的 map 和 slice 指向的内存不一样了。

说明：在上图中，我们在反射对象中往 slice 追加元素后，导致反射对象 slice 的 array 指针指向了一片新的内存区域了，
这个时候我们再对反射对象进行修改的时候，不会影响到原 slice。这也就是我们不能通过 slice 或 map 的拷贝的反射对象来修改 slice 或 map 的原因。

示例代码：

func TestPointer1(t *testing.T) {
	s := []int{1, 2, 3}
	v4 := reflect.ValueOf(s)
	v4.Index(1).SetInt(20)
	assert.Equal(t, 20, s[1])

	// 这里发生了扩容
	// v5 的 array 跟 s 的 array 指向的是不同的内存区域了。
	v5 := reflect.Append(v4, reflect.ValueOf(4))
	fmt.Println(s) // [1 20 3]
	fmt.Println(v5.Interface().([]int)) // [1 20 3 4]

	// 这里修改 v5 的时候影响不到 s 了
	v5.Index(1).SetInt(30)
	fmt.Println(s) // [1 20 3]
	fmt.Println(v5.Interface().([]int)) // [1 30 3 4]
}

说明：在上面的代码中，v5 实际上是 v4 扩容后的切片，底层的 array 指针指向的是跟 s 不一样的 array 了，
因此在我们修改 v5 的时候，会发现原来的 s 并没有发生改变。

虽然通过值反射对象可以修改 slice 的数据，但是如果通过反射对象 append 元素到 slice 的反射对象的时候，
可能会触发 slice 扩容，这个时候再修改反射对象的时候，就影响不了原来的 slice 了。

slice 容量够的话是不是就可以正常追加元素了？

只能说，能，也不能。我们看看下面这个例子：

func TestPointer000(t *testing.T) {
	s1 := make([]int, 3, 6)
	s1[0] = 1
	s1[1] = 2
	s1[2] = 3
	fmt.Println(s1) // [1 2 3]

	v6 := reflect.ValueOf(s1)
	v7 := reflect.Append(v6, reflect.ValueOf(4))
	// 虽然 s1 的容量足够大，但是 s1 还是看不到追加的元素
	fmt.Println(s1)                     // [1 2 3]
	fmt.Println(v7.Interface().([]int)) // [1 2 3 4]

	// s1 和 s2 底层数组还是同一个
	// array1 是 s1 底层数组的内存地址
	array1 := (*(*reflect.SliceHeader)(unsafe.Pointer(&s1))).Data
	s2 := v7.Interface().([]int)
    // array2 是 s2 底层数组的内存地址
	array2 := (*(*reflect.SliceHeader)(unsafe.Pointer(&s2))).Data
	assert.Equal(t, array1, array2)

	// 这是因为 s1 的长度并没有发生改变，
	// 所以 s1 看不到追加的那个元素
	fmt.Println(len(s1), cap(s1)) // 3 6
	fmt.Println(len(s2), cap(s2)) // 4 6
}

在这个例子中，我们给 slice 分配了足够大的容量，但是我们通过反射对象来追加元素的时候，
虽然数据被正常追加到了 s1 底层数组，但是由于在反射对象以外的 s1 的 len 并没有发生改变，
因此 s1 还是看不到反射对象追加的元素。所以上面说可以正常追加元素。

但是，外部由于 len 没有发生改变，因此外部看不到反射对象追加的元素，所以上面也说不能正常追加元素。

因此，虽然理论上修改的是同一片内存，我们依然不能通过传值的方式来通过反射对象往 slice 中追加元素。
但是修改 [0, len(s)) 范围内的元素在反射对象外部是可以看到的。

map 也不能通过值反射对象来修改其元素。

跟 slice 类似，通过 map 的值反射对象来追加元素的时候，同样可能导致扩容，
扩容之后，保存数据的内存区域会发生改变。

但是，从另一个角度看，如果我们只是修改其元素的话，是可以正常修改的。

chan 没有追加

chan 跟 slice、map 有个不一样的地方，它的长度是我们创建 chan 的时候就已经固定的了，
因此，不存在扩容导致指向内存区域发生改变的问题。

因此，对于 chan 类型的元素，我们传 ch 或者 &ch 给 reflect.ValueOf 都可以实现修改 ch。

结构体字段包含指针的情况

如果结构体里面包含了指针字段，我们也只是想通过反射对象来修改这个指针字段的话，
那么我们也还是可以通过传值给 reflect.ValueOf 来创建反射对象来修改这个指针字段：

type person struct {
	Name *string
}

func TestPointerPerson(t *testing.T) {
	name := "foo"
	p := person{Name: &name}

	v := reflect.ValueOf(p)
	fmt.Println(v.Field(0).Elem().CanAddr())
	fmt.Println(v.Field(0).Elem().CanSet())

	name1 := "bar"
	v.Field(0).Elem().Set(reflect.ValueOf(name1))
	// p 的 Name 字段已经被成功修改
	fmt.Println(*p.Name)
}

在这个例子中，我们虽然使用了 p 而不是 &p 来创建反射对象，
但是我们依然可以修改 Name 字段，因为反射对象拿到了 Name 的指针的拷贝，
通过这个拷贝是可以定位到 p 的 Name 字段本身指向的内存的。

但是我们依然是不能修改 p 中的其他字段。

5. interface 类型处理

对于 interface 类型的元素，我们可以将以下两种操作看作是等价的：

// v1 跟 v2 都拿到了 a 的拷贝
var a = 1
v1 := reflect.ValueOf(a)

var b interface{} = a
v2 := reflect.ValueOf(b)

我们可以通过下面的断言来证明：

assert.Equal(t, v1.Kind(), v2.Kind())
assert.Equal(t, v1.CanAddr(), v2.CanAddr())
assert.Equal(t, v1.CanSet(), v2.CanSet())
assert.Equal(t, v1.Interface(), v2.Interface())

当然，对于指针类型也是一样的：

// v1 跟 v2 都拿到了 a 的指针
var a = 1
v1 := reflect.ValueOf(&a)

var b interface{} = &a
v2 := reflect.ValueOf(b)

同样的，我们可以通过下面的断言来证明：

assert.Equal(t, v1.Kind(), v2.Kind())
assert.Equal(t, v1.Elem().Kind(), v2.Elem().Kind())
assert.Equal(t, v1.Elem().CanAddr(), v2.Elem().CanAddr())
assert.Equal(t, v1.Elem().Addr(), v2.Elem().Addr())
assert.Equal(t, v1.Interface(), v2.Interface())
assert.Equal(t, v1.Elem().Interface(), v2.Elem().Interface())

interface 底层类型是值

interface 类型的底层类型是值的时候，我们将其传给 reflect.ValueOf 跟直接传值是一样的。
是没有办法修改 interface 底层数据的值的（除了指针类型字段，因为反射对象也拿到了指针字段的地址）：

type person struct {
    Name *string
}

func TestInterface1(t *testing.T) {
	name := "foo"
	p := person{Name: &name}

	// v 拿到的是 p 的拷贝
    // 下面两行等价于 v := reflect.ValueOf(p)
	var i interface{} = p
	v := reflect.ValueOf(i)
	assert.False(t, v.CanAddr())
	assert.Equal(t, reflect.Struct, v.Kind())
	assert.True(t, v.Field(0).Elem().CanAddr())
}

在上面这个例子中 v := reflect.ValueOf(i) 其实等价于 v := reflect.ValueOf(p)，
因为在我们调用 reflect.ValueOf(p) 的时候，go 语言本身会帮我们将 p 转换为 interface{} 类型。
在我们赋值给 i 的时候，go 语言也会帮我们将 p 转换为 interface{} 类型。
这样再调用 reflect.ValueOf 的时候就不需要再做转换了。

interface 底层类型是指针

传递底层数据是指针类型的 interface 给 reflect.ValueOf 的时候，我们可以修改 interface 底层指针指向的值，
效果等同于直接传递指针给 reflect.ValueOf：

func TestInterface(t *testing.T) {
	var a = 1
	v1 := reflect.ValueOf(&a)

	var b interface{} = &a
	v2 := reflect.ValueOf(b)

	// v1 和 v2 本质上都接收了一个 interface 参数，
	// 这个 interface 参数的数据部分都是 &a

	v1.Elem().SetInt(10)
	assert.Equal(t, 10, a)

	// 通过 v1 修改 a 的值，v2 也能看到
	assert.Equal(t, 10, v2.Elem().Interface())

	// 同样的，通过 v2 修改 a 的值，v1 也能看到
	v2.Elem().SetInt(20)
	assert.Equal(t, 20, a)
	assert.Equal(t, 20, v1.Elem().Interface())
}

不要再对接口类型取地址

能不能通过反射 Value 对象来修改变量只取决于，能不能根据反射对象拿到最初变量的内存地址。
如果拿到的只是原始值的拷贝，不管我们怎么做都无法修改原始值。

对于初学者另外一个令人困惑的地方可能是下面这样的代码：

func TestInterface(t *testing.T) {
	var a = 1
	var i interface{} = a
	v1 := reflect.ValueOf(&a)
	v2 := reflect.ValueOf(&i)

	// v1 和 v2 的类型都是 reflect.Ptr
	assert.Equal(t, reflect.Ptr, v1.Kind())
	assert.Equal(t, reflect.Ptr, v2.Kind())

	// 但是两者的 Elem() 类型不同，
	// v1 的 Elem() 是 reflect.Int，
	// v2 的 Elem() 是 reflect.Interface
	assert.Equal(t, reflect.Int, v1.Elem().Kind())
	assert.Equal(t, reflect.Interface, v2.Elem().Kind())
}

困惑的源头在于，reflect.ValueOf() 这个函数的参数是 interface{} 类型的，
这意味着我们可以传递任意类型的值给它，包括指针类型的值。

正因如此，如果我们不懂得 reflect 包的工作原理的话，
就会传错变量到 reflect.ValueOf() 函数中，导致程序出错。

对于上面例子的 v2，它是一个指向 interface{} 类型的指针的反射对象，它也能找到最初的变量 a：

但是能不能修改 a，还是取决于 a 是否是可寻址的。也就是最初传递给 i 的值是不是一个指针类型。

assert.Equal(t, "<*interface {} Value>", v2.String())
assert.Equal(t, "<interface {} Value>", v2.Elem().String())
assert.Equal(t, "<int Value>", v2.Elem().Elem().String())

在上面的例子中，我们传递给 i 的是 a 的值，而不是 a 的指针，所以 i 是不可寻址的，也就是说 v2 是不可寻址的。

上图说明：

• i 是接口类型，它的数据部分是 a 的拷贝，它的类型部分是 int 类型。
• &i 是指向接口的指针，它指向了上图的 eface。
• v2 是指向 eface 的指针的反射对象。
• 最终，我们通过 v2 找到 i 这个接口，然后通过 i 找到 a 这个变量的拷贝。

所以，绕了一大圈，我们最终还是修改不了 a 的值。到最后我们只拿到了 a 的拷贝。

6. 指针类型反射对象不可修改其指向地址

其实这一点上面有些地方也有涉及到，但是这里再强调一下。一个例子如下：

func TestPointer(t *testing.T) {
	var a = 1
	var b = &a
	v := reflect.ValueOf(b)

	assert.False(t, v.CanAddr())
	assert.False(t, v.CanSet())

	assert.True(t, v.Elem().CanAddr())
	assert.True(t, v.Elem().CanSet())
}

说明：

• v 是指向 &a 的指针的反射对象。
• 通过这个反射对象的 Elem() 方法，我们可以找到原始的变量 a。
• 反射对象本身不能修改，但是它的 Elem() 方法返回的反射对象可以修改。

对于指针类型的反射对象，其本身不能修改，但是它的 Elem() 方法返回的反射对象可以修改。

7. 反射也不能修改字符串中的字符

这是因为，go 中的字符串本身是不可变的，我们无法像在 C 语言中那样修改其中某一个字符。
其实不止是 go，其实很多编程语言的字符串都是不可变的，比如 Java 中的 String 类型。

在 go 中，字符串是用一个结构体来表示的，大概长下面这个样子：

type StringHeader struct {
	Data uintptr
	Len  int
}

• Data 是指向字符串的指针。
• Len 是字符串的长度（单位为字节）。

在 go 中 str[1] = 'a' 这样的操作是不允许的，因为字符串是不可变的。

相同的字符串只有一个实例

假设我们定义了两个相同的字符串，如下：

s1 := "hello"
s2 := "hello"

这两个字符串的值是相同的，但是它们的地址是不同的。那既然如此，为什么我们还是不能修改它的其中某一个字符呢？
这是因为，虽然 s1 和 s2 的地址不一样，但是它们实际保存 hello 这个字符串的地址是一样的：

v1 := (*reflect.StringHeader)(unsafe.Pointer(&s1))
v2 := (*reflect.StringHeader)(unsafe.Pointer(&s2))

// 两个字符串实例保存字符串的内存地址是一样的
assert.Equal(t, v1.Data, v2.Data)

两个字符串内存表示如下：

所以，我们可以看到，s1 和 s2 实际上是指向同一个字符串的指针，所以我们无法修改其中某一个字符。
因为如果允许这种行为存在的话，我们对其中一个字符串实例修改，也会影响到另外一个字符串实例。

字符串本身可以替换

虽然我们不能修改字符串中的某一个字符，但是我们可以通过反射对象把整个字符串替换掉：

func TestStirng(t *testing.T) {
	s := "hello"

	v := reflect.ValueOf(&s)
	fmt.Println(v.Elem().CanAddr())
	fmt.Println(v.Elem().CanSet())

	v.Elem().SetString("world")
	fmt.Println(s) // world
}

这里实际上是把 s 中保存字符串的地址替换成了指向 world 这个字符串的地址，而不是将 hello 指向的内存修改成 world：

func TestStirng(t *testing.T) {
	s := "hello"

	oldAddr := (*reflect.StringHeader)(unsafe.Pointer(&s)).Data

	v := reflect.ValueOf(&s)
	v.Elem().SetString("world")

	newAddr := (*reflect.StringHeader)(unsafe.Pointer(&s)).Data

	// 修改之后，实际保存字符串的内存地址发生了改变
	assert.NotEqual(t, oldAddr, newAddr)
}

这可以用下图表示：

总结

• 如果我们需要通过反射对象来修改变量的值，那么我们必须得有办法拿到变量实际存储的内存地址。这种情况下，很多时候都是通过传递指针给 reflect.ValueOf() 方法来实现的。
• 但是对于 chan、map 和 slice 或者其他类似的数据结构，它们通过指针来引用实际存储数据的内存，这种数据结构是通过通过传值给 reflect.ValueOf() 方法来实现修改其中的元素的。因为这些数据结构的数据部分可以通过指针的拷贝来修改。
• 但是 map 和 slice 有可能会扩容，如果通过反射对象来追加元素，可能导致追加失败。这是因为，通过反射对象追加元素的时候，如果扩容了，那么原来的内存地址就会失效，这样我们其实就修改不了原来的 map 和 slice 了。
• 同样的，结构体传值来创建反射对象的时候，如果其中有指针类型的字段，那么我们也可以通过指针来修改其中的元素。但是其他字段也还是修改不了的。
• 如果我们创建反射对象的参数是 interface 类型，那么能不能修改元素的变量还是取决于我们这个 interface 类型变量的数据部分是值还是指针。如果 interface 变量中存储的是值，那么我们就不能修改其中的元素了。如果 interface 变量中存储的是指针，就可以修改。
• 我们无法修改字符串的某一个字符，通过反射也不能，因为字符串本身是不可变的。不同的 stirng 类型的变量，如果它们的值是一样的，那么它们会共享实际存储字符串的内存。
• 但是我们可以直接用一个新的字符串替代旧的字符串。

但其实说了那么多，简单来说只有一点，就是我们只能通过反射对象来修改指针类型的变量。如果拿不到实际存储数据的指针，那么我们就无法通过反射对象来修改其中的元素了。