伪网站建站,seo的工作内容,如何运营一个公众号,网站如何投放广告reflect 包的核心概念
Go 中的反射涉及两个核心概念#xff1a;
Type#xff1a;表示一个类型的结构体#xff0c;reflect.Type 是类型的描述。Value#xff1a;表示一个值的结构体#xff0c;reflect.Value 是一个具体值的包装。
反射让我们能够动态地访问对象的类型和…reflect 包的核心概念
Go 中的反射涉及两个核心概念
Type表示一个类型的结构体reflect.Type 是类型的描述。Value表示一个值的结构体reflect.Value 是一个具体值的包装。
反射让我们能够动态地访问对象的类型和数据并根据需要对其进行操作。
常用类型
reflect.Type
reflect.Type 是对 Go 类型的描述。可以通过它获取有关类型的信息比如类型名、类型的种类、是否是指针、结构体的字段等。
常见方法
t.Kind()获取 reflect.Type 的底层类型如 int、struct、slice 等。t.Name()获取类型的名称仅对命名类型有效。t.NumField()获取结构体类型的字段数。t.Field(i)获取结构体的第 i 个字段。
reflect.Value
reflect.Value 代表一个变量的值它包含了具体的值可以通过它获取或修改数据。
常见方法
v.Kind()获取 reflect.Value 的底层类型如 int、struct、slice 等。v.Interface()将 reflect.Value 转换为 interface{} 类型。v.Set()修改 reflect.Value 的值需要是可修改的即传入指针。v.Type()获取 reflect.Value 的类型。v.String()获取 reflect.Value 的字符串表示。
常见的反射操作
获取类型和值
使用 reflect.TypeOf 获取类型使用 reflect.ValueOf 获取值。
package mainimport (fmtreflect
)func main() {var x int 42// 获取类型t : reflect.TypeOf(x)// 获取值v : reflect.ValueOf(x)fmt.Println(Type:, t) // 输出Type: intfmt.Println(Value:, v) // 输出Value: 42
}动态修改值
reflect 允许我们在运行时动态修改值。要修改值必须传递指向变量的指针。
package mainimport (fmtreflect
)func main() {var x int 42p : reflect.ValueOf(x) // 传入指针// 修改值p.Elem().SetInt(100)fmt.Println(Modified value:, x) // 输出Modified value: 100
}获取结构体字段
使用 reflect 获取结构体字段名和值。
package mainimport (fmtreflect
)type Person struct {Name stringAge int
}func printStructFields(s interface{}) {val : reflect.ValueOf(s)if val.Kind() reflect.Struct {for i : 0; i val.NumField(); i {field : val.Field(i)fmt.Printf(%s: %v\n, val.Type().Field(i).Name, field)}}
}func main() {p : Person{Alice, 30}printStructFields(p)
}使用反射调用方法
反射不仅可以获取类型和值还能动态调用方法。
package mainimport (fmtreflect
)type Person struct {Name string
}func (p *Person) SayHello() {fmt.Println(Hello, my name is, p.Name)
}func main() {p : Person{Name: Alice}// 获取反射对象v : reflect.ValueOf(p)// 获取方法并调用method : v.MethodByName(SayHello)method.Call(nil)
}反射与类型断言的对比
类型断言与反射在用途上有很大区别
类型断言通常用于接口类型的断言快速检查和转换接口类型为具体类型。reflect允许动态地操作类型和值可以用于获取更多类型信息或修改值。
示例类型断言
package mainimport fmtfunc printType(i interface{}) {if str, ok : i.(string); ok {fmt.Println(String:, str)} else if num, ok : i.(int); ok {fmt.Println(Integer:, num)} else {fmt.Println(Unknown type)}
}func main() {printType(Hello)printType(42)printType(3.14)
}示例使用 reflect 获取类型和值
package mainimport (fmtreflect
)func main() {var x interface{} 42v : reflect.ValueOf(x)t : reflect.TypeOf(x)fmt.Println(Type:, t) // 输出Type: intfmt.Println(Value:, v) // 输出Value: 42
}总结类型断言与反射对比
特性类型断言reflect 包用途用于接口类型的类型转换用于动态类型检查、修改值、获取字段等性能高效编译时确定类型较慢涉及运行时类型解析语法简洁性简单直观语法较复杂类型安全类型安全编译时检查无类型安全运行时可能出错灵活性灵活性较低仅适用于接口类型断言高度灵活可动态修改、调用方法等 案例
package _caseimport (fmtreflect
)type student struct {Name string json:name,omitempty db:name2Age int json:age,omitempty // omitempty Zero-Value不序列化
}type User struct {Id intName stringAge int
}// 匿名字段
type Boy struct {UserAddr string
}func (u User) Hello(name string) {fmt.Println(hello, name)
}func ReflectCase1() {//reflectTest1()//reflectType(cz)//reflectValue(55.6)//reflectTest2()//u : User{1, chen, 18}//Poni(u)//m : Boy{User{1, sa, 20}, bj}//reflectTest3(m)//fmt.Println(u)//setValue(u)//fmt.Println(u)//userMethod(u)//var s student//getTag(s)
}func getTag(o any) {v : reflect.ValueOf(o)// 返回reflect.TypeOf类型t : v.Type()// 获取字段for i : 0; i t.Elem().NumField(); i {f : t.Elem().Field(i)fmt.Print(f.Tag.Get(json), \t)fmt.Println(f.Tag.Get(db))}
}func userMethod(o any) {v : reflect.ValueOf(o)// 获取方法m : v.MethodByName(Hello)// 有参数的话需要传一个Value类型切片args : []reflect.Value{reflect.ValueOf(666)}// 没有参数只需要var args []reflect.Value// m.Call()m.Call(args)
}func setValue(o any) {v : reflect.ValueOf(o)// 获取指针指向的元素v v.Elem()// 取字段f : v.FieldByName(Name)if f.Kind() reflect.String {f.SetString(zhen)}
}func reflectTest3(o any) {t : reflect.TypeOf(o)fmt.Println(t)// Anoymous:匿名fmt.Printf(%#v\n, t.Field(0))// 值信息fmt.Printf(%#v\n, reflect.ValueOf(o).Field(0))
}func Poni(o any) {t : reflect.TypeOf(o)fmt.Println(类型, t)fmt.Println(字符串类型, t.Name())// 获取值v : reflect.ValueOf(o)fmt.Println(v)// 获取所有属性for i : 0; i t.NumField(); i {f : t.Field(i)fmt.Printf(%s : %v, , f.Name, f.Type)// 获取字段值信息val : v.Field(i).Interface()fmt.Println(val:, val)}fmt.Println(method)for i : 0; i t.NumMethod(); i {m : t.Method(i)fmt.Println(m.Name)fmt.Println(m.Type)}
}// 在处理处理少量已知类型时使用类型断言switch性能更好reflect性能低
// 相较于使用interface{} switch 类型推断处理结构体时无法获取详细的字段或标签信息。
// reflect处理复杂结构体内的字段具有优势可以获取结构体的字段、标签、方法等详细信息。
// reflect使用场景处理大量动态、未知的复杂数据类型且这些类型在编译时无法预知使用 reflect 可以在运行时获取这些类型信息
// 实现通用代码
func reflectTest2() {stu : student{Name: chenzhen,Age: 19,}v : reflect.ValueOf(stu)// 获取struct字段数量fmt.Println(NumFields:, v.NumField())// 获取字段Name值:// 1.v.Field(指定字段序号) - 适用于不知道字段名或者结合for遍历操作// 2.v.FieldByName(指定字段名) - 适用于知道字段名fmt.Println(Name value:, v.Field(0).String(), , , v.FieldByName(Name).String())// 字段类型fmt.Println(Name type:, v.Field(0).Type())t : reflect.TypeOf(stu)for i : 0; i t.NumField(); i {// 获取字段名name : t.Field(i).Namefmt.Println(Field Name:, name)// 获取tagif fieldName, ok : t.FieldByName(name); ok {tag : fieldName.Tagfmt.Println(tag-, tag, , , json:, tag.Get(json), , id, tag.Get(id))}}
}func reflectTest1() {x : 1.2345fmt.Println(TypeOf)// TypeOf()返回接口中保存值的类型t : reflect.TypeOf(x)fmt.Println(type:, t)fmt.Println(kind:, t.Kind())fmt.Println(ValueOf)v : reflect.ValueOf(x)fmt.Println(value:, v)fmt.Println(type:, v.Type())fmt.Println(kind:, v.Kind())// Float传入一个Value类型值返回一个float64类型fmt.Println(value:, v.Float())z : v.Interface() // Interface()返回一个any类型值fmt.Println(z)fmt.Printf(value is %g\n, z)x1 : []int{1, 2, 3}v1 : reflect.ValueOf(x1)fmt.Println(type:, v1.Type())fmt.Println(kind:, v1.Kind())x2 : map[string]string{test1: 1, test2: 2}v2 : reflect.ValueOf(x2)fmt.Println(type:, v2.Type())fmt.Println(kind:, v2.Kind())fmt.Println(kind)// Kind()返回类型种类与Type()区别为如下案例Kind返回更底层type MyInt intm : MyInt(5)v3 : reflect.ValueOf(m)fmt.Println(type:, v3.Type())fmt.Println(kind:, v3.Kind())
}func reflectType(a any) {t : reflect.TypeOf(a)fmt.Println(类型是, t)// kind()获取具体类型k : t.Kind()fmt.Println(k)switch k {case reflect.Float64:fmt.Println(a is float64)case reflect.String:fmt.Println(string)default:panic(unhandled default case)}
}func reflectValue(a any) {v : reflect.ValueOf(a)fmt.Println(v)fmt.Println(v.Type())switch k : v.Kind(); k {case reflect.Float64:fmt.Println(a is , v.Float())default:panic(unhandled default case)}
} package _caseimport (errorsfmtreflect
)func ReflectCase2() {type user struct {ID int64Name stringHobby []string}type outUser struct {ID int64Name stringHobby []string}u : user{ID: 1, Name: nick, Hobby: []string{篮球, 羽毛球}}out : outUser{}// 需求1使用reflect动态copy structrs : copy(out, u)fmt.Println(rs, out)// 需求2sliceUser : []user{{ID: 1, Name: nick, Hobby: []string{篮球, 羽毛球}},{ID: 2, Name: nick1, Hobby: []string{篮球1, 羽毛球1}},{ID: 3, Name: nick2, Hobby: []string{篮球2, 羽毛球2}},}slice : sliceColumn(sliceUser, Hobby)fmt.Println(slice)
}// 从一个切片或结构体中提取指定字段colu的值并返回一个包含这些值的切片
// 每次 t t.Elem() 或 v v.Elem() 都是为了处理某一层的指针解引用问题以便获取实际的值或类型。
// 如果传入的切片类型涉及指针例如 *[]*Struct就需要多次解引用才能得到实际的元素类型和值。// 对于四次t t.Elem()解释
// reflect.Elem()顾名思义是取得变量的元素部分
// 在Golang中变量的元素部分指的是指针指向的变量本身。
// 第一个 t t.Elem() 处理传入 slice 是指针的情况。
// 第二个 t t.Elem() 获取切片元素的类型。
// 第三个 t t.Elem() 处理切片元素是指针的情况获取指针指向的实际类型。
// o.Elem() 处理遍历时元素是指针的情况解引用以访问字段。// 我的理解对于
//
// if t.Kind() reflect.Ptr {
// t t.Elem()
// v v.Elem()
// }
// 第一个t t.Elem()这是为了处理传入时传入的是切片地址的情况如果传入的 slice 不是指针比如 []Struct这一段代码不会执行因此不会影响后面的逻辑。
// 而如果传入的是切片则会在第二个t t.Elem()生效这是因为切片打印出来是指向其第一个元素的地址我们要的是其值
// 所以要t t.Elem()而接下来的
// if t.Kind() reflect.Ptr {
// t t.Elem()
// }则是为了应对其在切片内部还有一个切片指针的情况需要获取其值而最后的
// if o.Kind() reflect.Ptr {
// v1 : o.Elem()
// val : v1.FieldByName(colu)
// s reflect.Append(s, val)
// }则是处理切片中的切片中的field中指针的情况。
func sliceColumn(slice any, colu string) any {t : reflect.TypeOf(slice)v : reflect.ValueOf(slice)// 因为这里传入一个切片切片值为指向其第一个元素的地址所以要elemif t.Kind() reflect.Ptr {t t.Elem()v v.Elem()}// 如果直接传入的slice是一个结构体那么直接返回要找的colu对应值if v.Kind() reflect.Struct {val : v.FieldByName(colu)return val.Interface()}// 处理切片情况if v.Kind() ! reflect.Slice {return nil}t t.Elem()// 如果还是一个指针要找value我们期望他是一个structif t.Kind() reflect.Ptr {t t.Elem()}f, _ : t.FieldByName(colu)// 获取要找字段的类型sliceT : reflect.SliceOf(f.Type)// 根据类型创建切片s : reflect.MakeSlice(sliceT, 0, 0)for i : 0; i v.Len(); i {// index(i)返回v持有值的第i个元素。如果v的Kind不是Array、Chan、Slice、String或者i出界会panico : v.Index(i)if o.Kind() reflect.Struct {val : o.FieldByName(colu)s reflect.Append(s, val)}if o.Kind() reflect.Ptr {v1 : o.Elem()val : v1.FieldByName(colu)s reflect.Append(s, val)}}return s.Interface()
}func copy(dest any, source any) error {// 对sorece的reflect处理sT : reflect.TypeOf(source)sV : reflect.ValueOf(source)// 但是如果source传入的是指针那么还要多操作一次获取它的值if sT.Kind() reflect.Ptr {sT sT.Elem()sV sV.Elem()}// 对于dest的reflect处理dT : reflect.TypeOf(dest)dV : reflect.ValueOf(dest)// 因为dest要被修改所以传入的一定是指针if dT.Kind() ! reflect.Ptr {return errors.New(target对象必须为指针类型)}dT dT.Elem()dV dV.Elem()// source必须为struct或者struct指针if sV.Kind() ! reflect.Struct {return errors.New(sorce必须为struct或者struct指针)}// dest必须为struct指针if dV.Kind() ! reflect.Struct {return errors.New(dest对象必须为struct指针)}// New()返回一个Value类型值该值持有一个指向类型为传入类型的新申请的零值的指针返回值的Type为PtrTo(typ)// 这里destObj是待复制对象所以new出zero-valuedestObj : reflect.New(dT)for i : 0; i dT.NumField(); i {// 每字段dField : dT.Field(i)if sField, ok : sT.FieldByName(dField.Name); ok {if dField.Type ! sField.Type {continue}// 取sV中与dField.Name同名的Value赋给valuevalue : sV.FieldByName(dField.Name)// 设置destObj指针对应dField.Name的字段的值为valuedestObj.Elem().FieldByName(dField.Name).Set(value)}}dV.Set(destObj.Elem())// error nilreturn nil
}
