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

这篇具有很好参考价值的文章主要介绍了Golang那些违背直觉的编程陷阱。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

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

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


切片拷贝之后都是同一个元素
package main

import (
	"encoding/json"
	"fmt"
)

func arr1() {
	var nn []int
	for 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 []*int
	for i := 0; i < 5; i++ {
        // 出错原因:每次都是i的地址,i的地址始终是一个,所以最终数组元素是5
        // 解决方法,每次新生命一个变量,之后使用每次新分配的变量进行赋值。参见arr3
		nn = append(nn, &i)
	}
	//[5,5,5,5,5]
	marshal, _ := json.Marshal(nn)
	fmt.Println(string(marshal))
}

func arr3() {
	var nn []*int
	for i := 0; i < 5; i++ {
        // 
		s := i
		nn = 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 main

import (
	"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)
}

| 这个代码执行输出结果:Golang那些违背直觉的编程陷阱,golang,开发语言,后端

看到结果是不是很意外,为什么有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 main

import (
	"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 main

import (
	"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 T
	var pt *T

	var 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 = t
	i = 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))

输出:

Golang那些违背直觉的编程陷阱,golang,开发语言,后端

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

重点:Golang方法集合规范

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

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

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

package main

import "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 := &t

	var t1 T1
	var pt1 *T1
	dump_method_set.DumpMethodSet(&t1)
	dump_method_set.DumpMethodSet(&pt1)

	var t2 T2
	var pt2 *T2
	dump_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 main

import "51788.net/golang-day01/dump_method_set"

type Interface1 interface {
	M1()
}

type Interface2 interface {
	M1()
	M2()
}

type Interface3 interface {
	Interface1
	Interface2 // Go 1.14之前版本报错:duplicate method M1
}

type Interface4 interface {
	Interface2
	M2() // Go 1.14之前版本报错:duplicate method M2
}

func main() {
	dump_method_set.DumpMethodSet((*Interface3)(nil))
}

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

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

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

示例1:

package main

import "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 {
	IRun1
	IRun2
}

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 main

import "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 {
	IRun1
	IRun2
}

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 main

import "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 {
	IRun1
	IRun2
}

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 TS
	t.M1()
}

Golang那些违背直觉的编程陷阱,golang,开发语言,后端

查看一下方法集合:

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

输出:

Golang那些违背直觉的编程陷阱,golang,开发语言,后端文章来源地址https://www.toymoban.com/news/detail-855190.html

类型中内嵌接口,命名冲突的方法调用优先级
package main

type 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那些违背直觉的编程陷阱的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Golang vs Rust ——服务端编程应该选择哪种语言

    为服务端编程选择一种语言应该基于你的长期目标和项目的要求,因此,盲目地问我应该雇用 Go 开发人员还是应该选择 Rust 进行开发并不能帮助你解决问题。 然而,如果你发现自己陷入了困境,那么这篇文章将为你解惑。下面让我们开始吧。 Go 是一种静态类型的、AOT 编译的

    2024年02月02日
    浏览(62)
  • 【Golang】VsCode下开发Go语言的环境配置(超详细图文详解)

    📓推荐网站(不断完善中):个人博客 📌个人主页:个人主页 👉相关专栏:CSDN专栏、个人专栏 🏝立志赚钱,干活想躺,瞎分享的摸鱼工程师一枚 ​ 话说在前,Go语言的编码方式是 UTF-8 ,理论上你直接使用文本进行编辑也是可以的,当然为了提升我们的开发效率我们还是需

    2024年02月07日
    浏览(85)
  • 【Golang星辰图】数据管理利器:Go编程语言中的数据库和搜索引擎综合指南

    Go编程语言是一种强大、类型安全且高效的编程语言,它在处理数据库和搜索引擎方面有着广泛的应用。本篇文章将详细介绍几个Go编程语言中常用的数据库和全文搜索引擎,包括Go-bleve、Go-pgx、Go-leveldb/leveldb、Go-xorm、Go-mysql-driver和Go-bbolt/bbolt。对于每个工具,我们将介绍其功

    2024年03月26日
    浏览(72)
  • 100天精通Golang(基础入门篇)——第15天:深入解析Go语言中函数的应用:从基础到进阶,助您精通函数编程!(进阶)

    🌷 博主 libin9iOak带您 Go to Golang Language.✨ 🦄 个人主页——libin9iOak的博客🎐 🐳 《面试题大全》 文章图文并茂🦕生动形象🦖简单易学!欢迎大家来踩踩~🌺 🌊 《IDEA开发秘籍》学会IDEA常用操作,工作效率翻倍~💐 🪁 希望本文能够给您带来一定的帮助🌸文章粗浅,敬请批

    2024年02月12日
    浏览(68)
  • Golang网络编程

    Golang网络编程 网络编程简介 网络编程协议 网络分层模型 TCP/IP协议 什么是DNS 套接字(Socket) 客户端服务器模型 TCP/UDP的区别 HTTP协议 会话session Cookie https HTTP请求格式 HTTP响应格式 http头信息 http请求头信息 http响应头信息 HTTP状态码 http内容类型和内容编码 Golang网络编程 Gol

    2024年02月10日
    浏览(42)
  • Golang 并发编程详解

    并发是现代软件开发中的一个重要概念,它允许程序同时执行多个任务,提高系统的性能和响应能力。Golang 是一门天生支持并发的语言,它通过 goroutine 和 channel 提供了强大的并发编程支持。 在本文中,我们将深入探讨 Golang 中的并发编程,了解 goroutine、channel 以及一些常见

    2024年01月23日
    浏览(45)
  • 深入理解 Golang: 网络编程

    关于计算机网络分层与 TCP 通信过程过程此处不再赘述。 考虑到 TCP 通信过程中各种复杂操作,包括三次握手,四次挥手等,多数操作系统都提供了 Socket 作为 TCP 网络连接的抽象。 Linux - Internet domain socket - SOCK_STREAM Linux 中 Socket 以 “文件描述符” FD 作为标识 在进行 Socket 通

    2024年02月11日
    浏览(42)
  • Golang之路---04 并发编程——WaitGroup

    为了保证 main goroutine 在所有的 goroutine 都执行完毕后再退出,前面使用了 time.Sleep 这种简单的方式。 由于写的 demo 都是比较简单的, sleep 个 1 秒,我们主观上认为是够用的。 但在实际开发中,开发人员是无法预知,所有的 goroutine 需要多长的时间才能执行完毕,sleep 多了,

    2024年02月14日
    浏览(36)
  • 编程笔记 Golang基础 012 项目构建

    如何构建和组织一个项目,是学习该语言编程的开始。 Go 语言中的模块(Module)、包(Package)和文件有着紧密的关系,它们共同构成了 Go 语言的代码组织结构和依赖管理机制: 模块(Module) : Go 语言从 1.11 版本开始引入了模块系统,用于管理和解决依赖问题。 模块是一个

    2024年02月21日
    浏览(40)
  • golang网络编程学习-TCP

    golang网络编程学习-TCP 网络编程主要的内容是: 1.TCP网络编程 2.http服务 3.rpc服务 4.websocket服务   golang网络编程学习-TCP 一、TCP/IP TCP/IP是一种协议簇,它是网络通信的基础,是互联网的核心协议,负责数据在网络中的传输。它包括TCP和IP两个协议,TCP提供数据报传输的可靠性,

    2024年02月16日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包