golang学习笔记——类型断言

已于 2024-06-30 10:00:36 修改
阅读量881 收藏 11
点赞数 23
分类专栏： golang从入门到入门 文章标签： golang
于 2024-06-23 01:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/e891377/article/details/139834756
版权

文章目录

类型断言

Go语言的类型断言与类型转换在形式上都相差一小点，之前我还一直以为是类型转换。没想到这是错误的。

在 Golang 中，类型转换和类型断言是两种不同的操作。类型转换是将不同类型的变量进行转换，需要开发人员进行显式的类型转换操作。类型断言是将接口类型转换为具体的类型，或者将具体类型转换为接口。类型断言的成功与失败取决于接口值的动态类型是否与尝试断言的类型相匹配。

Go 语言类型断言

GoLang中的 interface{} 即 any 可以代表所有类型，包括基本类型string、int、int64，以及自定义的 struct 类型。

interface{} 好比 java 中的 Object，java 中的所有类都实现了Object。

下面这个函数接收一个 interface{} 的参数，就代表了它可以传递任何类型的变量。如果在代码中强转 a 为 string，如以下的代码：

func funcName(a interface{}) string {
    return string(a)
}

此时编译器将会返回：

cannot convert a (type interface{}) to type string: need type assertion

编译器提示我们用类型断言（type assertion）约束变量。接下来介绍几种使用类型断言的方法。

直接断言使用

直接断言使用，返回对应类型的值

  • 如果断言成功，则 变量b == 变量a
  • 如果断言失败，则 panic

语法如下：

变量b :=变量a.(类型)

举例

如果 断言为 string，则输出正常name type = string, name = tom
如果断言为 非 string，则 panic

package main

import "fmt"
import "reflect"

func testTypeAssertion1() {

	var name any = "tom"

	nameType := reflect.TypeOf(name)

	fmt.Printf("name type = %v, name = %v\n", nameType, name.(string))

	fmt.Printf("name type = %v, name = %v\n", nameType, name.(int))
}

func main() {
	testTypeAssertion1()
}

输出

name type = string, name = tom
panic: interface conversion: interface {} is string, not int

第一个fmt正常输出，第二个fmt发生panic

断言判断并返回是否成功,可配合if

从一些业务角度来讲，如果断言不成功直接 panic，程序会终止，显然并不能满足一些业务的需求，比如记录错误日志，或走其他分支等等，所以 GoLang 也提供了另一个参数，返回断言是否成功

  • 如果断言成功，返回对应类型的值，即 变量b == 变量a，ok 为 true
  • 如果断言失败，变量b为对应 断言类型的 默认值，ok 为 false

语法如下：

变量b, ok = 变量a.(类型)

举例

func testTypeAssertion2() {   
    var name any = "tom"    
    nameStringData, ok1 := name.(string)
    fmt.Printf("name type = %v, name = %v, assert success ? %v, ok type = %T\n", reflect.TypeOf(nameStringData), nameStringData, ok1, ok1)
        
    nameIntData, ok2 := name.(int)
    fmt.Printf("name type = %v, name = %v, assert success ? %v, ok type = %T\n", reflect.TypeOf(nameIntData), nameIntData, ok2, ok2)
}

输出结果，不出意外，没有 panic，可以看出，第二个参数 ok 返回了断言是否成功， bool类型

name type = string, name = tom, assert success ? true, ok type = bool
name type = int, name = 0, assert success ? false, ok type = bool

也可以看出转 int 未成功后的 nameIntData 为 int 类型，默认值是 0

断言成功或失败，结合 if 执行不同的操作


if ok1 {
    name = "Mike"
    fmt.Printf("ok1 true, change name to %v\n", name)
} else {
    name = "mike"
    fmt.Printf("ok1 false, change name to %v\n", name)
}


if ok2 {
    name = "sara"
    fmt.Printf("ok2 true, change name to %v\n", name)
} else {
    name = ""
    fmt.Printf("ok2 false, change name to %v\n", name)
}

输出结果

name type = string, name = tom, assert success ? true, ok type = bool
name type = int, name = 0, assert success ? false, ok type = bool
ok1 true, change name to Mike
ok2 false, change name to

将断言语句与 if 结合起来使用

将断言语句与 if 结合 ，写在一行

if aData, ok := a.(T); ok {
    fmt.Println(aData, ok)
}

测试：

