Golang实现string，int，int64及float类型互相转换的方法

原创 2025-05-27 10:11:46编程技术

425

在 Go 语言开发中，类型转换是日常操作中不可或缺的一环。由于 Go 是静态类型语言，不同类型之间的转换需要显式声明，这既保证了类型安全，也要求开发者对类型系统有清晰认知。本文ZHANID工具网将系统讲解 string、int、int64 和 float 四大基础类型之间的转换方法，结合官方标准库和最佳实践，帮助开发者掌握类型转换的核心技巧。

一、string 与整数类型的互相转换

1. string → int/int64

核心方法：使用 strconv 包的 ParseInt 或 Atoi 函数
适用场景：将数字字符串转换为整数类型

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // string → int
    strInt := "42"
    if num, err := strconv.Atoi(strInt); err == nil {
        fmt.Printf("Converted int: %d (Type: %T)\n", num, num) // 42 (int)
    } else {
        fmt.Println("Conversion error:", err)
    }

    // string → int64（指定进制和位大小）
    strInt64 := "1024"
    if num64, err := strconv.ParseInt(strInt64, 10, 64); err == nil {
        fmt.Printf("Converted int64: %d (Type: %T)\n", num64, num64) // 1024 (int64)
    }
}

关键参数说明：

base: 进制（2-36），如 10 表示十进制
bitSize: 目标整数类型（0/8/16/32/64）
返回值包含错误对象，必须进行错误检查

2. int/int64 → string

核心方法：使用 strconv 包的 Itoa 或 FormatInt 函数
适用场景：将整数转换为十进制字符串表示

func main() {
    // int → string
    num := 42
    str := strconv.Itoa(num)
    fmt.Printf("Converted string: %s (Type: %T)\n", str, str) // "42" (string)

    // int64 → string（指定进制）
    num64 := int64(1024)
    str64 := strconv.FormatInt(num64, 16) // 转为16进制字符串
    fmt.Printf("Hex string: %s (Type: %T)\n", str64, str64) // "400" (string)
}

进制扩展：

二进制：base=2
八进制：base=8
十六进制：base=16（大写字母需额外处理）

二、string 与 float 类型的互相转换

1. string → float

核心方法：使用 strconv.ParseFloat 函数
适用场景：将浮点数字符串转换为 float32/float64

func main() {
    strFloat := "3.1415926"
    if f, err := strconv.ParseFloat(strFloat, 64); err == nil {
        fmt.Printf("Converted float64: %.7f (Type: %T)\n", f, f) // 3.1415926 (float64)
    }
}

精度控制：

第二个参数 bitSize 指定目标类型（32 或 64）
转换时会保留原始精度，超出部分按四舍五入处理

2. float → string

核心方法：使用 strconv.FormatFloat 函数
适用场景：将浮点数转换为指定格式的字符串

func main() {
    f := 3.1415926
    // 格式化选项：'f'（定点表示法）、'e'（科学计数法）、'g'（自动选择）
    str := strconv.FormatFloat(f, 'f', 4, 64) // 保留4位小数
    fmt.Printf("Formatted string: %s (Type: %T)\n", str, str) // "3.1416" (string)
}

格式化参数详解：

fmt: 格式标记（f/e/E/g/G）
prec: 精度（小数点后位数）
bitSize: 原始浮点数类型（32/64）

三、整数类型之间的转换

1. int ↔ int64

显式类型转换：

var i int = 42
var i64 int64 = int64(i)  // int → int64
i = int(i64)               // int64 → int（注意可能的精度损失）

平台差异注意：

在 32 位系统：int 为 4 字节，int64 为 8 字节
在 64 位系统：int 为 8 字节，与 int64 等价

2. int/int64 ↔ float

直接类型转换：

var i int = 42
f := float64(i)  // int → float64
i = int(f)       // float64 → int（截断小数部分）

精度风险：

浮点数转整数会丢失小数部分
大整数转浮点数可能丢失精度（超过 2^53 时）

四、类型转换的通用技巧

1. 错误处理最佳实践

// 统一错误处理函数
func safeConvert(s string) (int, error) {
    if num, err := strconv.Atoi(s); err != nil {
        return 0, fmt.Errorf("invalid integer: %q", s)
    }
    return num, nil
}

// 使用示例
if num, err := safeConvert("123a"); err != nil {
    fmt.Println("Error:", err) // 输出: invalid integer: "123a"
}

2. 性能优化建议

优先使用 strconv 包：相比 fmt.Sprintf，strconv 方法性能更高
避免重复转换：缓存常用转换结果
批量处理优化：使用 strings.Builder 进行批量字符串操作

3. 边界值测试用例

// 测试用例推荐
testCases := []struct {
    input    string
    expected int64
}{
    {"0", 0},
    {"-2147483648", math.MinInt32},
    {"9223372036854775807", math.MaxInt64},
    {"18446744073709551616", 0}, // 超出int64范围
}

for _, tc := range testCases {
    if res, _ := strconv.ParseInt(tc.input, 10, 64); res != tc.expected {
        t.Errorf("Failed: %s → %d", tc.input, res)
    }
}

五、常见问题解决方案

1. 处理带符号的数字字符串

str := "-123.45"
if num, err := strconv.ParseFloat(str, 64); err == nil {
    // 自动处理正负号
}

2. 十六进制字符串转换

// 十六进制 → 整数
hexStr := "1a3f"
num, _ := strconv.ParseInt(hexStr, 16, 64) // 输出: 6719

// 整数 → 十六进制（大写）
str := strings.ToUpper(strconv.FormatInt(num, 16))

3. 科学计数法处理

// 科学计数法 → float
sciStr := "6.022e23"
f, _ := strconv.ParseFloat(sciStr, 64) // 输出: 6.022e+23

// float → 科学计数法
str := strconv.FormatFloat(f, 'e', 3, 64)