go泛型实现方式遐想

### 为了绕开反射的慢性能和go无泛型以及接口断言的慢性能，下面提供一种方式给大伙，我想这会开拓大伙的一些思维，转发需注明原著连接，谢谢！ ### 主要是利用了组合的原理来实现的，下面直接给出代码，欢迎大伙评论。 ``` package main import "fmt" type Person struct { name string age int } type Animal struct { name string age int } //如果无泛型，我们需要下面这些累赘 //func (p Person) getName() string { // return p.name //} // //func (p Person) getAge() int { // return p.age //} // //func (a Animal) getName() string { // return a.name //} // //func (a Animal) getAge() int { // return a.age //} //下面是泛型，我们注释掉上面的几个方法 type Biological struct { _type string *Person *Animal } func (b Biological) getName() (name string) { switch b._type { //针对不同的类型做不同的事情 case "Person": name= b.Person.name case "Animal": name= b.Animal.name } return } func (b Biological) getAge() (age int) { switch b._type { //针对不同的类型做不同的事情 case "Person": age= b.Person.age case "Animal": age= b.Animal.age } return } //下面是接收泛型的处理函数 func testFun(b *Biological) { fmt.Println(b.getName()) fmt.Println(b.getAge()) } //下面是将具体的类型转成泛型类型实例的函数 func newGeneric(s string,p *Person,a *Animal) *Biological { return &Biological{ _type: s, Person: p, Animal: a, } } func main() { var p = Person{ name: "ppp", age: 10, } testFun(newGeneric("Person",&p,nil)) fmt.Println("--------------") var a = Animal{ name: "AAA", age: 20, } testFun(newGeneric("Animal",nil,&a)) } ``` ### 下面给出代码截图方便查看：    ### 这个应该是比反射的性能要好很多，特别是在并发函数里面，我们应该尽量避免使用反射或者 go库中使用到反射的函数！ ### 为了再说明组合的好处，我们再举个例子如下： ``` package main import "fmt" type T struct { *string *int } //如果不建立泛型则需要像下面这样写，挺累赘的写法！ //func return_string(s string) string { // return s //} //func return_int(i int) int { // return i //} func echo(arg T) T { return arg } func doubleStrOrInt(arg T) T { switch arg.int { case nil: //为string s := *arg.string s += s arg.string = &s default: //为int i := (*arg.int) * 2 arg.int = &i } return arg } func main() { s := "a"//基本类型 arg := T{string: &s}//泛型 str := echo(arg).string//调用接收泛型的函数且回去结果 fmt.Println(*str) ii := 1 arg1 := T{int: &ii} i := echo(arg1).int fmt.Println(*i) //------------ str = doubleStrOrInt(arg).string fmt.Println(*str) i = doubleStrOrInt(arg1).int fmt.Println(*i) } ``` ### 代码截图如下：   ### 为了让读者意识到性能问题，我给出下面的测试： ``` //代码1 package main import ( "fmt" "sync" "time" ) func doubleStrOrInt(arg interface{}) interface{} { switch s := arg.(type) { case string: //为string s += s arg = s case int: //为int i := s * 2 arg = i } return arg } func main() { start := time.Now() s := "a" //基本类型 ii := 1 var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() //故意循环100000次 for k := 0; k < 100000; k++ { _ = doubleStrOrInt(s) //fmt.Println(str) _ = doubleStrOrInt(ii) //fmt.Println(i) } }() wg.Wait() end := time.Now() fmt.Println("耗时：", end.Sub(start)) } ``` ### 截图：  ``` //代码2 package main import ( "fmt" "sync" "time" ) type T struct { *string *int } func doubleStrOrInt(arg T) T { switch arg.int { case nil: //为string s := *arg.string s += s arg.string = &s default: //为int i := (*arg.int) * 2 arg.int = &i } return arg } func main() { start := time.Now() s := "a" //基本类型 arg := T{string: &s} //泛型 ii := 1 arg1 := T{int: &ii} var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() //故意循环100000次 for k := 0; k < 100000; k++ { _ = doubleStrOrInt(arg).string //fmt.Println(*str) _ = doubleStrOrInt(arg1).int //fmt.Println(*i) } }() wg.Wait() end := time.Now() fmt.Println("耗时：", end.Sub(start)) } ``` ### 代码截图：   ### 下面是上面2段代码的执行结果： ## 采用反射与断言的结果是： ## 耗时： 22.4633ms ## 而不采用反射，自定义类似泛型的结构体的执行结果则是： ## 耗时： 6.8349ms