09-go类型断言

最新推荐文章于 2024-04-07 19:57:01 发布
最新推荐文章于 2024-04-07 19:57:01 发布
阅读量257 收藏
点赞数
分类专栏： Go 实现原理 类型断言 文章标签： go 实现原理 类型断言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/svasticah/article/details/93379834
版权
Go 同时被 3 个专栏收录
25 篇文章 0 订阅
订阅专栏
实现原理
22 篇文章 1 订阅
订阅专栏
类型断言
1 篇文章 0 订阅
订阅专栏

类型断言适用对象

        var i int32Value =100;
        if t,ok := i.(int32);ok {
                i = 200;
        }

类型断言只能用于interface变量。

invalid type assertion: i.(int32) (non-interface type int32Value on left)

未实现相应接口的方法的断言，编译会失败

type int32Interface interface {
        Value() int32
}
var i int32Value =100;
        
var var_a_int int32= 1000;
var var_b_iface int32Interface = i;
if t,ok := var_b_iface.(int32);ok {
        i = 200;
}

int32没有实现接口int32Interface的方法Value

go tool compile -S -N -L type_assert.go > type_assert-n.asm 
type_assert.go:73:24: impossible type assertion:
        int32 does not implement int32Interface (missing Value method)

int32Value实现了接口方法，编译可以正常编译。

type int32Value int32

type int32Interface interface {
        Value() int32
}

func (i int32Value) Value() int32 {
        return int32(i)
}

var i int32Value =100;
if t,ok := var_b_iface.(int32Value);ok {
    i = 200;
    fmt.Println(t);
}

类型断言底层实现

eface断言
     59 func func3(var_eface interface{}) int32{
     60         t := var_eface.(int32Value)
     61         t.Value();
     ...
     }

type eface struct {
	_type *_type
	data  unsafe.Pointer
}
  1. AX存放的是接口变量的地址。即eface对象地址。eface第一个元素是_type。是一个_type指针。
  2. DX总存放的是目标类型地址。
    因此eface断言，比较的是类型的指针。
    将eface._type与目标类型直接进行比较。
    比较的是两个指针，即同一个类型在内存中只有一份记录。
0x003a 00058 (type_assert.go:60)        MOVL    $0, ""..autotmp_10+84(SP)
0x0042 00066 (type_assert.go:60)        MOVQ    "".var_eface+240(SP), AX    //AX为eface._type,具体对象类型
0x004a 00074 (type_assert.go:60)        PCDATA  $2, $1
0x004a 00074 (type_assert.go:60)        MOVQ    "".var_eface+248(SP), CX
0x0052 00082 (type_assert.go:60)        PCDATA  $2, $2
0x0052 00082 (type_assert.go:60)        LEAQ    type."".int32Value(SB), DX  //断言的类型，type."".int32Value
0x0059 00089 (type_assert.go:60)        CMPQ    AX, DX                      //比较 type."".int32Value 和 "".var_eface+240(SP)
0x005c 00092 (type_assert.go:60)        JEQ     99
0x005e 00094 (type_assert.go:60)        JMP     542
0x0063 00099 (type_assert.go:60)        PCDATA  $2, $0
0x0063 00099 (type_assert.go:60)        MOVL    (CX), AX
0x0065 00101 (type_assert.go:60)        MOVL    AX, ""..autotmp_10+84(SP)
0x0069 00105 (type_assert.go:60)        MOVL    AX, "".t+72(SP)
0x006d 00109 (type_assert.go:61)        MOVL    "".t+72(SP), AX
0x0071 00113 (type_assert.go:61)        MOVL    AX, "".i+76(SP)
0x0075 00117 (type_assert.go:61)        MOVL    $0, "".~r0+64(SP)
0x007d 00125 (type_assert.go:61)        XCHGL   AX, AX
0x007e 00126 (type_assert.go:26)        MOVL    "".i+76(SP), AX
0x0082 00130 (type_assert.go:61)        MOVL    AX, ""..autotmp_13+80(SP)
0x0086 00134 (type_assert.go:61)        MOVL    AX, "".~r0+64(SP)
0x008a 00138 (type_assert.go:61)        JMP     140

