golang学习笔记——类型断言

原创 已于 2025-06-13 02:14:39 修改 · 2.1k 阅读 · 15 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#golang

于 2024-06-23 01:00:00 首次发布
部署运行你感兴趣的模型镜像

文章目录

类型断言

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

面试题

请问关于类型转化，下面选项正确的是？

A.
type MyInt int
var i int = 1
var j MyInt = i

B.
type MyInt int
var i int = 1
var j MyInt = (MyInt)i

C.
type MyInt int
var i int = 1
var j MyInt = MyInt(i)

D.
type MyInt int
var i int = 1
var j MyInt = i.(MyInt)

面试题答案

在 Go 语言中，类型转换需要显式进行，特别是当涉及自定义类型（即使底层类型相同）。分析选项：

  • A. 错误：
    var j MyInt = i
    直接赋值会编译失败，因为 MyInt 和 int 是不同的类型（尽管底层类型相同）。Go 要求显式转换。

  • B. 错误：
    var j MyInt = (MyInt)i
    语法无效。Go 的类型转换必须是 T(v) 形式，括号只能用于表达式分组，不能用于类型转换。这里会导致编译错误。

  • C. 正确：
    var j MyInt = MyInt(i)
    这是 Go 标准类型转换语法：目标类型(值)。它将 i（int 类型）显式转换为 MyInt 类型，编译和运行正确。

  • D. 错误：
    var j MyInt = i.(MyInt)
    i.(MyInt) 是类型断言语法，但类型断言只能用于接口类型（interface）。i 是具体类型 int，非接口，因此编译失败。

正确答案：C

原因：
Go 要求自定义类型与底层基础类型之间必须显式转换，正确语法是 MyInt(i)。其他选项语法错误或机制不匹配。

参考资料

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

您可能感兴趣的与本文相关的镜像

ACE-Step

ACE-Step

音乐合成
ACE-Step

ACE-Step是由中国团队阶跃星辰（StepFun）与ACE Studio联手打造的开源音乐生成模型。 它拥有3.5B参数量，支持快速高质量生成、强可控性和易于拓展的特点。 最厉害的是，它可以生成多种语言的歌曲，包括但不限于中文、英文、日文等19种语言

