Go语言学习之反射的用法详解_Golang_

package main import ( "fmt" "reflect" ) func Test(i interface{}) { //反射数据类型 t := reflect.TypeOf(i) fmt.Println("类型是", t) //反射数据值 v := reflect.ValueOf(i) fmt.Println("值是", v) } func main() { a := "hello" Test(a) }

package main import ( "fmt" "reflect" ) type Student struct { Name string Age int Score float32 } func Test(i interface{}) { //反射获取类型 t := reflect.TypeOf(i) fmt.Println("类型是", t) //反射获取值 v := reflect.ValueOf(i) //判断值的类别 c := v.Kind() fmt.Println("类别是", c) } func main() { var stu Student = Student{ Name: "张三", Age: 18, Score: 80, } Test(stu) fmt.Println("-------------") var num int = 10 Test(num) }

package main import ( "fmt" "reflect" ) type Student struct { Name string Age int Score float32 } func Test(i interface{}) { t := reflect.TypeOf(i) fmt.Println("类型是", t) //类别 v := reflect.ValueOf(i) c := v.Kind() fmt.Println("类别是", c) fmt.Printf("c的类型是%T\n", c) fmt.Printf("v的类型是%T\n", v) //转换成接口 iv := v.Interface() fmt.Printf("iv的类型%T\n", iv) //断言处理 stu_iv, err := iv.(Student) if err { fmt.Printf("stu_iv的类型%T\n", stu_iv) } } func main() { var stu Student = Student{ Name: "张三", Age: 18, Score: 80, } Test(stu) }

package main import ( "fmt" "reflect" ) func Test(i interface{}) { v := reflect.ValueOf(i) fmt.Printf("v的类型是%T\n", v) //转换成指定类型 t := v.Int() fmt.Printf("t的类型是%T\n", t) } func main() { //类型不同的话会报错 var num int = 100 Test(num) }

package main import ( "fmt" "reflect" ) func Test(i interface{}) { v := reflect.ValueOf(i) //更新值需要value的地址，否则会保存，Elem()表示指针* v.Elem().SetInt(100) result := v.Elem().Int() fmt.Printf("result类型为 %T, 值为 %d\n", result, result) } func main() { var num int = 10 Test(&num) }

package main import ( "fmt" "reflect" ) //结构体 type Student struct { Name string Age int Score float32 } //结构体方法 func (s Student) Run() { fmt.Println("Running") } func (s Student) Sleep() { fmt.Println("Sleeping") } //使用反射查看结构体字段数量和方法数量 func Test(i interface{}) { v := reflect.ValueOf(i) //类别判断 if v.Kind() != reflect.Struct { fmt.Println("不是结构体") return } //获取结构体中字段数量 stu_num := v.NumField() fmt.Println("字段数量: ", stu_num) //获取结构体中方法数量 stu_meth := v.NumMethod() fmt.Println("方法数量: ", stu_meth) } func main() { var stu Student = Student{ Name: "张三", Age: 18, Score: 88, } Test(stu) }

package main import ( "fmt" "reflect" ) type Student struct { Name string Age int Score float32 } func Test(i interface{}) { v := reflect.ValueOf(i) //获取结构体中每个属性 for i := 0; i < v.NumField(); i++ { //输出属性值 fmt.Printf("%d %v\n", i, v.Field(i)) //输出属性值的类型 fmt.Printf("%d %v\n", i, v.Field(i).Kind()) } } func main() { var stu Student = Student{ Name: "张三", Age: 18, Score: 88, } Test(stu) }

package main import ( "fmt" "reflect" ) type Student struct { Name string Age int Score float32 } func Test(i interface{}, name string) { v := reflect.ValueOf(i) vk := v.Kind() //判断是都为指针并指向结构体类型 if vk != reflect.Ptr && v.Elem().Kind() == reflect.Struct { fmt.Println("expect struct") return } //更改属性值 v.Elem().Field(0).SetString(name) //获取结构体中每个属性 for i := 0; i < v.Elem().NumField(); i++ { //输出属性值 fmt.Printf("%d %v\n", i, v.Elem().Field(i)) //输出属性值的类型 fmt.Printf("%d %v\n", i, v.Elem().Field(i).Kind()) } } func main() { var stu Student = Student{ Name: "张三", Age: 18, Score: 88, } Test(&stu, "李四") }

package main import ( "encoding/json" "fmt" "reflect" ) type Student struct { Name string `json:"stu_name"` Age int Score float32 } func Test(i interface{}, name string) { v := reflect.ValueOf(i) vk := v.Kind() //判断是都为指针并指向结构体类型 if vk != reflect.Ptr && v.Elem().Kind() == reflect.Struct { fmt.Println("expect struct") return } //更改属性值 v.Elem().Field(0).SetString(name) //获取结构体中每个属性 for i := 0; i < v.Elem().NumField(); i++ { //输出属性值 fmt.Printf("%d %v\n", i, v.Elem().Field(i)) //输出属性值的类型 fmt.Printf("%d %v\n", i, v.Elem().Field(i).Kind()) } } func main() { var stu Student = Student{ Name: "张三", Age: 18, Score: 88, } Test(&stu, "李四") fmt.Println("----------------json原信息----------------") result, _ := json.Marshal(stu) fmt.Println("json原信息: ", string(result)) //反射获取类型 st := reflect.TypeOf(stu) s := st.Field(0) fmt.Printf("Name原信息名称: %s\n", s.Tag.Get("json")) } 

package main import ( "fmt" "reflect" ) func hello() { fmt.Println("hello world") } func main() { //反射使用函数 v := reflect.ValueOf(hello) //类型判断是否属于reflect.func类型 if v.Kind() == reflect.Func { fmt.Println("函数") } //反射调用函数 v.Call(nil) //Call中需要传入的是切片 }

package main import ( "fmt" "reflect" "strconv" ) //反射调用传参和返回值函数 func Test(i int) string { return strconv.Itoa(i) } func main() { v := reflect.ValueOf(Test) //定义参数切片 params := make([]reflect.Value, 1) //切片元素赋值 params[0] = reflect.ValueOf(20) //反射调函数 result := v.Call(params) fmt.Printf("result的类型是 %T\n", result) //[]reflect.Value切片转换string s := result[0].Interface().(string) fmt.Printf("s的类型是 %T ,值为 %s\n", s, s) } 

package main import ( "fmt" "reflect" "strconv" ) //反射方法 type Student struct { Name string Age int } //结构体方法 func (s *Student) SetName(name string) { s.Name = name } func (s *Student) SetAge(age int) { s.Age = age } func (s *Student) String() string { return fmt.Sprintf("%p", s) + ",Name:" + s.Name + ",Age:" + strconv.Itoa(s.Age) } func main() 
                
提示：
                    本文由神整理自网络，如有侵权请联系本站删除！
                    

                    本站声明： 

                    1、本站所有资源均来源于互联网，不保证100%完整、不提供任何技术支持； 

                    2、本站所发布的文章以及附件仅限用于学习和研究目的;不得将用于商业或者非法用途；否则由此产生的法律后果，本站概不负责！
                
                

                

                                            
上一篇：Golang中Json的序列化和反序列化的使用_Golang_
                                                                
下一篇：Go语言学习之文件操作方法详解_Golang_