type."".int32Value

type."".int32Value SRODATA size=80
        0x0000 04 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
        0x0010 5e 3c 98 b9 07 04 04 85 00 00 00 00 00 00 00 00  ^<..............
        0x0020 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
        0x0030 00 00 00 00 01 00 01 00 10 00 00 00 00 00 00 00  ................
        0x0040 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
        rel 24+8 t=1 runtime.algarray+64
        rel 32+8 t=1 runtime.gcbits.+0
        rel 40+4 t=5 type..namedata.*main.int32Value-+0
        rel 44+4 t=5 type.*"".int32Value+0
        rel 48+4 t=5 type..importpath."".+0
        rel 64+4 t=5 type..namedata.Value.+0
        rel 68+4 t=24 type.func() int32+0
        rel 72+4 t=24 "".(*int32Value).Value+0
        rel 76+4 t=24 "".int32Value.Value+0
iface断言
     70         var i int32Value =100;
     71 
     72         var var_a_int int32= 1000;
     73         var var_b_iface int32Interface = i;
     74         var_a_int = 200;
     75         t := var_b_iface.(int32Value);

直接比较iface.tab与目标类型.

  1. 再看AX中实际的内容. iface.tab是一个itab类型指针。
type iface struct {
	tab  *itab
	data unsafe.Pointer
}
  1. itab结构
    itab的第一个元素inter是一个interafcetype类型指针.
type itab struct {
	inter *interfacetype
	_type *_type
	hash  uint32 // copy of _type.hash. Used for type switches.
	_     [4]byte
	fun   [1]uintptr // variable sized. fun[0]==0 means _type does not implement inter.
}
  1. interfacetype结构
    interfacetype第一个元素为typ，是一个_type类型。即所有类型的底层结构。
type interfacetype struct {
	typ     _type
	pkgpath name
	mhdr    []imethod
}

由上可以看出:

  1. AX中存放的就是iface.tab.inter这个指针，指向接口变量中实际存储的动态类型。
  2. DX中存放的就是目标类型的地址。
  3. 断言比较的就是两个类型的指针。
0x007a 00122 (type_assert.go:75)        MOVL    $0, ""..autotmp_19+84(SP)
0x0082 00130 (type_assert.go:75)        MOVQ    "".var_b_iface+288(SP), AX  //接口变量地址放在AX，即AX中即iface.tab
0x008a 00138 (type_assert.go:75)        PCDATA  $2, $3
0x008a 00138 (type_assert.go:75)        MOVQ    "".var_b_iface+296(SP), CX
0x0092 00146 (type_assert.go:75)        PCDATA  $2, $4
0x0092 00146 (type_assert.go:75)        LEAQ    go.itab."".int32Value,"".int32Interface(SB), DX //将目标类型地址放在 DX
0x0099 00153 (type_assert.go:75)        PCDATA  $2, $3
0x0099 00153 (type_assert.go:75)        CMPQ    AX, DX  //直接比较两个地址
0x009c 00156 (type_assert.go:75)        JEQ     163
0x009e 00158 (type_assert.go:75)        JMP     1607
0x00a3 00163 (type_assert.go:75)        PCDATA  $2, $0
0x00a3 00163 (type_assert.go:75)        MOVL    (CX), AX
0x00a5 00165 (type_assert.go:75)        MOVL    AX, ""..autotmp_19+84(SP)
0x00a9 00169 (type_assert.go:75)        MOVL    AX, "".t+72(SP)

go.itab."".int32Value,"".int32Interface

go.itab."".int32Value,"".int32Interface SRODATA dupok size=32
        0x0000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
        0x0010 5e 3c 98 b9 00 00 00 00 00 00 00 00 00 00 00 00  ^<..............
        rel 0+8 t=1 type."".int32Interface+0
        rel 8+8 t=1 type."".int32Value+0
        rel 24+8 t=1 "".(*int32Value).Value+0

断言返回值

59 func func3(var_eface interface{}) int32{
60    assert_value := var_eface.(int32Value)
61    var tmp int32 = 1000;
62    fmt.Println(assert_value,tmp)
63    return tmp
64 }


