Go 两种形式的类型转换


Go 两种形式的类型转换

正文

Go 的类型转换常常让人有点迷，有两种形式的”类型转换”：

  1. Type(obj) ：这种形式的类型转换要求 obj 对象的类型和 Type 是等价类型，即实现了相同的方法
  2. obj.(Type) ：这种形式用于向下转型，即接口对象转结构体对象，所以 obj 必须是一个接口对象 , 这种形式在 Go 中一般叫做类型断言

代码示例：

package main

import "fmt"

type Animal interface{ 
    GetName() string 
}

// Cat 实现 Animal 接口
type Cat struct{ 
    name string 
}

func (c *Cat) GetName() string { 
    return "I'm cat : " + c.name 
}

// Dog 实现 Animal 接口
type Dog struct{ 
    name string 
}

func (d *Dog) GetName() string { 
    return "I'm dog : " + d.name 
}

func main() {
    cat := Cat{
        name: "hello kitty"
    }
    
    animal := Animal(&cat) // 结构体转接口，括号里需要传递一个 *Cat 类型而不能是 Cat 类型，因为是 *Cat 类型实现了 GetName() 方法，而不是 Cat 类型
    fmt.Println(animal.GetName())
    
    dog1 := Dog(cat) // 结构体之间进行转换，括号里需要传递一个 Cat 类型，因为 Cat = Dog, *Cat = *Dog
    fmt.Println(dog1.GetName())
    
    dog2 := (*Dog)(&cat)
    fmt.Println(dog2.GetName()) // 如上所述，*Cat = *Dog
    
    cat2, ok := animal.(*Cat)   // 类型断言，左边必须是一个接口类型的对象，当接口对象的实际类型和要转换的目标类型匹配时，转换成功，否则失败
    if ok {
        fmt.Println("convert animal to cat - " + cat2.GetName())
    } else {
        fmt.Println("can not convert animal to cat")
    }
    
    dog3, ok := animal.(*Dog) // 类型断言，接口对象的实际类型和要转换的目标类型不匹配
    if ok {
        fmt.Println("convert animal to dog - " + dog3.GetName())
    } else {
        fmt.Println("can not convert animal to dog")
    }
}

运行结果：

I'm cat : hello kitty 
I'm dog : hello kitty 
I'm dog : hello kitty 
convert animal to cat - I'm cat : hello kitty 
can not convert animal to dog

类型转换

类型转换是用来在不同但相互兼容的类型之间的相互转换的方式，所以，当类型不兼容的时候，是无法转换的。

语法：结果类型 := 目标类型(表达式)

如：

func test() {
    var var1 int = 7
    fmt.Printf("%T->%v\n", var1, var1)
    var2 := float32(var1)
    var3 := int64(var1)
    //var4 := []int8(var1)
    //var5 := []string(var1)
    fmt.Printf("%T->%v\n", var2, var2)
    fmt.Printf("%T->%v\n", var3, var3)
    //fmt.Printf("%T->%d", var4, var4)
    //fmt.Printf("%T->%d", var5, var5)
}

其中，var4和var5处运行会报错。因为类型不兼容。注释后，输出如下：

int->7
float32->7
int64->7

值得注意的是，如果某些类型可能引起误会，应该用括号括起来转换，如下：

func test() {
    // 创建一个int变量，并获得它的指针
    var1 := new(int32)
    
    fmt.Printf("%T->%v\n", var1, var1)
    var2 := *int32(var1)
    fmt.Printf("%T->%v\n", var2, var2)
}

*int32(var1)相当于*(int32(var1))，一个指针，当然不能直接转换成一个int32类型，所以该表达式直接编译错误。 将该表达式改为 (*int32)(var1)就可以正常输出了。输出如下：

*int32->0xc00007e01c
*int32->0xc00007e01c

类型断言

类型断言的本质，跟类型转换类似，都是类型之间进行转换， 不同之处在于，类型断言是在接口之间进行，对于一个对象，把一种接口的引用转换成另一种。

语法：

  1. 目标类型的值，布尔参数 := 表达式.(目标类型) // 安全类型断言
  2. 目标类型的值 := 表达式.(目标类型)　　//非安全类型断言

来看一下安全的类型断言：

func test() {
    var i interface{} = "99"
    j, b := i.(int)
    if b {
        fmt.Printf("%T->%d\n", j, j)
    } else {
        fmt.Println("类型不匹配")
    }
}

输出：

类型不匹配

把"99" 改为 99 ，输出：

int->99






参考资料

Go 两种形式的“类型转换” https://blog.csdn.net/u012124304/article/details/109401561

GO语言总结(5)——类型转换和类型断言 https://www.cnblogs.com/zrtqsk/p/4157350.html

返回