GoLang之interface底层系列二(类型断言)

已于 2022-04-30 17:00:51 修改
阅读量1.3k 收藏 4
点赞数
分类专栏： GoLang底层 文章标签： golang
于 2022-04-30 00:21:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52690231/article/details/124505914
版权

文章目录

GoLang之interface底层系列二(类型断言)

注：本文基于Windos系统上Go SDK v1.18进行讲解

1.抽象类型、具体类型

我们已经知道接口可以分为空接口与非空接口两类。相对于接口这种“抽象类型”，像int，slice，string，map，struct等类型被称为“具体类型”。
类型断言是Go语言中应用在接口值上的一个神奇特性，而类型断言的目标类型可以是某种具体类型，也可以是某种非空接口类型。这样我们就组合出四种类型断言，接下来就逐一看看它们究竟是如何断言的！

image-20220304101053035

2.断言的作用类型与目标类型

类型断言作用在接口值之上，可以是空接口，也可以是非空接口;

而断言的目标类型，可以是具体类型，也可以是非空接口类型。这样就组合出了四种类型断言，接下来我们就逐一看看，它们究竟是怎样断言的。

image-20220304102120705

image-20220304102131110

image-20220304102323947

image-20220304102334650

3.空接口.(具体类型)

e.(*os.File)就是要判断e存储的_type是否指向*os.File的类型元数据。反正我们介绍过Go语言里每种类型的类型元数据都是全局唯一的。

var e interface{}
//......
r, ok := e.(*os.File)
fmt.Println(r, ok) //<nil> false

在这里插入图片描述

如果e像下面这样赋值，，e的动态值就是f，e的动态类型就是*os.File，所以e.(*os.File)类型断言成功，ok为true，r为e的动态值，r被赋值为e的动态值f

//eggo.txt存在
func main() {
	var e interface{}
	f, _ := os.Open("aaa.txt")
	fmt.Println(f)//输出：&{0xc0000d0780}
	e = f
	r, ok := e.(*os.File)
	fmt.Println(ok) //输出：true
	fmt.Println(r)  //输出：&{0xc0000d0780}
}

//eggo.txt不存在
    var e interface{}
	f, _ := os.Open("eggo.txt")
	e = f
	r, ok := e.(*os.File)
	fmt.Println(f)        //<nil>
	fmt.Println(f == nil) //true
	fmt.Println(e)        //<nil>
	fmt.Println(e == nil) //flase
	fmt.Println(r, ok)    //<nil> true

在这里插入图片描述
image-20220304103824977

如果e的动态类型不是*os.File，例如e被赋值为string，e的动态类型就是string,那么类型断言就会失败，ok就是false，r就是*os.File的类型零值nil。

var e interface{}
f := "eggo"
e = f
r, ok := e.(*os.File)
fmt.Println(r, ok) //<nil> false

在这里插入图片描述
image-20220304104604639
image-20220304104618974

4.非空接口.(具体类型)

rw.(*os.File)是要判断rw的动态类型是否为*os.File。前面我们介绍过，程序中用到的itab结构体都会缓存起来，可以通过<接口类型, 动态类型>组合起来的key，查找到对应的itab指针。
所以这里的类型断言只需要一次比较就能完成，就是看iface.tab是否等于<io.ReadWriter, *os.File>这个组合对应的itab指针就好。

    var rw io.ReadWriter
	fmt.Println(rw)//<nil>
	//......
	r, ok := rw.(*os.File)
	fmt.Println(r, ok) //<nil> false

在这里插入图片描述

如果把一个*os.File类型的变量f赋给rw，它的动态值就是f，动态类型就是*os.File。
rw这里存储的itab指针就指向<io.ReadWriter, *os.File>组合对应的itab，所以类型断言成功，ok为true，r被赋值为rw的动态值。

    //eggo.txt存在
	var rw io.ReadWriter
	fmt.Println(rw)
	f, _ := os.Open("eggo.txt") //<nil>
	fmt.Println(f)              //&{0xc00006c000}
	rw = f
	fmt.Println(rw) //&{0xc00006c000}
	r, ok := rw.(*os.File)
	fmt.Println(r, ok) //&{0xc00006c000} true

    //eggo.txt不存在
	var rw io.ReadWriter
	fmt.Println(rw)
	f, _ := os.Open("eggo.txt") //<nil>
	fmt.Println(f)//<nil>
	rw = f
	fmt.Println(rw)//<nil>
	r, ok := rw.(*os.File)
	fmt.Println(r, ok) //<nil> true

