Golang那些违背直觉的编程陷阱

2024-04-22 06:20

本文主要是介绍Golang那些违背直觉的编程陷阱,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

目录

知识点1:切片拷贝之后都是同一个元素

知识点2:方法集合决定接口实现,类型方法集合是接口方法集合的超集则认定为实现接口,否则未实现接口


切片拷贝之后都是同一个元素
package mainimport ("encoding/json""fmt"
)func arr1() {var nn []intfor i := 0; i < 5; i++ {nn = append(nn, i)}marshal, _ := json.Marshal(nn)// [0,1,2,3,4]fmt.Println(string(marshal))
}func arr2() {var nn []*intfor i := 0; i < 5; i++ {// 出错原因:每次都是i的地址,i的地址始终是一个,所以最终数组元素是5// 解决方法,每次新生命一个变量,之后使用每次新分配的变量进行赋值。参见arr3nn = append(nn, &i)}//[5,5,5,5,5]marshal, _ := json.Marshal(nn)fmt.Println(string(marshal))
}func arr3() {var nn []*intfor i := 0; i < 5; i++ {// s := inn = append(nn, &s)}marshal, _ := json.Marshal(nn)//[0,1,2,3,4]fmt.Println(string(marshal))
}func main() {arr1()arr2()arr3()
}

主要看一下arr2与arr3函数即可知晓,很好理解却又很容易疏忽。接下来看一个类似问题的变种,跟struct方法有关系示例:

package mainimport ("fmt""time"
)type field struct {name string
}func (p *field) print() {fmt.Println(p.name)
}func main() {data1 := []*field{{"one"}, {"two"}, {"three"}}for _, v := range data1 {go v.print()}data2 := []field{{"four"}, {"five"}, {"six"}}for _, v := range data2 {go v.print()}time.Sleep(3 * time.Second)
}

| 这个代码执行输出结果:

看到结果是不是很意外,为什么有3个six呢?接下来分下一下:由于field的print方法是指针类型,所以data2每次在调用print方法时都是v指向的内存对象,这个对象最后一次赋值是six,所以输出的是3个six(其实此处存在不确定性,main协程与子协程的调度顺序,如果每次调度main协程之后立马就去调度子协程可能结果就是正确的了)。

那怎么修复问题呢?

方法1:

将filed的print方法的接受者修改为值类型,这样每次调用时都会拷贝一个副本进行调用,就会背面这个问题了,具体如下:

func (p field) print() {fmt.Println(p.name)
}

方法2:

每次调用时重新声明一个变量进行调用,这个底层原理也是拷贝一个副本进行调用,具体修改如下:

package mainimport ("fmt""time"
)type field struct {name string
}func (p *field) print() {fmt.Println(p.name)
}func main() {data1 := []*field{{"one"}, {"two"}, {"three"}}for _, v := range data1 {go v.print()}data2 := []field{{"four"}, {"five"}, {"six"}}for _, v := range data2 {replica := v// 此处每次都是重新分配一个内存存储v的副本go replica.print()}time.Sleep(3 * time.Second)
}
方法集合决定接口实现,类型方法集合是接口方法集合的超集则认定为实现接口,否则未实现接口
package mainimport ("fmt""reflect"
)type Interface interface {M1()M2()
}type T struct{}func (t T) M1()  {}
func (t *T) M2() {}func DumpMethodSet(i interface{}) {v := reflect.TypeOf(i)elemTyp := v.Elem()n := elemTyp.NumMethod()if n == 0 {fmt.Printf("%s's method set is empty!\n", elemTyp)return}fmt.Printf("%s's method set:\n", elemTyp)for j := 0; j < n; j++ {fmt.Println("-", elemTyp.Method(j).Name)}fmt.Printf("\n")
}
func main() {var t Tvar pt *Tvar i Interface//Cannot use 't' (type T) as type Interface//Type does not implement 'Interface' as 'M2' method has a pointer receiver// 言外之意就是类型T没有实现接口的M2方法i = ti = pt
}

此处主要需要了解Go方法集合规范是什么才能更好解释问题。如下工具方法可以用于查看类型的方法集合,具体代码如下:

func DumpMethodSet(i interface{}) {v := reflect.TypeOf(i)elemTyp := v.Elem()n := elemTyp.NumMethod()if n == 0 {fmt.Printf("%s's method set is empty!\n", elemTyp)return}fmt.Printf("%s's method set:\n", elemTyp)for j := 0; j < n; j++ {fmt.Println("-", elemTyp.Method(j).Name)}fmt.Printf("\n")
}

调用:

var t T
var pt *T
DumpMethodSet(&t)
DumpMethodSet(&pt)
DumpMethodSet((*Interface)(nil))

输出:

因为T类型的方法集合只有M1,所以导致上面将T类型实例赋值给接口类型会报错。

重点:Golang方法集合规范

1. 对于非接口类型的自定义类型T,其方法集合由所有receiver为T类型的方法组成;

2. 而类型*T的方法集合则包含所有receiver为T和*T类型的方法。也正因为如此,pt才能成功赋值给Interface类型变量。

特别提示:在进行组合时候,内嵌的是指针或值类型的结构体所以涉及引入的方法集是不一样的,也遵循上面规范。一般来说内嵌指针的方法集大于等于值得方法集。参见代码:

package mainimport "51788.net/golang-day01/dump_method_set"//main.T1's method set:
//- T1M1
//- T1M2//*main.T1's method set:
//- PT1M3
//- T1M1
//- T1M2
type T1 struct{}func (T1) T1M1()   { println("T1's M1") }
func (T1) T1M2()   { println("T1's M2") }
func (*T1) PT1M3() { println("PT1's M3") }//main.T2's method set:
//- T2M1
//- T2M2
//
//*main.T2's method set:
//- PT2M3
//- T2M1
//- T2M2
type T2 struct{}func (T2) T2M1()   { println("T2's M1") }
func (T2) T2M2()   { println("T2's M2") }
func (*T2) PT2M3() { println("PT2's M3") }//main.T's method set:
//- PT2M3
//- T1M1
//- T1M2
//- T2M1
//- T2M2
//
//*main.T's method set:
//- PT1M3
//- PT2M3
//- T1M1
//- T1M2
//- T2M1
//- T2M2
type T struct {T1*T2
}func main() {t := T{T1: T1{},T2: &T2{},}pt := &tvar t1 T1var pt1 *T1dump_method_set.DumpMethodSet(&t1)dump_method_set.DumpMethodSet(&pt1)var t2 T2var pt2 *T2dump_method_set.DumpMethodSet(&t2)dump_method_set.DumpMethodSet(&pt2)dump_method_set.DumpMethodSet(&t)dump_method_set.DumpMethodSet(&pt)
}

结论:

  • T类型的方法集合 = T1的方法集合 + *T2的方法集合;
  • *T类型的方法集合 = *T1的方法集合 + *T2的方法集合。
接口方法覆盖
package mainimport "51788.net/golang-day01/dump_method_set"type Interface1 interface {M1()
}type Interface2 interface {M1()M2()
}type Interface3 interface {Interface1Interface2 // Go 1.14之前版本报错:duplicate method M1
}type Interface4 interface {Interface2M2() // Go 1.14之前版本报错:duplicate method M2
}func main() {dump_method_set.DumpMethodSet((*Interface3)(nil))
}

在golang1.14版本之后允许接口中相同方法的覆盖。

类型里面内嵌多个接口,多个接口方法集合存在交集

当多个接口方法存在交集时,交集方法必须在类型上进行显示实现,否则调用交集方法时会报错。(当然如果不显示实现,而且后续不调用交集方法的话也不会报错。如果使用交集方法就要一定在类型上实现交集方法)。

示例1:

package mainimport "fmt"type IRun1 interface {M1()M2()
}type IRun2 interface {M2()M3()
}type IRun1Impl struct{}func (IRun1Impl) M1() {fmt.Println(" (IRun1Impl) M1()")
}func (IRun1Impl) M2() {fmt.Println(" (IRun1Impl) M2()")
}type IRun2Impl struct{}func (IRun2Impl) M2() {fmt.Println(" (IRun2Impl) M2()")
}func (IRun2Impl) M3() {fmt.Println(" (IRun2Impl) M3()")
}type TRun struct {IRun1IRun2
}func (e TRun) M1() {fmt.Println("t m1")
}// 一定在类型上实现交集方法
func (e TRun) M2() {fmt.Println("t m2")
}func main() {e := TRun{IRun1: &IRun1Impl{},IRun2: &IRun2Impl{},}e.M1()e.M2()e.M3()//	输出://t m1//t m2// (IRun2Impl) M3()
}

示例2:

package mainimport "fmt"type IRun1 interface {M1()M2()
}type IRun2 interface {M2()M3()
}type IRun1Impl struct{}func (IRun1Impl) M1() {fmt.Println(" (IRun1Impl) M1()")
}func (IRun1Impl) M2() {fmt.Println(" (IRun1Impl) M2()")
}type IRun2Impl struct{}func (IRun2Impl) M2() {fmt.Println(" (IRun2Impl) M2()")
}func (IRun2Impl) M3() {fmt.Println(" (IRun2Impl) M3()")
}type TRun struct {IRun1IRun2
}func (e TRun) M1() {fmt.Println("t m1")
}func main() {e := TRun{IRun1: &IRun1Impl{},IRun2: &IRun2Impl{},}e.M1()// 不在类型上声明M2方法,虽然两个接口都有声明M2方法,但是也会报错:// 编译器报错:Ambiguous reference 'M2'e.M2()e.M3()}

示例三:

package mainimport "fmt"type IRun1 interface {M1()M2()
}type IRun2 interface {M2()M3()
}type IRun1Impl struct{}func (IRun1Impl) M1() {fmt.Println(" (IRun1Impl) M1()")
}func (IRun1Impl) M2() {fmt.Println(" (IRun1Impl) M2()")
}type IRun2Impl struct{}func (IRun2Impl) M2() {fmt.Println(" (IRun2Impl) M2()")
}func (IRun2Impl) M3() {fmt.Println(" (IRun2Impl) M3()")
}type TRun struct {IRun1IRun2
}func (e TRun) M1() {fmt.Println("t m1")
}func main() {e := TRun{IRun1: &IRun1Impl{},IRun2: &IRun2Impl{},}e.M1()// 虽然没有在类型上声明M2方法,但是不调用M2方法的话也不会存在编译错误// 满足原则:你用你写,不用不写(u can u up)//e.M2()e.M3()
}

小提示:现实中应该避免这种复杂编程,显然无疑的提高了问题复杂度,并无显著收益。

类型里面内嵌接口

type InterfaceX interface {M1()M2()
}type TS struct {InterfaceX
}func (TS) M3() {}

类型TS内嵌接口InterfaceX是允许的,而且编译器不要求强制必须实现M1与M2方法,这个如果有Java经验的话会很违背经验。但是Golang就是允许的,但是如果你调用未实现的方法就会报错:

func main() {var t TSt.M1()
}

查看一下方法集合:

func main() {dump_method_set.DumpMethodSet((*InterfaceX)(nil))var t TSvar pt *TSdump_method_set.DumpMethodSet(&t)dump_method_set.DumpMethodSet(&pt)
}

输出:

类型中内嵌接口,命名冲突的方法调用优先级
package maintype Interface interface {M1()M2()
}type T struct {Interface
}// 类型T上实现了接口M1方法,但是类型T未实现M2方法
func (T) M1() {println("T's M1")
}type S struct{}func (S) M1() {println("S's M1")
}
func (S) M2() {println("S's M2")
}func main() {var t = T{Interface: S{},}// 因为类型实现了M1方法,所以直接调用M1的方法t.M1()// 因为接口类型没有实现M2方法,所以调用会从内嵌的接口上寻找方法t.M2()
}

这篇关于Golang那些违背直觉的编程陷阱的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/925007

相关文章

golang版本升级如何实现

《golang版本升级如何实现》:本文主要介绍golang版本升级如何实现问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录golanwww.chinasem.cng版本升级linux上golang版本升级删除golang旧版本安装golang最新版本总结gola

golang中reflect包的常用方法

《golang中reflect包的常用方法》Go反射reflect包提供类型和值方法,用于获取类型信息、访问字段、调用方法等,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值... 目录reflect包方法总结类型 (Type) 方法值 (Value) 方法reflect包方法总结

Go语言数据库编程GORM 的基本使用详解

《Go语言数据库编程GORM的基本使用详解》GORM是Go语言流行的ORM框架,封装database/sql,支持自动迁移、关联、事务等,提供CRUD、条件查询、钩子函数、日志等功能,简化数据库操作... 目录一、安装与初始化1. 安装 GORM 及数据库驱动2. 建立数据库连接二、定义模型结构体三、自动迁

Golang如何对cron进行二次封装实现指定时间执行定时任务

《Golang如何对cron进行二次封装实现指定时间执行定时任务》:本文主要介绍Golang如何对cron进行二次封装实现指定时间执行定时任务问题,具有很好的参考价值,希望对大家有所帮助,如有错误... 目录背景cron库下载代码示例【1】结构体定义【2】定时任务开启【3】使用示例【4】控制台输出总结背景

Golang如何用gorm实现分页的功能

《Golang如何用gorm实现分页的功能》:本文主要介绍Golang如何用gorm实现分页的功能方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录背景go库下载初始化数据【1】建表【2】插入数据【3】查看数据4、代码示例【1】gorm结构体定义【2】分页结构体

在Golang中实现定时任务的几种高效方法

《在Golang中实现定时任务的几种高效方法》本文将详细介绍在Golang中实现定时任务的几种高效方法,包括time包中的Ticker和Timer、第三方库cron的使用,以及基于channel和go... 目录背景介绍目的和范围预期读者文档结构概述术语表核心概念与联系故事引入核心概念解释核心概念之间的关系

SpringBoot开发中十大常见陷阱深度解析与避坑指南

《SpringBoot开发中十大常见陷阱深度解析与避坑指南》在SpringBoot的开发过程中,即使是经验丰富的开发者也难免会遇到各种棘手的问题,本文将针对SpringBoot开发中十大常见的“坑... 目录引言一、配置总出错?是不是同时用了.properties和.yml?二、换个位置配置就失效?搞清楚加

Golang 日志处理和正则处理的操作方法

《Golang日志处理和正则处理的操作方法》:本文主要介绍Golang日志处理和正则处理的操作方法,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考... 目录1、logx日志处理1.1、logx简介1.2、日志初始化与配置1.3、常用方法1.4、配合defer

golang float和科学计数法转字符串的实现方式

《golangfloat和科学计数法转字符串的实现方式》:本文主要介绍golangfloat和科学计数法转字符串的实现方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望... 目录golang float和科学计数法转字符串需要对float转字符串做处理总结golang float

golang实现延迟队列(delay queue)的两种实现

《golang实现延迟队列(delayqueue)的两种实现》本文主要介绍了golang实现延迟队列(delayqueue)的两种实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的... 目录1 延迟队列:邮件提醒、订单自动取消2 实现2.1 simplChina编程e简单版:go自带的time