Golang空接口与类型断言的实现

 更新时间:2022年03月25日 09:10:21   作者:蓝色记忆  
本文主要介绍了Golang空接口与类型断言的实现,文中根据实例编码详细介绍的十分详尽,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

空接口

定义

空接口是特殊形式的接口类型,普通的接口都有方法,而空接口没有定义任何方法口,也因此,我们可以说所有类型都至少实现了空接口。

type test interface {
}

每一个接口都包含两个属性,一个是值,一个是类型。

var i interface{}
fmt.Printf("类型:%T----值:%v\n", i, i) //类型:<nil>----值:<nil>

可见对于空接口来说,这两者都是 nil

使用场景

第一,通常我们会直接使用 interface{} 作为类型声明一个实例,而这个实例可以承载任意类型的值。

func main() {
	var i interface{}

	i = 100
	fmt.Println(i) //100

	i = "yif"
	fmt.Println(i) //yif

	i = 3.14
	fmt.Println(i) //3.14

	i = false
	fmt.Println(i) //false
}

第二,如果想让你的函数可以接收任意类型的值 ,也可以使用空接口。如下代码都正常打印:

func main() {
	i := 100
	s := "yif"
	f := 3.14

	test(i)
	test(s)
	test(f)
}

func test(i interface{}) {
	fmt.Println(i)
}

上面写法有点麻烦,可以使用可变参数的函数。如下:

func main() {
	i := 100
	s := "yif"
	f := 3.14

	test(i, s, f)
}

func test(res ...interface{}) {
	fmt.Println(res) //res是切片
	for k, v := range res {
		fmt.Println(k, v)
	}
}

结果:

D:\workspace\go\src\test>go run main.go
[100 yif 3.14]
0 100
1 yif
2 3.14 

第三,你也定义一个可以接收任意类型的 array、slice、map、strcut,例如这边定义一个切片

func main() {
	sli := make([]interface{}, 4)
	sli[0] = 100
	sli[1] = "yif"
	sli[2] = []int{1, 2, 3}
	sli[3] = [...]int{5, 6, 7}
	fmt.Println(sli)
	for k, v := range sli {
		fmt.Println(k, v)
	}
}

结果:

D:\workspace\go\src\test>go run main.go
[100 yif [1 2 3] [5 6 7]]
0 100
1 yif
2 [1 2 3]
3 [5 6 7] 

空接口几个要注意的坑

**第一,**空接口可以承载任意值,但不代表任意类型就可以承接空接口类型的值

空接口类型可以保存任何值,也可以从空接口中取出原值。

但要是你把一个空接口类型的对象,再赋值给一个固定类型(比如 int, string等类型)的对象赋值,是会报错的。

var i interface{} = 100
var t int = i // cannot use i (type interface {}) as type int in assignment: need type assertion

但是你使用短变量声明,是可以的:

var i interface{} = 100
t := i
fmt.Println(t) //100

因为编译器会根据等号右边的值来推导变量的类型完成初始化。

**第二:**当空接口承载数组和切片后,该对象无法再进行切片

sli := []int{1, 2, 3, 4}
var i interface{}
i = sli
fmt.Println(i[1:2]) //cannot slice i (type interface {})

类型断言

类型断言(Type Assertion)是一个使用在接口值上的操作,用于检查接口类型变量所持有的值是否实现了期望的接口或者具体的类型

类型断言,仅能对静态类型为空接口(interface{})的对象进行断言,否则会抛出错误

Go语言中类型断言的两种语法

在Go语言中类型断言的第一种语法格式如下:

t := i.(T)

这个表达式可以断言一个接口对象(i)里不是 nil,并且接口对象(i)存储的值的类型是 T,如果断言成功,就会返回值给 t,如果断言失败,就会触发 panic。

func main() {
	var i interface{} = 100
	t := i.(int)
	fmt.Println(t) //100
	
	fmt.Println("------------------------------------")

	s := i.(string)
	fmt.Println(s)
}

结果【执行第二次断言的时候失败了,并且触发了 panic】:

D:\workspace\go\src\test>go run main.go
100
------------------------------------
panic: interface conversion: interface {} is int, not string

goroutine 1 [running]:
main.main()
        D:/workspace/go/src/test/main.go:32 +0x10e
exit status 2 

如果要断言的接口值是 nil,那我们来看看也是不是也如预期一样会触发panic

var i interface{}
var _ = i.(interface{})

结果:

D:\workspace\go\src\test>go run main.go
panic: interface conversion: interface is nil, not interface {}

goroutine 1 [running]:
main.main()
        D:/workspace/go/src/test/main.go:27 +0x34
exit status 2 

在Go语言中类型断言的另一种语法格式如下:

t, ok:= i.(T)

和上面一样,这个表达式也是可以断言一个接口对象(i)里不是 nil,并且接口对象(i)存储的值的类型是 T,如果断言成功,就会返回其类型给 t,并且此时 ok 的值 为 true,表示断言成功。

如果接口值的类型,并不是我们所断言的 T,就会断言失败,但和第一种表达式不同的事,这个不会触发 panic,而是将 ok 的值设为 false ,表示断言失败,此时t 为 T 的零值。