在这里插入图片描述
image-20220304105820120

下面我们定义一个eggo类型，并且由*eggo类型实现io.ReadWriter接口。
如果把一个*eggo类型的变量赋值给rw，rw的动态类型就是*eggo，rw持有的itab指针就不指向<io.ReadWriter, *os.File>组合对应的itab结构体，类型断言就会失败，ok为false，而r就会被置为*os.File的类型零值nil。

package main

import (
	"fmt"
	"io"
	"os"
)

type eggo struct {
	name string
}

func (e *eggo) Read(b []byte) (n int, err error) {
	return len(e.name), nil
}

func (e *eggo) Write(b []byte) (n int, err error) {
	return len(e.name), nil
}
func main() {
	var rw io.ReadWriter
	f := eggo{name: "eggo"}
	fmt.Println(f) //{eggo}
	rw = &f
	fmt.Println(rw) //&{eggo}
	r, ok := rw.(*os.File)
	fmt.Println(r, ok) //<nil> false
}

在这里插入图片描述
image-20220304110017053

package main

import (
	"fmt"
	"io"
)

type eggo struct {
	name string
}

func (e *eggo) Read(b []byte) (n int, err error) {
	return len(e.name), nil
}

func (e *eggo) Write(b []byte) (n int, err error) {
	return len(e.name), nil
}
func main() {
	var rw io.ReadWriter
	f := eggo{name: "eggo"}
	rw = &f
	r, ok := rw.(*eggo)
	fmt.Println(r, ok) //&{eggo} true
}

5.空接口.(非空接口)

e.(io.ReadWriter)就是要判断e的动态类型是否实现了io.ReadWriter接口。

    var e interface{}
	//......
	rw, ok := e.(io.ReadWriter)
	fmt.Println(rw, ok) //<nil> false

在这里插入图片描述

如果e像这样赋值：
它的动态值就是f,e的动态类型就是*os.File，我们知道*os.File类型元数据的后面可以找到该类型实现的方法列表描述信息。

    //eggo.txt存在
    var e interface{}
	f, _ := os.Open("aaa.txt")
	fmt.Println(f)//输出：&{0xc000118780}
	e = f //把*结构体赋值给了空接口
	rw, ok := e.(io.ReadWriter)
	fmt.Println(rw) //输出：&{0xc000118780}
	fmt.Println(ok) //输出：true

//eggo.txt不存在
	var e interface{}
	f, _ := os.Open("eggo.txt")
	fmt.Println(f)//<nil>
	e = f
	fmt.Println(e)//<nil>
	rw, ok := e.(io.ReadWriter)
	fmt.Println(rw, ok) //<nil> true

在这里插入图片描述
image-20220304132110770

其实并不需要每次都检查动态类型的方法列表，还记得itab缓存吗？ 实际上，当类型断言的目标类型为非空接口时，会首先去itabTable里查找对应的itab指针，若没有找到io.ReadWrite和os.File对应的itab结构体，再去检查动态类型的方法列表,即再去检查*os.File的方法列表。
此处注意，就算从itabTable中找到了itab指针，也要进一步确认itab.fun[0]是否等于0。这是因为一旦通过方法列表确定某个具体类型没有实现指定接口，就会把itab这里的fun[0]置为0，然后同样会把这个itab结构体缓存起来，和那些断言成功的itab缓存一样。这样做的目的是避免再遇到同种类型断言时重复检查方法列表。
即断言失败的类型组合其对应的itab结构体也会被缓存起来，只是会把itab.fun[0]置为0，用以标识这里的动态类型并没有实现对应的接口，这样以后在遇到同样类型断言时，就不用再去检查方法列表了，可以直接断言失败;
回到例子中，这里会断言成功，ok为true，rw就是一个io.ReadWriter类型的变量，其动态值与e相同。tab指向<io.ReadWriter, *os.File>对应的itab结构体。

在这里插入图片描述

然而如果把一个字符串赋值给e，它的动态类型就是string，<io.ReadWriter, string>这个组合会对应下面这个itab，它也会被缓存起来。

	var e interface{}
	f := "eggo"
	e = f
	rw, ok := e.(io.ReadWriter)
	fmt.Println(rw, ok) //< nil > false

在这里插入图片描述
image-20220304135648543

断言失败，ok为false，rw为io.ReadWriter的类型零值，即tab和data均为nil。

在这里插入图片描述

