golang 通过reflect反射修改值

╰半橙微兮° 2021-12-12 00:15 398阅读 0赞

不是所有的反射值都可以修改。对于一个反射值是否可以修改，可以通过`CanSet()`进行检查。

要修改值，必须满足:

*  可以寻址
    
    可寻址的类型：
    
     *  指针指向的具体元素
     *  slice的元素
     *  可寻址的结构体的字段(指向结构体的指针)
     *  可寻址的数组的元素(指向数组的指针)
 *  不是结构体没有导出的字段

# 1.指针指向的具体元素 #

需要两步:

*  取地址：`v := reflect.ValueOf(&x)`
 *  取得具体值 `v=v.Elem()`

下面通过一个整型变量的赋值进行说明。

package main
    
    import (
            "fmt"
            "reflect"
    )
    
    
    func main() { 
    
            a := 1
    
            v := reflect.ValueOf(a)
    
            fmt.Println("v Type:", v.Type())
            fmt.Println("v CanSet:", v.CanSet())
    
            v = reflect.ValueOf(&a)
            fmt.Println("v Type:", v.Type())
            fmt.Println("v CanSet:", v.CanSet())
    
            v = v.Elem() // element value
            fmt.Println("v Type:", v.Type())
            fmt.Println("v CanSet:", v.CanSet())
            
            // set
            v.SetInt(2)
            fmt.Println("after set, v:", v)
    
            newValue := reflect.ValueOf(3)
            v.Set(newValue)
            fmt.Println("after set, v:", v)
    
    }

定义一个整型变量，得到反射值，检查是否可以修改。

接着，通过反射获取整型变量地址的反射值，再通过`Elem()`得到指针指向的具体对象，这样就可以修改值。

输出结果：

v: 1
    v Type: int
    v CanSet: false
    v Type: *int
    v CanSet: false
    v Type: int
    v CanSet: true
    after set, v: 2
    after set, v: 3

# 2.slice的元素 #

需要两步:

*  取切片：`v := reflect.ValueOf(s)`
 *  获取切片的元素 `e := v.Index(0)`

具体代码如下。

package main
    
    import (
            "fmt"
            "reflect"
    )
    
    
    func main() { 
    
            a := []int{ 1,1}
    
            v := reflect.ValueOf(a)
            fmt.Println("v:", v)
    
            fmt.Println("v Type:", v.Type())
            fmt.Println("v CanSet:", v.CanSet())
    
            e := v.Index(0)
            fmt.Println("e CanSet:", e.CanSet())
    
            e.SetInt(2)
    
            fmt.Println("after set:", v)
    }

定义一个slice，得到反射值，从slice 的反射值中元素，  
接着，修改元素的值。

结果输出：

v: [1 1]
    v Type: []int
    v CanSet: false
    e CanSet: true
    after set: [2 1]

# 3.可寻址的结构体的字段 #

需要三步：

*  取结构体地址 `v := reflect.ValueOf(&a)`
 *  获取结构体的具体值:`Elem()`
 *  获取结构体的字段:`FieldByName()`

package main
    
    import (
            "fmt"
            "reflect"
    )
    
    type Orange struct { 
            Size int
    }
    
    func main() { 
    
            a := Orange{ 99}
    
            v := reflect.ValueOf(a)
            fmt.Println("v:", v)
    
            fmt.Println("v Type:", v.Type())
            fmt.Println("v CanSet:", v.CanSet())
    
            v = reflect.ValueOf(&a)
            fmt.Println("v:", v)
    
            fmt.Println("v Type:", v.Type())
            fmt.Println("v CanSet:", v.CanSet())
    
            //element
            v = v.Elem()
    
            size := v.FieldByName("Size")
            fmt.Println("size CanSet:", size.CanSet())
    
            size.SetInt(88)
    
            fmt.Println("after set:", v)
    
    }

定义一个结构体变量，首先反射变量，检查是否可以修改值。  
接着，使用变量地址进行反射，通过`Elem()`获取指针指向的具体值。  
最后，获取结构体的字段，并修改值。

输出结果

v: {99}
    v Type: main.Orange
    v CanSet: false
    v: &{99}
    v Type: *main.Orange
    v CanSet: false
    size CanSet: true
    after set: {88}

# 4.可寻址的数组的元素 #

需要三步：

*  取数组地址 `v := reflect.ValueOf(&a)`
 *  获取反射对象中的具体值:`Elem()`
 *  通过索引获取元素:`Index(0)`

package main
    
    import (
            "fmt"
            "reflect"
    )
    
    func main() { 
    
            a := [2]int{ 1,1}
    
            v := reflect.ValueOf(a)
            fmt.Println("v:", v)
    
            fmt.Println("v Type:", v.Type())
            fmt.Println("v CanSet:", v.CanSet())
    
            e := v.Index(0)
            fmt.Println("e Type:", e.Type())
            fmt.Println("e CanSet:", e.CanSet())
    
            v = reflect.ValueOf(&a)
            fmt.Println("v:", v)
    
            fmt.Println("v Type:", v.Type())
            fmt.Println("v CanSet:", v.CanSet())
    
            // element
            v = v.Elem()
            e = v.Index(0)
            fmt.Println("e Type:", e.Type())
            fmt.Println("e CanSet:", e.CanSet())
    
            e.SetInt(3)
    
            fmt.Println("after set:", v)
    
    }

定义一个数组变量，首先反射变量，检查是否可以修改值。  
接着，取数组中的元素，检查是否可以修改值。

使用数组的地址进行反射，通过`Elem()`获取指针指向的具体值。  
最后，获取数组中的元素，并修改值。

输出结果

v: [1 1]
    v Type: [2]int
    v CanSet: false
    e Type: int
    e CanSet: false
    v: &[1 1]
    v Type: *[2]int
    v CanSet: false
    e Type: int
    e CanSet: true
    after set: [3 1]