Go，也称为 Golang，是一种静态类型语言。这意味着每个变量的类型在编译时都是已知的，从而为代码提供安全性和可预测性。但是，这也要求从一种类型到另一种类型的任何转换都是明确且经过深思熟虑的。在本文中，我们将探讨 Go 中可用的各种类型转换和转换机制，从基本的数值转换到更复杂的接口和指针转换。

1. 基本类型转换

Go 允许在整数、浮点数和字符串等基本类型之间进行转换，但这些转换必须显式完成。

数字类型

不同数字类型之间的转换很简单，但必须明确：

var i int = 42
var f float64 = float64(i)  // int to float64
var u uint = uint(i)        // int to uint

在此示例中，我们将 int 转换为 float64 和 uint。这些转换是显式的，因为 Go 不执行自动（隐式）类型转换。

字符串和字节切片

Go 字符串是不可变的，但它们可以与字节切片 ([]byte) 相互转换，而字节切片 ([]byte) 是可变的：

var s string = "hello"
var b []byte = []byte(s)   // string to []byte
var s2 string = string(b)  // []byte to string

同样，可以在字符串和符文切片（[]rune）之间进行转换，其中符文是 int32 的类型别名：

var r []rune = []rune(s)   // string to []rune
var s3 string = string(r)  // []rune to string

2. 自定义类型转换

在Go中，您可以基于现有类型定义自己的类型。自定义类型与其基础类型之间的转换是显式的：

type MyInt int
var i int = 10
var mi MyInt = MyInt(i)   // int to MyInt
var i2 int = int(mi)      // MyInt to int

此显式转换对于确保编译器可以验证代码的安全性是必要的。

3. 指针转换

Go中的指针引用变量的内存地址。您可以在值与其指针之间进行转换：

var x int = 42
var p *int = &x     // int to *int (pointer to int)
var y int = *p      // *int to int (dereferencing)

4. 接口类型转换

Go中的接口用于定义一组方法。您可以在具体类型和接口之间进行转换：

var a interface{} = 42    // int to interface{}
var b int = a.(int)       // interface{} to int (type assertion)

类型断言

类型断言提供对接口具体值的访问：

if v, ok := a.(int); ok {
    fmt.Println("a is an int:", v)
}

类型开关

类型开关允许您根据接口的动态类型执行不同的操作：

switch v := a.(type) {
case int:
    fmt.Println("a is an int:", v)
case string:
    fmt.Println("a is a string:", v)
default:
    fmt.Println("a is of unknown type")
}

5. 不安全的转换

unsafe 包允许你绕过 Go 的类型安全，从而实现非法的转换：

import "unsafe"

var i int = 42
var p *int = &i
var fp *float64 = (*float64)(unsafe.Pointer(p))  // *int to *float64

警告：应谨慎使用不安全的转换，并且仅在绝对必要时使用，因为它们可能导致未定义的行为。

6. 通道类型转换

通道是 Go 中的一个强大功能，允许 goroutine 之间进行通信。您可以在双向和单向通道之间进行转换：

ch := make(chan int)
var sendOnlyChan chan




  
  
  7. 结构体和数组转换


具有相同布局的结构体或数组之间的转换需要显式转换：


type Point struct {
    X, Y int
}

type Coord struct {
    X, Y int
}

var p Point = Point{1, 2}
var c Coord = Coord(p)  // Convert Point to Coord (same field types)





  
  
  8. 切片转换


切片是对数组的引用，虽然您可以在相同类型的切片之间进行转换，但不同类型的切片之间的转换需要显式转换：


var a []int = []int{1, 2, 3}
var b []int = a[1:]  // Convert a slice to another slice of the same type





  
  
  9. 零接口转换


Go 中的 nil 值可以分配给任何接口类型：


var x interface{} = nil
var y error = nil





  
  
  10. 函数类型转换


Go 函数可以转换为不同类型，只要签名兼容：


type FuncType func(int) int

func square(x int) int {
    return x * x
}

var f FuncType = FuncType(square)  // Convert function to FuncType





  
  
  11. 数组到切片的转换


可以从数组创建切片，它本质上是对数组的引用：


var arr [5]int = [5]int{1, 2, 3, 4, 5}
var sl []int = arr[:]  // Convert array to slice





  
  
  结论


Go 中的类型转换和转换在设计上是明确的，使代码更安全、更容易理解。通过要求显式转换，Go 有助于防止隐式类型强制可能产生的微妙错误，这在其他一些编程语言中很常见。理解这些转换并正确使用它们对于编写健壮且高效的 Go 程序至关重要。