17370845950

需传指针确保可寻址，用reflect.MakeMap创建后通过SetMapIndex填充，key/value类型须严格匹配，结构体或slice值需先初始化；遍历修改时检查CanSet和IsValid，slice操作后须调用Set更新原变量。

怎么用 reflect.MakeMap 安全创建并填充 map

直接 reflect.ValueOf(m) 得到的 map 值是不可设置的（CanSet() == false），哪怕你后续调用 SetMapIndex 也会 panic。必须从指针入手，确保可寻址。

• 先用 reflect.ValueOf(&m).Elem() 获取可写的 map 反射值
• 用 reflect.MapOf(keyType, valueType) 构造类型，再调用 reflect.MakeMap()
• SetMapIndex 的 key 和 value 都必须是 reflect.Value 类型，且类型要严格匹配 map 定义（比如 map[string]int 的 key 必须是 reflect.TypeOf("").Kind() == reflect.String）
• 如果 value 是结构体或 slice，需先用 reflect.New 或 reflect.MakeSlice 初始化，否则写入时会 panic（nil pointer dereference）

package main

import (
	"fmt"
	"reflect"
)

func main() {
	// 创建 map[string]int 的反射值
	keyType := reflect.TypeOf("")
	valType := reflect.TypeOf(0)
	mapType := reflect.MapOf(keyType, valType)
	m := reflect.MakeMap(mapType)

	// 设置键值对：m["hello"] = 42
	key := reflect.ValueOf("hello")
	val := reflect.ValueOf(42)
	m.SetMapIndex(key, val)

	// 转回原类型使用
	result := m.Interface().(map[string]int)
	fmt.Println(result) // map[hello:42]
}

遍历任意 map 并安全修改值的正确姿势

不能直接对 interface{} 参数做 reflect.ValueOf(data).MapKeys() 后就改 —— 如果原始 map 不可寻址，所有写操作都会失败。关键在“是否传了地址”和“是否检查有效性”。

• 遍历时用 MapKeys() 或 MapRange()（Go 1.12+ 推荐，更稳定）
• 读取值用 MapIndex(key)，但务必先检查 IsValid()，避免访问不存在的 key 导致 panic
• 写入前确认 map 可设置：v.CanAddr() || v.Kind() == reflect.Ptr，否则只能读，不能写
• 若 map 元素是 *string 这类指针类型，需先 elem := v.MapIndex(key).Elem() 再 SetString，否则 Set 会报 “cannot set unaddressable value”

func clearStringValues(m interface{}) {
	v := reflect.ValueOf(m)
	if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Map {
		panic("expect *map[K]V where V is string or *string")
	}
	mv := v.Elem()
	for _, key := range mv.MapKeys() {
		val := mv.MapIndex(key)
		switch val.Kind() {
		case reflect.String:
			mv.SetMapIndex(key, reflect.ValueOf(""))
		case reflect.Ptr:
			if val.Elem().Kind() == reflect.String {
				if val.IsNil() {
					mv.SetMapIndex(key, reflect.Zero(val.Type()))
				} else {
					val.Elem().SetString("")
				}
			}
		}
	}
}

动态操作 slice：追加、替换、类型无关的修改

反射操作 slice 的核心陷阱是：传值进去只能读，传指针才能改；而 reflect.Append 返回新值，不自动更新原变量 —— 必须手动 Set 回去。

• 创建 slice：用 reflect.SliceOf(elemType) + reflect.MakeSlice(type, len, cap)
• 追加元素：newSlice := reflect.Append(slice, elem)，然后 slice.Set(newSlice) 才生效
• 修改某索引元素：先 slice.Index(i)，再根据元素类型调用 SetInt/SetString/Set；若元素是 struct，需确保字段可导出（首字母大写）且可设置
• 批量替换所有 int 元素为 +1：需用 elem.Kind() == reflect.Int 判断，再 elem.SetInt(elem.Int() + 1)

func addOneToAllInts(s interface{}) {
	v := reflect.ValueOf(s)
	if v.Kind() != reflect.Ptr {
		panic("need pointer to slice")
	}
	slice := v.Elem()
	if slice.Kind() != reflect.Slice {
		panic("not a slice")
	}
	for i := 0; i < slice.Len(); i++ {
		elem := slice.Index(i)
		if elem.Kind() == reflect.Int {
			elem.SetInt(elem.Int() + 1)
		}
	}
}

func main() {
	data := []int{10, 20, 30}
	addOneToAllInts(&data)
	fmt.Println(data) // [11 21 31]
}

为什么 map[string]interface{} 不能直接反射赋值给 struct？

这不是反射本身的问题，而是 Go 类型系统限制：map[string]interface{} 和 struct 是完全不同的底层类型，即使字段名一致，反射也无法自动映射。常见错误是以为 reflect.ValueOf(&s).Elem().FieldByName("Name").Set(...) 就能“一键填充”，结果发现 key 不存在或类型不匹配。

• 真正安全的做法是用 github.com/mitchellh/mapstructure，它做了字段名匹配、类型转换、嵌套展开等容错处理
• 自己手写反射映射时，必须逐个 FieldByName + CanSet 检查 + 类型兼容判断（如 int ← float64 需 Convert）
• 性能敏感场景应避免反射映射，优先用 JSON 编解码或生成代码（如 easyjson）
• 切记：反射不解决语义问题，只解决语法层面的动态访问 —— 字段名拼错、大小写不一致、嵌套层级不对，都会静默失败或 panic

反射操作 map 和 slice 最容易被忽略的点，不是“怎么写”，而是“谁负责生命周期”。比如用 reflect.MakeMap 创建的 map，其 key/value 类型一旦确定就不能变；用 reflect.Append 扩容后的 slice，若没 Set 回原变量，上层完全感知不到变化。这些不是 bug，是反射模型本身的约束。