总结：
下面中代码中断言是成功的，所以ok为true，rw就是一个io.ReadWriter接口类型的变量(即*os.file结构体实现了io.ReadWriter接口)，rw的动态值与e相同，而tab就指向这一个itab结构体

image-20220304140836261

如果e被赋值为一个字符串，它的动态类型就是string，并没有实现要求的Read和Write方法，所以对应的itab中fun[0]=0，并且会被添加到itab缓存中，这里断言失败，ok为false，rw为io.ReadWriter的类型零值

image-20220304141401229

6.非空接口.(非空接口)

w.(io.ReadWriter)是要判断w的动态类型是否实现了io.ReadWriter接口。

var w io.Writer
//......
rw, ok := w.(io.ReadWriter)
fmt.Println(rw, ok) //< nil > false

在这里插入图片描述

下面同样把一个*os.File类型的变量f赋值给w，它的动态值就是f，动态类型就是*os.File。

//eggo.txt存在
	var w io.Writer
	fmt.Println(w) //<nil>
	f, _ := os.Open("eggo.txt")
	fmt.Println(f) //&{0xc00011a780}
	w = f
	fmt.Println(w) //&{0xc00011a780}
	rw, ok := w.(io.ReadWriter)
	fmt.Println(rw, ok) //&{0xc00011a780}  true

	//eggo.txt不存在
	var w io.Writer
	fmt.Println(w) //<nil>
	f, _ := os.Open("eggo.txt")
	fmt.Println(f) //<nil>
	w = f
	fmt.Println(w) //<nil>
	rw, ok := w.(io.ReadWriter)
	fmt.Println(rw, ok) //<nil>  true

在这里插入图片描述

要确定*os.File是否实现了io.ReadWriter接口，同样会先去itab缓存里查找<io.ReadWriter,*os.File>对应的itab，若存在，且itab.fun[0]不等于0，则断言成功；若不存在，再去检查*os.File的方法列表，创建并缓存itab信息。
这里断言成功，ok为true，rw为io.ReadWriter类型的变量，动态值与w相同，而itab是<io.ReadWriter, *os.File>对应的那一个。

在这里插入图片描述
image-20220304142500480

下面我们自定义一个eggo类型，且*eggo类型只实现io.Writer要求的Write方法，并没有实现io.ReadWriter额外要求的Read方法。如果把一个*eggo类型的变量赋给w：

type eggo struct {
	name string
}

func (e *eggo) Write(b []byte) (n int, err error) {
	return len(e.name), nil
}

func main() {
	var w io.Writer
	f := eggo{name: "eggo"}
	w = &f
	rw, ok := w.(io.ReadWriter)
	fmt.Println(rw, ok) //<nil> false
}

此时，w的动态类型为*eggo，而*eggo的方法列表里缺少一个Read方法，所以类型断言失败，下面这个itab被缓存起来。

在这里插入图片描述
image-20220304142548844

断言失败后，ok为false，rw的data和tab均为nil。

在这里插入图片描述

综上，类型断言的关键是明确接口的动态类型，以及对应的类型实现了哪些方法。而明确这些的关键，还是类型元数据，以及空接口与非空接口的数据结构。接下来的Type Switch也不外如是。

7.Type Switch

这里的b会被赋值为e的动态值，下面每个case都是把e的动态类型和某个具体类型作比较，相等则选择这个分支，没有匹配的则走到default分支。

var e interface{}
str := "eggo"
e = str

switch b := e.(type) {
case *os.File:
    {
        fmt.Println("*os.File")
    }
case string:
    {
        fmt.Println(b)    //选择这个分支
    }
default:
    fmt.Println("default")
}

在这里插入图片描述

有时会遇到多个类型放在一个分支的情况，这时b的类型是interface{}。

switch b := e.(type) {
case *os.File:
    {
      fmt.Println("这里b的类型为*os.File", b)
    }
case string:
    {
      fmt.Println("这里b的类型为string", b)
    }
case int, int32, int64:
    {
      fmt.Println("多类型分支里b的类型为interface{}", b)
    }
default:
    fmt.Println("default")
}

8.附

空接口.(空接口):

type m interface{}

func main() {
	var a interface{}
	k, ok := a.(m)
	fmt.Println(k, ok) //<nil> false
}

func main() {
	var a interface{}
	k, ok := a.(interface{})
	fmt.Println(k, ok) //<nil> false
}

在这里插入图片描述

非空接口.(空接口):

type a interface{}

