在 Go 中，不同的数据类型之间的转换是常见的需求。Go 是静态类型语言，因此转换必须显式进行。常见的数据类型转换有数字类型之间、字符串与数字类型之间、结构体与 JSON 之间的转换等。下面是一些常见的数据类型转换示例：
Go 提供了显式的类型转换，数字类型之间的转换非常常见。比如 int 转换成 float64 或者 float32 转换成 int。
Life is like a journey
int 转 float64，float64 转 intpackage main
import "fmt"
func main() {
// int to float64
var i int = 42
var f float64 = float64(i) // 显式转换
fmt.Printf("int: %d, float64: %f\n", i, f)
// float64 to int
var f2 float64 = 42.58
var i2 int = int(f2) // 显式转换，丢失小数部分
fmt.Printf("float64: %f, int: %d\n", f2, i2)
}
输出：
int: 42, float64: 42.000000
float64: 42.580000, int: 42
Go 中的字符串和数字之间的转换也需要显式转换，通常使用 strconv 包。
string 转 int，int 转 stringpackage main
import (
"fmt"
"strconv"
)
func main() {
// string to int
str := "123"
i, err := strconv.Atoi(str) // Atoi 转换字符串到整数
if err != nil {
fmt.Println("Error converting string to int:", err)
}
fmt.Printf("string: %s, int: %d\n", str, i)
// int to string
i2 := 456
str2 := strconv.Itoa(i2) // Itoa 转换整数到字符串
fmt.Printf("int: %d, string: %s\n", i2, str2)
}
输出：
string: 123, int: 123
int: 456, string: 456
[]byte (字节切片) 之间的转换Go 中可以很方便地在字符串与字节切片之间进行转换。
string 转 []byte，[]byte 转 stringpackage main
import "fmt"
func main() {
// string to []byte
str := "Hello, Go!"
bytes := []byte(str)
fmt.Printf("string: %s, []byte: %v\n", str, bytes)
// []byte to string
bytes2 := []byte{72, 101, 108, 108, 111} // 对应 "Hello"
str2 := string(bytes2)
fmt.Printf("[]byte: %v, string: %s\n", bytes2, str2)
}
输出：
string: Hello, Go!, []byte: [72 101 108 108 111 44 32 71 111 33]
[]byte: [72 101 108 108 111], string: Hello
Go 中结构体与 JSON 之间的转换通常通过 encoding/json 包来实现。结构体需要通过 json.Marshal 转换为 JSON 字符串，通过 json.Unmarshal 从 JSON 字符串转换为结构体。
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string `json:"name"`
Age int `json:"age"`
}
func main() {
// 结构体转 JSON
p := Person{Name: "John", Age: 30}
jsonData, err := json.Marshal(p) // 转换为 JSON 字符串
if err != nil {
fmt.Println("Error marshalling struct:", err)
}
fmt.Printf("Struct to JSON: %s\n", jsonData)
// JSON 转 结构体
jsonStr := `{"name":"Alice","age":25}`
var p2 Person
err = json.Unmarshal([]byte(jsonStr), &p2) // 解析 JSON
if err != nil {
fmt.Println("Error unmarshalling JSON:", err)
}
fmt.Printf("JSON to Struct: %+v\n", p2)
}
输出：
Struct to JSON: {"name":"John","age":30}
JSON to Struct: {Name:Alice Age:25}
时间类型的转换主要通过 time 包来处理，可以将时间转换为字符串，或者从字符串解析出时间。
string 转 time.Time，time.Time 转 stringpackage main
import (
"fmt"
"time"
)
func main() {
// string to time.Time
dateStr := "2025-01-06 14:30:00"
layout := "2006-01-02 15:04:05"
t, err := time.Parse(layout, dateStr) // 根据格式解析字符串
if err != nil {
fmt.Println("Error parsing time:", err)
}
fmt.Printf("string: %s, time: %v\n", dateStr, t)
// time.Time to string
currentTime := time.Now()
timeStr := currentTime.Format(layout) // 格式化为字符串
fmt.Printf("time: %v, string: %s\n", currentTime, timeStr)
}
输出：
string: 2025-01-06 14:30:00, time: 2025-01-06 14:30:00 +0000 UTC
time: 2025-01-06 14:30:00 +0000 UTC, string: 2025-01-06 14:30:00
在 Go 中，接口类型可以通过类型断言转换成其他类型。类型断言用于从接口类型转换成具体类型。它不仅是一个转换操作，而且可以用于判断某个接口变量是否持有特定的类型。
package main
import "fmt"
func main() {
var x interface{} = 42 // interface{} 存储任何类型
// 断言为 int 类型
if v, ok := x.(int); ok {
fmt.Printf("x is of type int with value: %d\n", v)
} else {
fmt.Println("x is not of type int")
}
// 断言为 string 类型
if v, ok := x.(string); ok {
fmt.Printf("x is of type string with value: %s\n", v)
} else {
fmt.Println("x is not of type string")
}
}
输出：
x is of type int with value: 42
x is not of type string
Go 中的数组和切片是不同的类型，数组是固定长度的，而切片是动态的。虽然切片和数组的底层结构非常相似，但它们并不是直接可以互相转换的类型。
package main
import "fmt"
func main() {
// 数组转切片
arr := [3]int{1, 2, 3}
slice := arr[:] // 使用数组的全部作为切片
fmt.Println("Array:", arr)
fmt.Println("Slice:", slice)
// 切片转数组（必须指定数组长度）
slice2 := []int{4, 5, 6}
arr2 := [3]int{}
copy(arr2[:], slice2) // 使用 copy 将切片内容复制到数组
fmt.Println("Slice:", slice2)
fmt.Println("Array:", arr2)
}
输出：
Array: [1 2 3]
Slice: [1 2 3]
Slice: [4 5 6]
Array: [4 5 6]
Go 中常见的类型转换包括：
int 转 float64，float64 转 int。strconv 包进行转换。encoding/json 包。time 包。在 Go 中，类型转换一般是显式的，需要使用适当的转换方式。