go实战基础（一） - go实战反射（十四） - 《GO 开发知识笔记》

package main
import (
    "encoding/json"
    "fmt"
)
type Student struct {
    ID     int    `json:"id"`
    Gender string `json:"gender"`
    Name   string `json:"name"`
    Sno    string `json:"sno"`
}
func main() {
    var s1 = Student{
        ID:     1,
        Gender: "男",
        Name:   "李四",
        Sno:    "s0001",
    }
    fmt.Println("aa")
    var s, _ = json.Marshal(s1)
    jsonStr := string(s)
    fmt.Println(jsonStr)
}

package main
import (
    "fmt"
    "reflect"
)
type myInt int
type Person struct {
    Name string
    Age  int
}
//反射获取任意变量的类型
func reflectFn(x interface{}) {
    v := reflect.TypeOf(x)
    fmt.Println(v)
}
func main() {
    a := 10         //int
    b := 23.4       //float64
    c := true       //bool
    d := "你好golang" //string
    reflectFn(a)
    reflectFn(b)
    reflectFn(c)
    reflectFn(d)
    var e myInt = 34
    var f = Person{
        Name: "张三",
        Age:  20,
    }
    reflectFn(e) //main.myInt
    reflectFn(f) //main.Person
    var h = 25
    reflectFn(&h) //*int
}

package main
import (
    "fmt"
    "reflect"
)
type myInt int
type Person struct {
    Name string
    Age  int
}
//反射获取任意变量的类型
func reflectFn(x interface{}) {
    v := reflect.TypeOf(x)
    // v.Name() //类型名称 ,种类（Kind）就是指底层的类型
    // v.Kind() //种类
    fmt.Printf("类型:%v 类型名称:%v 类型种类:%v \n", v, v.Name(), v.Kind())
}
func main() {
    a := 10         //int
    b := 23.4       //float64
    c := true       //bool
    d := "你好golang" //string
    reflectFn(a)
    reflectFn(b)
    reflectFn(c)
    reflectFn(d)
    var e myInt = 34
    var f = Person{
        Name: "张三",
        Age:  20,
    }
    reflectFn(e) //main.myInt
    reflectFn(f) //main.Person
    var h = 25
    reflectFn(&h) //*int 类型名称: 类型种类:ptr
    var i = [3]int{1, 2, 3}
    reflectFn(i) //[3]int 类型名称: 类型种类:array
    var j = []int{11, 22, 33}
    reflectFn(j) //[]int 类型名称: 类型种类:slice
}

package main
import (
    "fmt"
    "reflect"
)
func reflectValue(x interface{}) {
    // var num = 10 + x //(mismatched types int and interface {}
    // b, _ := x.(int)
    // var num = 10 + b
    // fmt.Println(num) //23
    //反射来实现这个功能
    // v := reflect.ValueOf(x)
    // fmt.Println(v) //13
    // var n = v + 12
    // fmt.Println(n) //mismatched types reflect.Value and int
    //反射获取变量的原始值
    v := reflect.ValueOf(x)
    var m = v.Int() + 12
    fmt.Println(m) //25
}
func main() {
    var a = 13
    reflectValue(a)
}

package main
import (
    "fmt"
    "reflect"
)
func reflectValue(x interface{}) {
    v := reflect.ValueOf(x)
    // v.Kind() //获取种类
    kind := v.Kind()
    switch kind {
    case reflect.Int64:
        fmt.Printf("int类型的原始值%v,计算后的值是%v \n", v.Int(), v.Int()+10)
    case reflect.Float32:
        fmt.Printf("Float32类型的原始值%v\n", v.Float())
    case reflect.Float64:
        fmt.Printf("Float64类型的原始值%v\n", v.Float())
    case reflect.String:
        fmt.Printf("string类型的原始值%v\n", v.String())
    default:
        fmt.Printf("还没有判断这个类型\n")
    }
}
func main() {
    var a int64 = 100
    var b float32 = 12.3
    var c string = "你好golang"
    reflectValue(a)
    reflectValue(b)
    reflectValue(c)
}

package main
import (
    "fmt"
    "reflect"
)
func reflectSetValue(x interface{}) {
    // *x = 120  //invalid indirect of x (type interface {})
    // v, _ := x.(*int)
    // *v = 120 // invalid memory address or nil pointer dereferenc
    v := reflect.ValueOf(x)
    // fmt.Println(v.Kind()) //ptr
    // fmt.Println(v.Elem().Kind()) //int64
    if v.Elem().Kind() == reflect.Int64 {
        v.Elem().SetInt(123)
    } else if v.Elem().Kind() == reflect.String {
        v.Elem().SetString("你好 go语言")
    }
}
func main() {
    var a int64 = 100
    reflectSetValue(&a)
    fmt.Println(a)
    var b string = "你好golang"
    reflectSetValue(&b)
    fmt.Println(b)
}