func main() {
	var rw io.ReadWriter
	k, ok := rw.(a)
	fmt.Println(k, ok)//<nil> false
}


func main() {
	var rw io.ReadWriter
	k, ok := rw.(interface{})
	fmt.Println(k, ok) //<nil> false
}
GoGo在努力
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
golang之反射和断言的具体使用
09-18
主要介绍了golang之反射和断言的具体使用，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
实例学习Golang–接口（二、空接口和类型断言）
01-07
空接口 空接口的内部实现保存了对象的类型和指针。... // 声明 any 为 interface{} 类型的变量 var any interface{} any = 1 fmt.Printf(%T, %v\n, any, any) any = hello fmt.Printf(%T, %v\n, any, any)
Go语言接口(interface{})类型断言
敦煌的驼铃_Blog
03-04 4368
Go语言接口类型断言 1,使用场景 1.1,检查接口类型变量的值是否实现了期望的接口。 理解： * 很简单，就是检查当前接口类型的值有没有实现指定的某个具体的接口。 1.2,把接口类型变量的值转换为其他类型或其他接口。 理解： * 其实很好理解，go语言空interface{}可以保存任何类型的变量， 当程序中需要使用该变量的时候，需要把接口类型变量的值转化为 具体类型，可以通过接口类型断言。 * 假如接口
golang学习之Interface类型断言
Kiloveyousmile的博客
12-07 4035
Interface作为go语言中一个重要的组成部分，它的使用简单方便。它的通常和struct一起使用，有点类似C++中的类。今天，我们主要来讨论一下它在类型断言中的用法。
go语言interface{}类型断言的举例使用
12-21 1299
在go语言里经常会用到interface{}类型，它是类似于c语言中的void *类型，可以接受任意类型的参数。当我们的函数或者方法中有该参数时，要判断具体的类型值再进行相应处理。 一般格式：返回值，bool变量:=interface{}变量.(要判断的具体类型)，这样就是以某个具体类型来断言，返回值就是这个具体类型的。比如：v,b:=a.(string)，这个就是假设a这个interface{...
Golang--interface断言
琼黍的村落
05-10 1424
一个interface类型的变量varI中可以包含任何类型的值，必须有一种方式来检测它的动态类型，即运行时在变量存储中的值的实际类型。通常我们可以使用类型断言来测试在某个时刻varI是否包含类型T的值： v,ok := varI.(T) #varI必须是一个interface变量 如果转换合法，v是varI转换到类型T的值，ok是true;否则v是类型T的零值，ok是false。 接口的转换遵
golang 类型断言
qq_49723651的博客
11-29 5323
类型断言 文章目录类型断言空接口.(具体类型)非空接口.(具体类型)空接口.(非空接口)非空接口.(非空接口)Type Switch 我们已经知道接口可以分为空接口与非空接口两类。相对于接口这种“抽象类型”，像int，slice，string，map，struct等类型被称为“具体类型”。 类型断言是Go语言中应用在接口值上的一个神奇特性，而类型断言的目标类型可以是某种具体类型，也可以是某种非空接口类型。这样我们就组合出四种类型断言，接下来就逐一看看它们究竟是如何断言的！ 空接口.(具体类型) va
golang基础之Interface接口的使用
09-20
在 Go 语言中，接口（Interface）是一种强大的抽象机制，它允许我们定义一组方法签名，任何类型只要实现了这些方法即可被视为实现了该接口。接口的这种特性使得 Go 语言具有高度的灵活性和可扩展性，是实现面向接口...
low:Golang中的底层数据类型和utils
05-17
Golang中的底层数据类型和utils。 稳定的低级功能集是强大体系结构的基础。 它注重稳定性，并要求较高的测试覆盖率。 地位 这个项目一直在支持我们所有其他的go项目。 安装 go get github.com/openacid/low/... ...
golang struct 实现 interface的方法
09-20
主要介绍了golang struct 实现 interface的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Golang 类型断言
m0_63901241的博客
06-21 7053
在Go语言的interface中可以是任何类型，所以Go给出了类型断言来判断某一时刻接口中所含有的类型，例如现在给出一个接口，名为InterfaceText:上式是接口断言的一般形式，因为此方法不一定每次都可以完好运行，所以err的作用就是判断是否出错。所以一般接口断言常用以下写法： 如果转换合法，则v为InterfaceText转换为类型T的值，err为ture，反之err为false。值得注意的是：InterfaceText必须是接口类型！！！有些时候若是想仅判断是否含有类型T，可以写为： 下面
Go 学习笔记（35）— Go 接口 interface （接口声明、接口初始化、接口方法调用、接口运算、类型断言、类型查询、空接口）
热门推荐
wohu1104的专栏
05-22 1万+
1. 接口概念 接口是双方约定的一种合作协议。接口实现者不需要关心接口会被怎样使用，调用者也不需要关心接口的实现细节。接口是一种类型，也是一种抽象结构，不会暴露所含数据的格式、类型及结构。 接口内部存放的具体类型变量被称为接口指向的“实例”。接口只有声明没有实现，所以定义一个新接口，通常又变成声明一个新接口， 定义接口和声明接口二者通用，代表相同的意思。 最常使用的接口字面量类型就是空接口 interface{} ，由于空接口的方法集为空，所以任意类型都被认为实现了空接口，任意类型的实例都可以赋值或传递给空
Go ：断言的简介与实践
GIS摆渡人
11-17 1694
go存在4种类型转换分别为：断言、强制、显式、隐式。通常说的类型转换是指断言，强制在日常不会使用到、显示是基本的类型转换、隐式使用到但是不会注意到。断言、强制、显式三类在go语法描述中均有说明，隐式是在日常使用过程中总结出来。断言通过判断变量是否可以转换成某一个类型，就是判断当前接口变量的动态类型是什么。//expression必须是接口类型，且自身类型与Type类型相符。
Go接口类型断言详解
最新发布
SmileLife123的博客
12-01 513
在Go语言中，断言（Assertion）是一种用于判断接口类型的机制，将接口变量转换成另外一个接口或者另外一个类型，它允许我们在程序中判断一个接口的实际类型是否与我们预期的类型相同，以便进行相应的处理。
Go语言 类型断言性能测试
Sunface撩技术
04-20 6393
在一些通用化的接口设计中，我们不得不用interface{}来代表任意类型，然后在接口内部用类型转换来判断具体类型，从而执行具体逻辑。但是类型判断是有性能代价的，如果能具像化的知道这个性能代价有多大，就可以帮助我们设计接口的时候判断应该怎么设计。 下面是实验代码（github）： package labs01 import "testing" type InterfaceA inter
Golang interface 多态/类型断言
小楼一夜听春雨，深巷明朝卖杏花
10-17 923
变量(实例)具有多种形态。面向对象的第三大特征，在Go语言，多态特征是通过接口实现的（接口能够体现多态的特征）。可以按照统一的接口来调用不同的实现。这时接口变量就呈现不同的形态。在前面的Usb接口案例，usb既可以接收手机变量，又可以接收相机变量，就体现了Usb接口多态特性。自动的根据上下文环境来判断usb变量到底是什么类型的变量。
【容易踩坑】golang断言
jinchenga的博客
09-12 694
在Go语言中，。在Go语言中，断言的语法形式为x.(T)，其中x是一个接口类型的值，T是一个具体的类型。这个语法表示我们要判断x的实际类型是否是T，如果是，则将x转换为T类型的值，并返回给我们使用。断言的过程是通过判断x的实际类型信息和T类型信息是否一致来完成的。如果一致，断言就成功了，我们可以继续使用T类型的值；如果不一致，断言就失败了，会导致程序运行时产生一个恐慌（panic）。
GO语言面试精华——类型转换和断言的区别？
白话机器学习
09-10 60
我们知道，Go 语言中不允许隐式类型转换，也就是说两边，不允许出现类型不相同的变量。类型转换类型断言本质都是把一个类型转换成另外一个类型。不同之处在于，类型断言是对接口变量进行的操作。
golang类型断言
06-01
在 Golang 中，类型断言用于检查接口值的底层具体类型。类型断言的语法如下： ``` value, ok := interfaceVar.(typeName) ``` 其中，`interfaceVar` 为接口类型的变量，`typeName` 为底层具体类型的名称。如果 `interfaceVar` 的底层类型是 `typeName`，则断言成功，返回 `value` 和 `true`；否则返回 `value` 的零值和 `false`。在类型断言中，通常使用 `if` 语句进行判断，例如： ``` if str, ok := var1.(string); ok { // var1 的底层类型是 string fmt.Println(str) } else { // var1 不是 string 类型 fmt.Println("var1 is not a string") } ``` 如果 `var1` 的底层类型是 string，则输出 `var1` 的值；否则输出错误信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

GoGo在努力

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值