x003d 00061 (type_assert.go:60)        MOVL    $0, ""..autotmp_9+76(SP)
x0045 00069 (type_assert.go:60)        MOVQ    "".var_eface+288(SP), AX //将接口变量地址放入AX
x004d 00077 (type_assert.go:60)        PCDATA  $2, $1
x004d 00077 (type_assert.go:60)        PCDATA  $0, $1
x004d 00077 (type_assert.go:60)        MOVQ    "".var_eface+296(SP), CX //将接口变量数据地址放入CX
x0055 00085 (type_assert.go:60)        PCDATA  $2, $2
x0055 00085 (type_assert.go:60)        LEAQ    type."".int32Value(SB), DX   //将目标数据类型地址放入DX
x005c 00092 (type_assert.go:60)        CMPQ    AX, DX
x005f 00095 (type_assert.go:60)        JEQ     102
x0061 00097 (type_assert.go:60)        JMP     618
x0066 00102 (type_assert.go:60)        PCDATA  $2, $0
x0066 00102 (type_assert.go:60)        MOVL    (CX), AX //将接口变量值放入AX
x0068 00104 (type_assert.go:60)        MOVL    AX, ""..autotmp_9+76(SP) 
x006c 00108 (type_assert.go:60)        MOVL    AX, "".assert_value+72(SP) //assert_value类型已知是int32Value, 将接口中的值赋值给断言后变量

总结

  1. go中每个类型在内存中都只有一份定义。
  2. 断言就是将接口中保存的动态类型与目标类型的指针进行比较。指针指向同一个位置，即类型正确。
  3. 断言后的变量类型是确定的，即断言会声明一个指定类型变量，并赋值。
