类型转换 #

一、类型转换概述 #

Go是强类型语言，不同类型之间不能直接运算，必须显式转换。

var a int = 10
var b float64 = float64(a)  // 显式转换

二、数值类型转换 #

2.1 整数之间转换 #

var a int = 100
var b int8 = int8(a)
var c int64 = int64(a)
var d uint = uint(a)

fmt.Println(b, c, d)

2.2 整数与浮点数转换 #

var i int = 10
var f float64 = float64(i)  // int → float64
var j int = int(f)          // float64 → int

fmt.Println(f)  // 10
fmt.Println(j)  // 10

2.3 浮点数之间转换 #

var f32 float32 = 3.14
var f64 float64 = float64(f32)

fmt.Println(f64)

2.4 精度丢失 #

var f float64 = 3.99
var i int = int(f)

fmt.Println(i)  // 3（截断，非四舍五入）

2.5 溢出问题 #

var i int64 = 300
var b int8 = int8(i)

fmt.Println(b)  // 44（溢出）

三、字符串转换 #

3.1 strconv包 #

Go使用strconv包进行字符串与基本类型转换。

3.2 整数转字符串 #

import "strconv"

s := strconv.Itoa(123)  // "123"
fmt.Println(s)

s2 := strconv.FormatInt(123, 10)  // 十进制
s3 := strconv.FormatInt(255, 16)  // 十六进制 "ff"

3.3 字符串转整数 #

i, err := strconv.Atoi("123")
if err != nil {
    fmt.Println("转换失败")
}
fmt.Println(i)  // 123

i2, err := strconv.ParseInt("ff", 16, 64)  // 十六进制
fmt.Println(i2)  // 255

3.4 浮点数转字符串 #

s := strconv.FormatFloat(3.14159, 'f', 2, 64)
fmt.Println(s)  // "3.14"

// 参数：值，格式，精度，位数
// 格式：'f'十进制，'e'科学计数法，'g'自动选择

3.5 字符串转浮点数 #

f, err := strconv.ParseFloat("3.14", 64)
if err != nil {
    fmt.Println("转换失败")
}
fmt.Println(f)  // 3.14

3.6 布尔值转换 #

s := strconv.FormatBool(true)   // "true"
b, _ := strconv.ParseBool("true")  // true

四、字符与数值转换 #

4.1 字符转数值 #

var c byte = 'A'
n := int(c)
fmt.Println(n)  // 65

4.2 数值转字符 #

n := 65
c := byte(n)
fmt.Printf("%c\n", c)  // A

4.3 rune转换 #

r := '中'
fmt.Printf("%c, %d\n", r, r)  // 中, 20013

n := 20013
r2 := rune(n)
fmt.Printf("%c\n", r2)  // 中

五、字符串与字节切片 #

5.1 字符串转字节切片 #

s := "Hello"
b := []byte(s)
fmt.Println(b)  // [72 101 108 108 111]

5.2 字节切片转字符串 #

b := []byte{72, 101, 108, 108, 111}
s := string(b)
fmt.Println(s)  // Hello

5.3 字符串与rune切片 #

s := "世界"
r := []rune(s)
fmt.Println(r)  // [19990 30028]

s2 := string(r)
fmt.Println(s2)  // 世界

六、类型推断 #

6.1 自动推断 #

x := 10          // int
y := 3.14        // float64
z := "hello"     // string
b := true        // bool

6.2 数值推断规则 #

整数字面量默认为int
浮点字面量默认为float64
复数字面量默认为complex128

x := 10           // int
y := 3.14         // float64
z := 1 + 2i       // complex128

6.3 常量推断 #

无类型常量可以赋给不同类型：

const x = 10
var i int = x       // OK
var f float64 = x   // OK
var b byte = x      // OK

七、fmt包格式化 #

7.1 格式化动词 #

动词	说明
%d	整数
%f	浮点数
%s	字符串
%c	字符
%v	默认格式
%T	类型
%x	十六进制
%o	八进制
%b	二进制

7.2 示例 #

n := 255
fmt.Printf("%d\n", n)   // 255
fmt.Printf("%x\n", n)   // ff
fmt.Printf("%o\n", n)   // 377
fmt.Printf("%b\n", n)   // 11111111

f := 3.14159
fmt.Printf("%f\n", f)   // 3.141590
fmt.Printf("%.2f\n", f) // 3.14

s := "Hello"
fmt.Printf("%s\n", s)   // Hello
fmt.Printf("%q\n", s)   // "Hello"

八、常见转换场景 #

8.1 从字符串解析数值 #

func parseNumber(s string) (int, error) {
    return strconv.Atoi(s)
}

n, err := parseNumber("123")
if err != nil {
    fmt.Println("解析失败")
}

8.2 数值格式化输出 #

func formatNumber(n int, base int) string {
    return strconv.FormatInt(int64(n), base)
}

fmt.Println(formatNumber(255, 16))  // ff
fmt.Println(formatNumber(255, 2))   // 11111111

8.3 接口类型断言 #

var i interface{} = "hello"

s, ok := i.(string)
if ok {
    fmt.Println(s)
}

九、转换注意事项 #

9.1 精度问题 #

var f float64 = 3.99
var i int = int(f)  // 3，截断非四舍五入

9.2 溢出问题 #

var i int64 = 128
var b int8 = int8(i)  // -128，溢出

9.3 无效字符串 #

_, err := strconv.Atoi("abc")  // 错误
_, err = strconv.ParseFloat("3.14.15", 64)  // 错误

9.4 类型不兼容 #

var b bool = true
var i int = int(b)  // 错误：不能直接转换

十、最佳实践 #

10.1 检查错误 #

n, err := strconv.Atoi(s)
if err != nil {
    return fmt.Errorf("invalid number: %s", s)
}

10.2 使用fmt.Sprintf #

s := fmt.Sprintf("%d", 123)
s2 := fmt.Sprintf("%.2f", 3.14159)
s3 := fmt.Sprintf("%x", 255)

10.3 类型安全转换 #

func safeIntToInt64(n int) (int64, bool) {
    if n < math.MinInt64 || n > math.MaxInt64 {
        return 0, false
    }
    return int64(n), true
}

十一、总结 #

类型转换要点：

转换类型	方法
数值之间	T(v)
整数↔字符串	strconv.Itoa/Atoi
浮点↔字符串	strconv.FormatFloat/ParseFloat
字符串↔字节	[]byte(s)/string(b)
字符串↔rune	[]rune(s)/string®

关键点：

显式转换：Go不支持隐式类型转换
strconv包：字符串与基本类型转换
精度问题：注意浮点转整数的截断
错误处理：解析字符串时检查错误