func testTypeAssertion3() {
    
    var name any = "tom"
    
    
    if nameStringData, ok1 := name.(string); ok1 {
        nameStringData = "Mike"
        fmt.Printf("ok1 true, change name to %v\n", nameStringData)
    } else {
        nameStringData = "mike"
        fmt.Printf("ok1 false, change name to %v\n", nameStringData)
    }
    
    
    if nameIntData, ok2 := name.(int); ok2 {
        nameIntData = 10086
        fmt.Printf("ok2 true, change name to %v\n", nameIntData)
    } else {
        nameIntData = 10010
        fmt.Printf("ok2 false, change name to %v\n", nameIntData)
    }
}

输出结果

ok1 true, change name to Mike
ok2 false, change name to 10010

多说一句，出于代码可读性角度来讲，编码时可以使用类型语句减少代码复杂度，少用 if else，提前退出逻辑。

switch 断言类型

如果一次性断言多种类型，会写很多的 if else，也可以用 switch 减少代码复杂度，用 变量.(type) 作为判断条件，格式如下：

switch variable := variable.(type){
	default:
	    fmt.Printf("unexpected type %T", variable)
	case string:
	    fmt.Printf("type is %T, variable = %v", variable, variable)
	case int:
	    fmt.Printf("type is %T, variable = %v", variable, variable)
	case bool:
	    fmt.Printf("type is %T, variable = %v", variable, variable)
	case float32:
	    fmt.Printf("type is %T, variable = %v", variable, variable)
}

测试

func testTypeAssertion4() {
    var a any = 2
    switch a := a.(type) {
    default:
        fmt.Printf("unexpected type %T", a)
    case string:
        fmt.Printf("type is %T, value = %v", a, a)
    case int:
        fmt.Printf("type is %T, value = %v", a, a)
    case bool:
        fmt.Printf("type is %T, value = %v", a, a)
    case float32:
        fmt.Printf("type is %T, value = %v", a, a)
    }
}

输出

type is int, value = 2

结构体类型断言

首先定义接口和结构体

type Color interface {
    
    getColor() Color
    
    setColor(value int64, content string)
}


type Red struct {
  
    Value int64 `json:"value"`
    
    Content string `json:"content"`
}


type Yellow struct {
    
    Value int64 `json:"value"`
    
    Content string `json:"content"`
}

然后让 Red 实现 Color， Yellow不实现Color

func (y Yellow) getColor2() *Yellow {
    return &Yellow{
        Value:   0xF6FF33,
        Content: "黄色",
    }
}
func (y Yellow) setColor(value int64, content string) {
    y.Value = value
    y.Content = content
}

func (r Red) getColor() Color {
    return &Red{
        Value:   0xFF5733,
        Content: "红色",
    }
}
func (r Red) setColor(value int64, content string) {
    r.Value = value
    r.Content = content
}

测试：

func testTypeAssertion5() {

    var red interface{} = &Red{}
    var yellow interface{} = &Yellow{}

    
    if color, ok := red.(Color); ok {
        fmt.Printf("red ok = %v, color = %v\n", ok, color.getColor())
    } else {
        fmt.Printf("red ok = %v, color = %v\n", ok, red)
    }
    if color, ok := yellow.(Color); ok {
        fmt.Printf("yellow ok = %v, color = %v\n", ok, color.getColor())
    } else {
        fmt.Printf("yellow ok = %v, color = %v\n", ok, yellow)
    }

    
    switch red := red.(type) {
    default:
        fmt.Printf("default no color, red = %v\n", red)
    case Red:
        fmt.Printf("color = Red, %v\n", red)
    case *Red:
        fmt.Printf("color = *Red, %v\n", red)
    case Color:
        fmt.Printf("color = Color, %v\n", red)
    }
}

输出

red ok = true, color = &{16734003 红色}
yellow ok = false, color = &{0 }
color = *Red, &{0 }

从测试代码中可以看出，结构体可以断言原本的类型，也可以断言是否继承，实际上这两个分支都是可以进去的

case *Red:
    fmt.Printf("color = *Red, %v\n", red)
case Color:
    fmt.Printf("color = Color, %v\n", red)

因为先匹配到了 *Red，再加上**switch **判断类型 不可以使用 fallthrough，所以如果切换顺序，会匹配到 Color

case Color:
    fmt.Printf("color = Color, %v\n", red)	
case *Red:
    fmt.Printf("color = *Red, %v\n", red)

输出

red ok = true, color = &{16734003 红色}
yellow ok = false, color = &{0 }
color = Color, &{0 }

