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 程式至關重要。