【Go】Go 语言教程--Go 语言类型转换（十八）

我不是女神ヾ 2023-10-13 19:52 34阅读 0赞

往期回顾：

*  [Go 语言教程–介绍（一）][Go]
 *  [Go 语言教程–语言结构（二）][Go 1]
 *  [Go 语言教程–语言结构（三）][Go 2]
 *  [Go 语言教程–数据类型（四）][Go 3]
 *  [Go 语言教程–语言变量（五）][Go 4]
 *  [Go 语言教程–GO语言常量（六）][Go _GO]
 *  [Go 语言教程–GO语言运算符（七）][Go _GO 1]
 *  [Go 语言教程–GO条件和循环语句（八）][Go _GO 2]
 *  [Go 语言教程–GO语言函数（九）][Go _GO 3]
 *  [Go 语言教程–GO语言变量作用域（十）][Go _GO 4]
 *  [Go 语言教程–GO语言数组（十一）][Go _GO 5]
 *  [Go 语言教程–GO语言指针（十二）][Go _GO 6]
 *  [Go 语言教程–GO语言结构体（十三）][Go _GO 7]
 *  [Go 语言教程–GO语言切片(Slice)（十四）][Go _GO_Slice]
 *  [Go 语言教程–Go 语言范围(Range)（十五）][Go _Go _Range]
 *  [Go 语言教程–Go 语言Map(集合)（十六）][Go _Go _Map]
 *  [Go 语言教程–Go 语言递归函数（十七）][Go _Go]

#### 文章目录 ####

*  数值类型转换
 *  字符串类型转换
 *  接口类型转换

类型转换用于将一种数据类型的变量转换为另外一种类型的变量。

Go 语言类型转换基本格式如下：

type_name(expression)

type\_name 为类型，expression 为表达式。

## 数值类型转换 ##

将整型转换为浮点型：

var a int = 10
    var b float64 = float64(a)

以下实例中将整型转化为浮点型，并计算结果，将结果赋值给浮点型变量：

实例

package main
    
    import "fmt"
    
    func main() {
        
       var sum int = 17
       var count int = 5
       var mean float32
       
       mean = float32(sum)/float32(count)
       fmt.Printf("mean 的值为: %f\n",mean)
    }

以上实例执行输出结果为：

mean 的值为: 3.400000

## 字符串类型转换 ##

将一个字符串转换成另一个类型，可以使用以下语法：

var str string = "10"
    var num int
    num, _ = strconv.Atoi(str)

以上代码将字符串变量 str 转换为整型变量 num。

注意，strconv.Atoi 函数返回两个值，第一个是转换后的整型值，第二个是可能发生的错误，我们可以使用空白标识符 \_ 来忽略这个错误。

以下实例将字符串转换为整数

实例

package main
    
    import (
        "fmt"
        "strconv"
    )
    
    func main() {
        
        str := "123"
        num, err := strconv.Atoi(str)
        if err != nil {
        
            fmt.Println("转换错误:", err)
        } else {
        
            fmt.Printf("字符串 '%s' 转换为整数为：%d\n", str, num)
        }
    }

以上实例执行输出结果为：

字符串 '123' 转换为整数为：123

以下实例将整数转换为字符串：

实例

package main
    
    import (
        "fmt"
        "strconv"
    )
    
    func main() {
        
        num := 123
        str := strconv.Itoa(num)
        fmt.Printf("整数 %d  转换为字符串为：'%s'\n", num, str)
    }

以上实例执行输出结果为：

整数 123  转换为字符串为：'123'

以下实例将字符串转换为浮点数：

实例

package main
    
    import (
        "fmt"
        "strconv"
    )
    
    func main() {
        
        str := "3.14"
        num, err := strconv.ParseFloat(str, 64)
        if err != nil {
        
            fmt.Println("转换错误:", err)
        } else {
        
            fmt.Printf("字符串 '%s' 转为浮点型为：%f\n", str, num)
        }
    }

以上实例执行输出结果为：

字符串 '3.14' 转为浮点型为：3.140000