package main
import (
    "fmt"
    "reflect"
)
//student结构体
type Student struct {
    Name  string `json:"name1" form:"username"`
    Age   int    `json:"age"`
    Score int    `json:"score"`
}
func (s Student) GetInfo() string {
    var str = fmt.Sprintf("姓名:%v 年龄:%v 成绩:%v", s.Name, s.Age, s.Score)
    return str
}
func (s *Student) SetInfo(name string, age int, score int) {
    s.Name = name
    s.Age = age
    s.Score = score
}
func (s Student) Print() {
    fmt.Println("这是一个打印方法...")
}
//打印字段
func PrintStructField(s interface{}) {
    //判断参数是不是结构体类型
    t := reflect.TypeOf(s)
    v := reflect.ValueOf(s)
    if t.Kind() != reflect.Struct && t.Elem().Kind() != reflect.Struct {
        fmt.Println("传入的参数不是一个结构体")
        return
    }
    //1、通过类型变量里面的Field可以获取结构体的字段
    field0 := t.Field(0)
    fmt.Printf("%#v \n", field0) //reflect.StructField{Name:"Name", PkgPath:"", Type:(*reflect.rtype)(0x4adf20), Tag:"json:\"name\"", Offset:0x0, Index:[]int{0}, Anonymous:false}
    fmt.Println("字段名称：", field0.Name)
    fmt.Println("字段类型：", field0.Type)
    fmt.Println("字段Tag：", field0.Tag.Get("json"))
    fmt.Println("字段Tag：", field0.Tag.Get("form"))
    //2、通过类型变量里面的FieldByName可以获取结构体的字段
    fmt.Println("----------------------")
    field1, ok := t.FieldByName("Age")
    if ok {
        fmt.Println("字段名称：", field1.Name)
        fmt.Println("字段类型：", field1.Type)
        fmt.Println("字段Tag：", field1.Tag.Get("json"))
    }
    //3、通过类型变量里面的NumField获取到该结构体有几个字段
    var fieldCount = t.NumField()
    fmt.Println("结构体有", fieldCount, "个属性")
    //4、通过值变量获取结构体属性对应的值
    fmt.Println(v.FieldByName("Name"))
    fmt.Println(v.FieldByName("Age"))
    fmt.Println("----------------------")
    for i := 0; i < fieldCount; i++ {
        fmt.Printf("属性名称:%v 属性值:%v 属性类型:%v 属性Tag:%v\n", t.Field(i).Name, v.Field(i), t.Field(i).Type, t.Field(i).Tag.Get("json"))
    }
}
//打印执行方法
func PrintStructFn(s interface{}) {
    t := reflect.TypeOf(s)
    v := reflect.ValueOf(s)
    if t.Kind() != reflect.Struct && t.Elem().Kind() != reflect.Struct {
        fmt.Println("传入的参数不是一个结构体")
        return
    }
    //1、通过类型变量里面的Method可以获取结构体的方法
    method0 := t.Method(0)    //和结构体方法的顺序没有关系，和结构体方法的ASCII有关系
    fmt.Println(method0.Name) //GetInfo
    fmt.Println(method0.Type) //func(main.Student) string
    fmt.Println("--------------------------")
    //2、通过类型变量获取这个结构体有多少个方法
    method1, ok := t.MethodByName("Print")
    if ok {
        fmt.Println(method1.Name) //Print
        fmt.Println(method1.Type) //func(main.Student)
    }
    fmt.Println("--------------------------")
    //3、通过《值变量》执行方法 （注意需要使用值变量，并且要注意参数） v.Method(0).Call(nil) 或者v.MethodByName("Print").Call(nil)
    // v.Method(1).Call(nil)
    v.MethodByName("Print").Call(nil)
    info1 := v.MethodByName("GetInfo").Call(nil)
    fmt.Println(info1)
    //4、执行方法传入参数 （注意需要使用《值变量》，并且要注意参数,接收的参数是[]reflect.Value的切片）
    var params []reflect.Value
    params = append(params, reflect.ValueOf("李四"))
    params = append(params, reflect.ValueOf(23))
    params = append(params, reflect.ValueOf(99))
    v.MethodByName("SetInfo").Call(params) //执行方法传入参数
    info2 := v.MethodByName("GetInfo").Call(nil)
    fmt.Println(info2)
    // 5、获取方法数量
    fmt.Println("方法数量:", t.NumMethod())
}
func main() {
    stu1 := Student{
        Name:  "小明",
        Age:   15,
        Score: 98,
    }
    // PrintStructField(stu1)
    PrintStructFn(&stu1)
    fmt.Printf("%#v\n", stu1)
}

package main
import (
    "fmt"
    "reflect"
)
//student结构体
type Student struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Score int    `json:"score"`
}
func (s Student) GetInfo() string {
    var str = fmt.Sprintf("姓名:%v 年龄:%v 成绩:%v", s.Name, s.Age, s.Score)
    return str
}
//反射修改结构体属性
func reflectChangeStruct(s interface{}) {
    t := reflect.TypeOf(s)
    v := reflect.ValueOf(s)
    if t.Kind() != reflect.Ptr {
        fmt.Println("传入的不是结构体指针类型")
        return
    } else if t.Elem().Kind() != reflect.Struct {
        fmt.Println("传入的不是结构体指针类型")
        return
    }
    //修改结构体属性的值
    name := v.Elem().FieldByName("Name")
    name.SetString("小李")
    age := v.Elem().FieldByName("Age")
    age.SetInt(22)
}
func main() {
    stu1 := Student{
        Name:  "小明",
        Age:   15,
        Score: 98,
    }
    // PrintStructField(stu1)
    reflectChangeStruct(&stu1)
    fmt.Printf("%#v\n", stu1) //main.Student{Name:"小李", Age:22, Score:98}
}