以下三种方式都可以在编译前看到结构体是否实现了接口

    var _ Color = &Red{}
    var _ Color = Red{}
    var _ Color =(*Red)(nil)

	var _ Color = &Yellow{}

对 Red 使用可，对 Yellow 使用，编译器会提示错误
在这里插入图片描述

完整代码

package main

import "fmt"
import "reflect"

func testTypeAssertion1() {

	var name any = "tom"

	nameType := reflect.TypeOf(name)

	fmt.Printf("name type = %v, name = %v\n", nameType, name.(string))

	fmt.Printf("name type = %v, name = %v\n", nameType, name.(int))
}

func testTypeAssertion2() {

	var name any = "tom"
	nameStringData, ok1 := name.(string)
	fmt.Printf("name type = %v, name = %v, assert success ? %v, ok type = %T\n",
		reflect.TypeOf(nameStringData), nameStringData, ok1, ok1)

	nameIntData, ok2 := name.(int)
	fmt.Printf("name type = %v, name = %v, assert success ? %v, ok type = %T\n",
		reflect.TypeOf(nameIntData), nameIntData, ok2, ok2)
}

type Color interface {
	getColor() Color

	setColor(value int64, content string)
}

type Red struct {
	Value int64 `json:"value"`

	Content string `json:"content"`
}

type Yellow struct {
	Value int64 `json:"value"`

	Content string `json:"content"`
}

func (y Yellow) getColor2() *Yellow {
	return &Yellow{
		Value:   0xF6FF33,
		Content: "黄色",
	}
}
func (y Yellow) setColor(value int64, content string) {
	y.Value = value
	y.Content = content
}

func (r Red) getColor() Color {
	return &Red{
		Value:   0xFF5733,
		Content: "红色",
	}
}
func (r Red) setColor(value int64, content string) {
	r.Value = value
	r.Content = content
}

func testTypeAssertion5() {

	var red interface{} = &Red{}
	var yellow interface{} = &Yellow{}

	if color, ok := red.(Color); ok {
		fmt.Printf("red ok = %v, color = %v\n", ok, color.getColor())
	} else {
		fmt.Printf("red ok = %v, color = %v\n", ok, red)
	}
	if color, ok := yellow.(Color); ok {
		fmt.Printf("yellow ok = %v, color = %v\n", ok, color.getColor())
	} else {
		fmt.Printf("yellow ok = %v, color = %v\n", ok, yellow)
	}

	switch red := red.(type) {
	default:
		fmt.Printf("default no color, red = %v\n", red)
	case Red:
		fmt.Printf("color = Red, %v\n", red)
	case *Red:
		fmt.Printf("color = *Red, %v\n", red)
	case Color:
		fmt.Printf("color = Color, %v\n", red)
	}
}

func main() {
	//实现了接口,没有错误提示
	//var _ Color = &Red{}
	//var _ Color = Red{}
	//var _ Color = (*Red)(nil)

	//没有实现接口,错误提示
	//var _ Color = &Yellow{}

	testTypeAssertion5()
}

参考资料

GoLang类型转换
GoLang类型断言使用汇总
Go语言的类型断言（Type Assertion）和类型转换（Type Conversion）有什么区别