以下实例将浮点数转换为字符串：

实例

package main
    
    import (
        "fmt"
        "strconv"
    )
    
    func main() {
        
        num := 3.14
        str := strconv.FormatFloat(num, 'f', 2, 64)
        fmt.Printf("浮点数 %f 转为字符串为：'%s'\n", num, str)
    }

以上实例执行输出结果为：

浮点数 3.140000 转为字符串为：'3.14'

## 接口类型转换 ##

接口类型转换有两种情况：类型断言和类型转换。

类型断言用于将接口类型转换为指定类型，其语法为：

value.(type) 
    或者 
    value.(T)

其中 value 是接口类型的变量，type 或 T 是要转换成的类型。

如果类型断言成功，它将返回转换后的值和一个布尔值，表示转换是否成功。

实例

package main
    
    import "fmt"
    
    func main() {
        
        var i interface{
        } = "Hello, World"
        str, ok := i.(string)
        if ok {
        
            fmt.Printf("'%s' is a string\n", str)
        } else {
        
            fmt.Println("conversion failed")
        }
    }

以上实例中，我们定义了一个接口类型变量 i，并将它赋值为字符串 “Hello, World”。然后，我们使用类型断言将 i 转换为字符串类型，并将转换后的值赋值给变量 str。最后，我们使用 ok 变量检查类型转换是否成功，如果成功，我们打印转换后的字符串；否则，我们打印转换失败的消息。

类型转换用于将一个接口类型的值转换为另一个接口类型，其语法为：

T(value)

T 是目标接口类型，value 是要转换的值。

在类型转换中，我们必须保证要转换的值和目标接口类型之间是兼容的，否则编译器会报错。

实例

package main
    
    import "fmt"
    
    type Writer interface {
        
        Write([]byte) (int, error)
    }
    
    type StringWriter struct {
        
        str string
    }
    
    func (sw *StringWriter) Write(data []byte) (int, error) {
        
        sw.str += string(data)
        return len(data), nil
    }
    
    func main() {
        
        var w Writer = &StringWriter{
        }
        sw := w.(*StringWriter)
        sw.str = "Hello, World"
        fmt.Println(sw.str)
    }

以上实例中，我们定义了一个 Writer 接口和一个实现了该接口的结构体 StringWriter。然后，我们将 StringWriter 类型的指针赋值给 Writer 接口类型的变量 w。接着，我们使用类型转换将 w 转换为 StringWriter 类型，并将转换后的值赋值给变量 sw。最后，我们使用 sw 访问 StringWriter 结构体中的字段 str，并打印出它的值。

[Go]: https://blog.csdn.net/u011397981/article/details/131498341
[Go 1]: https://blog.csdn.net/u011397981/article/details/131523907
[Go 2]: https://blog.csdn.net/u011397981/article/details/131523987
[Go 3]: https://blog.csdn.net/u011397981/article/details/131525361
[Go 4]: https://blog.csdn.net/u011397981/article/details/131543946
[Go _GO]: https://blog.csdn.net/u011397981/article/details/131553561
[Go _GO 1]: https://blog.csdn.net/u011397981/article/details/131567591
[Go _GO 2]: https://blog.csdn.net/u011397981/article/details/131590680
[Go _GO 3]: https://blog.csdn.net/u011397981/article/details/131607945
[Go _GO 4]: https://blog.csdn.net/u011397981/article/details/131609123
[Go _GO 5]: https://blog.csdn.net/u011397981/article/details/131649896
[Go _GO 6]: https://writer.blog.csdn.net/article/details/131705852
[Go _GO 7]: https://blog.csdn.net/u011397981/article/details/131725092
[Go _GO_Slice]: https://writer.blog.csdn.net/article/details/131740556
[Go _Go _Range]: https://blog.csdn.net/u011397981/article/details/131740708?spm=1001.2014.3001.5501
[Go _Go _Map]: https://blog.csdn.net/u011397981/article/details/131758199
[Go _Go]: https://blog.csdn.net/u011397981/article/details/131786257