Golang字符串与int、uint、int64、uint64互转方法指南

字符串与整型互转的核心方法

Golang中没有自动的类型提升，类型转换需显式进行。对于字符串与整型的转换，标准库 strconv 提供了丰富的函数。

第1步：字符串转int、int64或uint64

目的：将表示数字的字符串解析为对应的整数类型。

• 转 int： 使用 strconv.Atoi(string) (int, error)。这是最常用的方式，默认按十进制解析。
• 转 int64： 推荐使用 strconv.ParseInt(string, base, bitSize) (int64, error)。
  • 参数 base：进制数（如10、16、2）。范围2-36。
  • 参数 bitSize：限制结果的范围，通常设为64以覆盖所有情况。
• 转 uint64： 同样可使用 ParseInt 获取 int64 后强制转换为 uint64，或使用专门的无符号转换逻辑。

第2步：int、int64转字符串

目的：将内存中的整数格式化为可读的字符串。

• int 转 string： 使用 strconv.Itoa(int) string。它是 FormatInt(int64, 10) 的便捷封装。
• int64 转 string： 使用 strconv.FormatInt(int64, base) string。需指定进制，默认为10。
• uint64 转 string： 使用 strconv.FormatUint(uint64, base) string。

第3步：整数类型间直接互转

当需要在 int、int8、int32、int64、uint、uint64 之间转换时，直接使用类型构造函数（Type Cast）即可，例如 int64(intValue) 或 int(uint64Value)。

完整代码示例与验证

以下代码展示了上述转换的具体实现，并包含类型打印以验证转换结果。

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	var testStr string = "123456"

	// 1. 字符串转 int
	intNum, _ := strconv.Atoi(testStr)
	fmt.Println("intNum =", intNum, ", 类型:", reflect.TypeOf(intNum))

	// 2. 字符串转 int64 (推荐直接使用 ParseInt)
	int64Num, _ := strconv.ParseInt(testStr, 10, 64)
	fmt.Println("int64Num =", int64Num, ", 类型:", reflect.TypeOf(int64Num))

	// ===================================================

	// 3. int 转 字符串
	var intNum2 int = 123456
	str1 := strconv.Itoa(intNum2)
	fmt.Println("str1 =", str1, ", 类型:", reflect.TypeOf(str1))

	// 4. int64 转 字符串
	var int64Num2 int64 = 123456
	str2 := strconv.FormatInt(int64Num2, 10)
	fmt.Println("str2 =", str2, ", 类型:", reflect.TypeOf(str2))

	fmt.Println("----------------- 内部类型转换 ---------------------")

	// 5. int 与 int64 互转
	var num3 int = 30
	var num4 int64 = int64(num3)
	fmt.Printf("num3(原): %T=%v -> num4(新): %T=%v\n", num3, num3, num4, num4)

	var num5 int64 = 20
	var num6 int = int(num5)
	fmt.Printf("num5(原): %T=%v -> num6(新): %T=%v\n", num5, num5, num6, num6)
}

运行上述代码，输出结果如下：

intNum = 123456 , 类型: int
int64Num = 123456 , 类型: int64
str1 = 123456 , 类型: string
str2 = 123456 , 类型: string
----------------- 内部类型转换 ---------------------
num3(原): int=30 -> num4(新): int64=30
num5(原): int64=20 -> num6(新): int=20

高级用法：指定进制转换

strconv.ParseInt 和 strconv.FormatInt 支持多种进制，这在处理十六进制地址或二进制数据时非常有用。

1. ParseInt 解析非十进制字符串

例如，字符串 "e" 在十六进制中代表十进制的 14。

var hexStr string = "e"
// base: 16 (十六进制), bitSize: 64
val, err := strconv.ParseInt(hexStr, 16, 64)
if err == nil {
	fmt.Println("十六进制 'e' 解析结果:", val)
}

结果：14。

2. FormatInt 格式化为其他进制

若要将整数转换为十六进制字符串：

num := 255
hexStr := strconv.FormatInt(int64(num), 16) // 结果为 "ff"
fmt.Println("255 的十六进制:", hexStr)

注意事项总结

• 错误处理： Atoi、ParseInt 返回的第二个值是error类型，在实际业务中不应忽略，应检查是否因非法字符导致转换失败。
• 截断风险： 从高位宽类型（如 int64）转换到低位宽类型（如 int，且在某些系统上 int 可能小于64位）时，如果数值超出低位宽类型的范围，会发生截断，导致数据错误。建议在转换前确认数值范围。
• 性能差异： Atoi 和 Itoa 针对十进制做了优化，速度略快于通用的 ParseInt/FormatInt。若确定只处理十进制，优先使用前者。

以上就是Golang字符串与int、uint、int64、uint64互转的详细内容，更多关于Go语言基础类型转换的资料请关注本站其它相关文章！