func main() {
    var i interface{} = 10
    t1, ok := i.(int)
    fmt.Printf("%d-%t\n", t1, ok)

    fmt.Println("=====分隔线1=====")

    t2, ok := i.(string)
    fmt.Printf("%s-%t\n", t2, ok)

    fmt.Println("=====分隔线2=====")

    var k interface{} // nil
    t3, ok := k.(interface{})
    fmt.Println(t3, "-", ok)

    fmt.Println("=====分隔线3=====")
    k = 10
    t4, ok := k.(interface{})
    fmt.Printf("%d-%t\n", t4, ok)

    t5, ok := k.(int)
    fmt.Printf("%d-%t\n", t5, ok)
}

结果【运行后输出如下,可以发现在执行第二次断言的时候,虽然失败了,但并没有触发了 panic】:

D:\workspace\go\src\test>go run main.go
10-true
=====分隔线1=====
-false
=====分隔线2=====
<nil> - false
=====分隔线3=====
10-true
10-true 

上面这段输出,你要注意的是第二个断言的输出在-false 之前并不是有没有输出任何 t2 的值,而是由于断言失败,所以 t2 得到的是 string 的零值也是 "" ,它是零长度的,所以你看不到其输出。

类型断言配合 switch 使用

如果需要区分多种类型,可以使用 type switch 断言。

func main() {
	test(100)
	test("yif")
	test(3.14)
	
	var i interface{} //nil
	test(i)
	
	test(nil)
}

func test(i interface{}) {
	switch r := i.(type) {
	case int:
		fmt.Println(r, "是int型")
	case string:
		fmt.Println(r, "是字符串")
	case nil:
		fmt.Println(r, "是nil")
	default:
		fmt.Println("没有结果!")
	}
}

结果:

D:\workspace\go\src\test>go run main.go
100 是int型
yif 是字符串
没有结果!
<nil> 是nil
<nil> 是nil

 到此这篇关于Golang空接口与类型断言的实现的文章就介绍到这了,更多相关Golang空接口与类型断言内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • Go语言的队列和堆栈实现方法

    Go语言的队列和堆栈实现方法

    这篇文章主要介绍了Go语言的队列和堆栈实现方法,涉及container/list包的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
    2015-02-02
  • GoLang BoltDB数据库详解

    GoLang BoltDB数据库详解

    这篇文章主要介绍了GoLang BoltDB数据库,boltdb是使用Go语言编写的开源的键值对数据库,boltdb存储数据时 key和value都要求是字节数据,此处需要使用到 序列化和反序列化
    2023-02-02
  • Golang使用Gin框架实现路由分类处理请求流程详解

    Golang使用Gin框架实现路由分类处理请求流程详解

    Gin是一个golang的微框架,封装比较优雅,具有快速灵活,容错方便等特点,这篇文章主要介绍了Golang使用Gin框架实现路由分类处理请求,感兴趣的同学可以参考下文
    2023-05-05
  • jenkins配置golang 代码工程自动发布的实现方法

    jenkins配置golang 代码工程自动发布的实现方法

    这篇文章主要介绍了jenkins配置golang 代码工程自动发布,jks是个很好的工具,使用方法也很多,我只用了它简单的功能,对jenkins配置golang相关知识感兴趣的朋友一起看看吧
    2022-07-07
  • 一文深入探讨Go语言中的if-else语句

    一文深入探讨Go语言中的if-else语句

    在Go语言中,条件语句的使用方式相对简洁明了,所以本文将探讨一下如何在Go程序中有效地进行条件判断和逻辑控制,感兴趣的小伙伴可以了解下
    2023-08-08
  • GoLang string与strings.Builder使用对比详解

    GoLang string与strings.Builder使用对比详解

    这篇文章主要介绍了GoLang string与strings.Builder使用对比,Builder 用于使用 Write 方法有效地构建字符串。它最大限度地减少了内存复制。零值可以使用了。不要复制非零生成器
    2023-03-03
  • 使用Go语言开发短链接服务的方法

    使用Go语言开发短链接服务的方法

    短链接一般是通过映射关系,将长长的一串网址,映射到几个字符的短链接上,建立好这种映射关系之后保存到数据库里,用户每次访问短链接的时候,这篇文章主要介绍了使用Go语言开发一个短链接服务,需要的朋友可以参考下
    2024-03-03
  • Go中的函数选项模式(Functional Options Pattern)详解

    Go中的函数选项模式(Functional Options Pattern)详解

    在 Go 语言中,函数选项模式是一种优雅的设计模式,用于处理函数的可选参数,本文将对其进行讲解,准备好了吗,快跟随着本文一探究竟吧
    2023-06-06
  • golang如何自定义json序列化应用详解

    golang如何自定义json序列化应用详解

    son格式可以算我们日常最常用的序列化格式之一了,下面这篇文章主要给大家介绍了关于golang如何自定义json序列化应用的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考借鉴,下面来一起看看吧
    2018-08-08
  • Go语言使用sort包对任意类型元素的集合进行排序的方法

    Go语言使用sort包对任意类型元素的集合进行排序的方法

    这篇文章主要介绍了Go语言使用sort包对任意类型元素的集合进行排序的方法,实例分析了sort排序所涉及的方法与相关的使用技巧,需要的朋友可以参考下
    2015-02-02

最新评论