怪我冷i
关注
  • 23
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Go学习日记2-Go类型断言
qq_15965621的博客
06-17 638
go2
golang类型转换与类型断言
惜暮
09-23 639
golang类型转换与断言 主要内容： golang语言特点：强类型；
golang 类型断言
qq_49723651的博客
11-29 5493
类型断言 文章目录类型断言空接口.(具体类型)非空接口.(具体类型)空接口.(非空接口)非空接口.(非空接口)Type Switch 我们已经知道接口可以分为空接口与非空接口两类。相对于接口这种“抽象类型”，像int，slice，string，map，struct等类型被称为“具体类型”。 类型断言是Go语言中应用在接口值上的一个神奇特性，而类型断言的目标类型可以是某种具体类型，也可以是某种非空接口类型。这样我们就组合出四种类型断言，接下来就逐一看看它们究竟是如何断言的！ 空接口.(具体类型) va
【TS】TypeScript类型断言：掌握类型转换的艺术
最新发布
鑫宝的博客
08-01 2563
类型断言是一种告诉编译器"相信我，我知道我在做什么"的方式。它类似于其他语言中的类型转换，但不进行特殊的数据检查和重构。类型断言纯粹是一个编译时语法，不会影响程序的运行时行为。
go类型断言
summericeZou的博客
06-16 1073
类型断言（Type Assertion）是一个使用在接口值上的操作，用于检查接口类型变量所持有的值是否实现了期望的接口或者具体的类型。在Go语言中类型断言的语法格式如下： 其中，x 表示一个接口的类型，T 表示一个具体的类型（也可为接口类型）。该断言表达式会返回 x 的值（也就是 value）和一个布尔值（也就是 ok），可根据该布尔值判断 x 是否为 T 类型：示例代码如下： 运行结果如下： 需要注意如果不接收第二个参数也就是上面代码中的 ok，断言失败时会直接造成一个 panic。如果 x 为 nil
Golang 类型断言
王佳宇的个人博客
06-14 6595
需要的知识 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 { ...
golang 结构体断言_聊聊golang的类型断言
weixin_35702533的博客
12-23 358
序本文主要研究一下golang的类型断言类型断言x.(T)断言x不为nil且x为T类型如果T不是接口类型，则该断言x为T类型如果T类接口类型，则该断言x实现了T接口实例1func main() {var x interface{} = 7i := x.(int)fmt.Println(reflect.TypeOf(i))j := x.(int32)fmt.Println(j)}直接赋值的方式，如果...
Golang学习笔记5——反射
Overvautious的博客
05-12 692
文章目录1. 反射是什么1.1 概念1.2 功能2. 反射的实现2.1 interface 和 反射2.2 Golang的反射reflect2.2.1 reflect的基本功能TypeOf和ValueOf2.3 获取接口的属性和方法2.3.1 从relfect.Value中获取接口interface的信息2.3.2 已知原有类型2.3.3 未知原有类型【遍历探测其Filed】2.4 通过reflect.Value设置实际变量的值2.5 通过reflect.ValueOf来进行方法的调用3. Golang的反
Go语言学习笔记——类型转换工具库cast
qq_39280718的博客
09-09 599
`cast`可以在 Go 中轻松安全地从一种类型转换为另一种类型，`cast` 提供了简单的函数来轻松地将数字转换为字符串，将接口转换为布尔值等。
Go语言学习笔记——反射
qq_39280718的博客
09-05 424
Go语言提供了一种机制，能够在运行时更新变量和检查它们的值、调用它们的方法和它们支持的内在操作，而不需要在编译时就知道这些变量的具体类型。这种机制被称为反射。
python转go学习笔记———面向对象
flandreflor的博客
02-23 358
面向对象OOP 结构体Struct go语言没有类，只有结构体，等同于类(class) //定义一个结构体(类) type Book struct { //如果类首字母大写，表示其他包也能够访问 Title string //如果类属性首字母大写，表示该属性公有，否则为私有 auth string } //创建实例 func main() { // 方式一 var bk1 Book = Book{title: "xixi",auth: "flandre"} // 方式
Go语言学习笔记——接口
IuSpet的博客
05-15 286
文章目录声明接口实现接口接口嵌套接口和类型转换接口断言空接口类型interface{}空接口与其他类型转换空接口比较类型分支参考资料   接口是一种提供给调用方和实现方遵守的协议约定，大家都按照统一的命名、参数表、返回值定义/使用实现了该接口的方法   Go的接口设计是非侵入式的，接口编写者无须知道接口被哪些类型实现；接口实现者只需知道实现的接口是什么样子，无须指明实现了哪一个接口。这种隐式的实现，解除了实现类与接口间的强耦合关系 声明接口 type Invoke interface { Call(i
golang类型断言
weixin_50134791的博客
04-05 168
golang的类型断言非常重要，作用类似C++的动态类型转换，用于将接口类型转换为具体的类型，例子如下 package main import ( "fmt" ) type it interface { Add() } type Stu struct { a int } func (stu *Stu)Add(){ } func (stu *Stu)Sub(){ fmt.Println(stu.a) } type Per struct { xx string } func (per *P
Golang类型断言
umgsai的专栏
05-22 268
package main import "fmt" type Point struct { x int y int } func TypeJudge(items ...interface{}) { for i, x := range items { switch x.(type) { case bool: fmt.Printf("第%d个参数%v是bool类型\n", i, x) case int, int32, int64: fmt.Printf("第%d个参数%d是.
Go语言类型断言
GeeCode的博客
07-03 543
本文详细介绍了 Go 语言中类型断言的使用方法，包括断言的语法、类型断言的两种方式、类型断言的注意事项等方面。类型断言是 Go 语言中非常重要的特性，可以帮助我们将接口类型转换为其他类型，并判断一个接口值是否实现了某个接口。掌握类型断言的使用方法可以提高代码的灵活性和可维护性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值