Golang类型断言性能优化：提升代码效率的3个技巧
Golang编程笔记的博客
05-13 760
Golang的接口设计因其灵活性成为构建模块化系统的核心工具，但接口的动态类型特性需要通过类型断言进行静态类型还原。本文聚焦类型断言在高频调用场景下的性能问题，通过底层原理分析和实战技巧，帮助开发者在接口密集型系统（如微服务框架、高性能API网关、分布式中间件）中实现效率优化。类型断言核心概念与底层原理（接口结构、断言实现机制）性能瓶颈分析（运行时开销来源、典型场景性能数据）三大优化技巧（原理+代码实现+性能对比）实战案例：高并发场景下的断言优化（开发环境、代码实现、压测结果）
Golang类型断言在反射中的应用：深入源码分析
Golang编程笔记的博客
04-14 750
本文旨在通过源码级分析，揭示Golang中类型断言（Type Assertion）与反射（Reflection）机制的深度整合逻辑。接口类型（）的内存模型与动态类型存储方式类型断言在运行时的具体实现（函数解析）反射包（reflect）中类型断言的核心应用场景安全断言与非安全断言在反射API中的差异化使用目标是帮助中高级Golang开发者理解类型系统动态特性，掌握复杂反射场景下的类型处理技巧。背景知识：建立接口、类型断言、反射的基础概念体系核心原理：解析接口内存布局与类型断言的运行时实现。
深入理解 TypeScript 中的类型断言(Type Assertion)
vvilkin的学习备忘
03-29 1793
类型断言是 TypeScript 中一个强大而独特的特性，它允许开发者告诉编译器："我知道这个值的类型是什么，请相信我"。本文将全面探讨类型断言的概念、语法、使用场景、最佳实践以及潜在陷阱，帮助你在 TypeScript 开发中更有效地使用这一特性。
TypeScript基础知识（四）类型断言和类型保护
青轩桃李能几何，流光欺人忽蹉跎
08-07 540
类型断言（Type Assertion）是 TypeScript 中的一种语法，它允许我们告诉编译器某个值的具体类型，并相信我们的断言是正确的。类型断言在编译时不会进行类型检查，但它只会影响编译阶段的类型推断，不会影响实际运行时的类型。它可以用来缩小变量的类型范围，使得变量在特定的条件下具有更具体的类型。请注意，在使用类型断言时要确保断言的类型是准确的，避免类型错误。通过使用类型保护和类型断言，我们可以在不同的分支中处理不同的类型，并获得更好的类型安全性。，即可以是数字类型也可以是字符串类型。
Go语言两种断言机制解析
最新发布
jiajixi的博客
10-11 340
assert函数的最后一个参数是自定义错误信息（支持格式化，类似fmt.Printf// 加上自定义信息，失败时能明确知道是哪个用例assert.Equal(t, 5, Add(2, 3), "Add(2,3) 计算错误，预期5")assert.Equal(t, 0, Add(0, 0), "Add(0,0) 计算错误，预期0")assert.Equal(t, -3, Add(-1, -2), "Add(-1,-2) 计算错误，预期-3")
【TS】TypeScript类型断言：掌握类型转换的艺术
鑫宝的博客
08-01 4257
类型断言是一种告诉编译器"相信我，我知道我在做什么"的方式。它类似于其他语言中的类型转换，但不进行特殊的数据检查和重构。类型断言纯粹是一个编译时语法，不会影响程序的运行时行为。
golang 类型断言
qq_49723651的博客
11-29 5733
类型断言 文章目录类型断言空接口.(具体类型)非空接口.(具体类型)空接口.(非空接口)非空接口.(非空接口)Type Switch 我们已经知道接口可以分为空接口与非空接口两类。相对于接口这种“抽象类型”，像int，slice，string，map，struct等类型被称为“具体类型”。 类型断言是Go语言中应用在接口值上的一个神奇特性，而类型断言的目标类型可以是某种具体类型，也可以是某种非空接口类型。这样我们就组合出四种类型断言，接下来就逐一看看它们究竟是如何断言的！ 空接口.(具体类型) va
golang中的类型断言
猛犸象
03-23 3412
goLang有类型转换，类型断言，类型切换 1.接口类型断言 类型断言就是将接口类型的值(x)，装换成类型(T)，成功则返回 T 的实例。格式为： x.(T) // 不安全，会造成panic，程序中断 v := x.(T) // 不安全，会造成panic，程序中断 v, ok: = x.(T) // 推荐写法 类型断言的必要条件就是x是接口类型，非接口类型的x不能做类型断言： var i int=10 v:=i.(int) //错误 i不是接口类型，无法使用接口断言 T可以是非接口类型，如果想断言合法，
golang学习笔记——类型转换
e891377的专栏
11-15 518
函数返回两个值，第一个是转换后的整型值，第二个是可能发生的错误，我们可以使用空白标识符。
golang学习笔记09——golang优秀开发常用开源库汇总
GoppViper的博客
09-08 1361
笔者开发工作中，使用过的各种golang开源开发库汇总，并持续更新中，同学们有好用的库，欢迎分享讨论哈[抱拳][抱拳]！
python转go学习笔记———面向对象
flandreflor的博客
02-23 493
面向对象OOP 结构体Struct go语言没有类，只有结构体，等同于类(class) //定义一个结构体(类) type Book struct { //如果类首字母大写，表示其他包也能够访问 Title string //如果类属性首字母大写，表示该属性公有，否则为私有 auth string } //创建实例 func main() { // 方式一 var bk1 Book = Book{title: "xixi",auth: "flandre"} // 方式
Golang 类型断言
m0_63901241的博客
06-21 7246
在Go语言的interface中可以是任何类型，所以Go给出了类型断言来判断某一时刻接口中所含有的类型，例如现在给出一个接口，名为InterfaceText:上式是接口断言的一般形式，因为此方法不一定每次都可以完好运行，所以err的作用就是判断是否出错。所以一般接口断言常用以下写法： 如果转换合法，则v为InterfaceText转换为类型T的值，err为ture，反之err为false。值得注意的是：InterfaceText必须是接口类型！！！有些时候若是想仅判断是否含有类型T，可以写为： 下面
Golang Gin实践 连载十三 优化你的应用结构和实现Redis缓存
weixin_34050519的博客
06-02 697
优化你的应用结构和实现Redis缓存 项目地址：https://github.com/EDDYCJY/go... 如果对你有所帮助，欢迎点个 Star
go类型断言
summericeZou的博客
06-16 1169
类型断言（Type Assertion）是一个使用在接口值上的操作，用于检查接口类型变量所持有的值是否实现了期望的接口或者具体的类型。在Go语言中类型断言的语法格式如下： 其中，x 表示一个接口的类型，T 表示一个具体的类型（也可为接口类型）。该断言表达式会返回 x 的值（也就是 value）和一个布尔值（也就是 ok），可根据该布尔值判断 x 是否为 T 类型：示例代码如下： 运行结果如下： 需要注意如果不接收第二个参数也就是上面代码中的 ok，断言失败时会直接造成一个 panic。如果 x 为 nil
Go（Golang）类型断言
gopher123的博客
04-25 1429
go类型断言
【白话】Go语言的类型断言
一年之内毫无半点成绩，想起来做人真是没趣。
11-02 787
go语言类型断言类型断言断言之前的变量与之后的变量断言是否实现了某个接口（包含某个方法的实现）类型分支 类型断言 go里面的类型断言写法： x.(T) 其中x为interface{}类型，T是要断言的类型 举个栗子： 有一个接口point，有两个变量pointA、pointB，且这两个变量都实现了改接口 假如我们要实现一个函数func display(p point) { … }，功能是若传入的参数p的那个变量的动态类型是pointA的话，就输出A，是pointB的话，就输出B 这时候就要用到类型断
golang类型断言
weixin_50134791的博客
04-05 221
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
Go语言断言和类型查询
YIYIYI
01-04 2186
Go语言断言和类型查询
全面Golang学习笔记：实战经验与知识点全覆盖
资源摘要信息:"这是我总结的GoLang学习笔记，是结合工作中的实战，知识点非常全面，非常适合大家学习" Go语言（通常称为Golang）是一种开源编程语言，由Google设计，旨在简化软件开发的复杂性。Go语言以其简洁、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值