浩玥当空照
关注
专栏目录
Go学习日记2-Go类型断言
qq_15965621的博客
06-17 658
go2
Go语言圣经 - 第7章 接口 - 7.10 类型断言
weixin_51487151的博客
01-07 150
第7章 接口 接口类型是对其它类型行为的抽象和概括.接口类型不会和特定的实现细节绑定在一起，这种抽象的方式能让我们的函数更加的灵活和更具有适应能力 Go语言的接口比较特殊，因为它是满足隐式实现的。也就是说，我们无需给具体类型定义所有满足足的接口类型，只需要让类型拥有一些简单必要的方法。这样我们新建一个接口类型，满足具体类型，并且我们不需要更改这些类型的定义。当我们使用的类型来自于不受我们控制的包时，这种机制比较有用 7.10 类型断言 类型断言是一个使用在接口值上的操作。语法上看起来像x.(T)被称为断言
go类型断言
summericeZou的博客
06-16 1073
类型断言（Type Assertion）是一个使用在接口值上的操作，用于检查接口类型变量所持有的值是否实现了期望的接口或者具体的类型。在Go语言中类型断言的语法格式如下： 其中，x 表示一个接口的类型，T 表示一个具体的类型（也可为接口类型）。该断言表达式会返回 x 的值（也就是 value）和一个布尔值（也就是 ok），可根据该布尔值判断 x 是否为 T 类型：示例代码如下： 运行结果如下： 需要注意如果不接收第二个参数也就是上面代码中的 ok，断言失败时会直接造成一个 panic。如果 x 为 nil
go 类型断言
qq_40484416的博客
04-24 176
rr,ok:=mapsy.Load(did) //从sync.Map中加载数据，rr类型是interface{} if !ok{ return nil } value, ok := rr.(*Robot) //将rr转成自己需要的类型，这里是Robot(自己定义的struct） if !ok { return } ...
GO语言类型转换和类型断言实例分析
12-26
本文实例讲述了GO语言类型转换和类型断言的用法。分享给大家供大家参考。具体分析如下： 由于Go语言不允许隐式类型转换。而类型转换和类型断言的本质，就是把一个类型转换到另一个类型。 一、类型转换 （1）、语法：...
Go-redis-Golang的类型安全Redis客户端
08-13
通过使用Golang的特性，如类型断言和接口，Go-redis确保了在与Redis交互时的类型安全，避免了因类型转换错误导致的问题。 **二、安装** 要使用Go-redis，首先需要通过Golang的包管理器`go get`进行安装： ```bash...
Go-支持大多数Go内置类型转换不使用反射通过类型断言开关
08-14
通过学习和理解这些示例，你可以更好地掌握在不使用反射的情况下进行Go语言类型转换的技巧，提升代码的效率和可读性。 总的来说，Go语言中的类型转换可以通过类型断言和switch语句来完成，这种方式在许多情况下比...
Go类型断言
Boboy
05-26 266
package main import "fmt" //类型断言（Type Assertion）是一个使用在接口值上的操作，用于检查接口类型变量所持有的值是否实现了期望的接口或者具体的类型。 //如何进行类型断言的判断？ //1.使用if语句或者switch语句 //2.依靠 value, ok := x.(T) //x 表示一个接口的类型， //T 表示一个具体的类型（也可为接口类型）。 //value 表示对应接口的值 //ok 表示对应的状态 true/false //如果 T 是具体某个类型
Go 类型断言
houyanhua1的专栏
03-21 196
demo.go（类型断言）： package main import "fmt" func main() { // 定义空接口类型变量 (可以接收任意类型的数据) var i interface{} i = 10 // 存放int类型数据 // int(i) + 20 // 会报错。 接口不能直接参与运算(类型转换)，需要使用类型断言。 // 类型断言 value...
GO类型断言
技术成就梦想，梦想成就未来。If you try hard enough, it can be.
03-13 485
我们知道接口可以指向任意类型对象，只要该类型实现了接口中的所有方法。 那如何判定接口到底指向的是哪种类型的对象呢？我们可以使用类型断言来实现。 语法： x.(T) 其中，x为接口变量，T为任意的类型。上面的断言语句表示 x is not nil and that the value stored in x is of type T More precisely, if T
Golang 类型断言
王佳宇的个人博客
06-14 6598
需要的知识 interface：https://blog.csdn.net/weixin_40165163/article/details/91905100 类型断言 x.(T)检查x的动态类型是否是T，其中x必须是接口值。 直接使用： func main() { var x interface{} x = 100 value1, ok := x.(int) if ok { ...
[GO]类型断言
阿森的博客
07-08 360
类型断言 GO的类型断言，是一个使用在接口值上面的操作，检查接口变量的值是否实现了期望的接口或者具体的类型。 // +build ignore package main import ( "fmt" ) type a1 interface{ f2() } type s1 struct{} func (s *s1) f2() {} func main() { var x interface{} x = new(s1) // 类型断言 判断接口变量x的值是否实现了a1接口 if v
Go 类型断言(Type assertion)
lishuangzhi的博客
09-20 166
类型断言 Golang的类型断言提供对接口(interface)值的底层具体值的访问 t := i.(T) 该语句断言接口值 i 持有具体类型 T 并将底层 T 值分配给变量 t。 如果 i 的具体类型不是 T，则该语句将引发panic。 t, ok := i.(T) 类型断言可以返回两个值：基础值和报告断言是否成功的布尔值。 A Tour of Go ...
go中的类型断言
最新发布
slnsuya的博客
04-07 731
类型断言的关键，是明确接口的动态类型，以及对应的类型实现了哪些方法，而明确这些的关键，还是“类型元数据”，以及空接口与非空接口的数据结构。
Go语言类型断言
GeeCode的博客
07-03 551
本文详细介绍了 Go 语言中类型断言的使用方法，包括断言的语法、类型断言的两种方式、类型断言的注意事项等方面。类型断言是 Go 语言中非常重要的特性，可以帮助我们将接口类型转换为其他类型，并判断一个接口值是否实现了某个接口。掌握类型断言的使用方法可以提高代码的灵活性和可维护性。
Go 的类型断言type assertion
翔云
02-23 1600
Go语言中的类型断言，语法上是这样的: x.(T) 其中，x是interface接口的表达式，T是类型，称为被断言类型。 补充一下，接口有接口值的概念，其包括动态类型和动态值两部分。 类型断言根据T的不同可以分为两种情况: 1. T是具体类型 类型断言首先检查x的动态类型是否是T. 如果是，类型断言的结果就是x的动态值. 如果否，操作就会panic 例如， va...
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
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值