Golang int 转 string 方法详解 – wiki基地

---

Golang int 转 string 方法详解：全面掌握数值与文本的转换

在 Go 语言编程中，我们经常需要在不同数据类型之间进行转换。其中，将整型（int、int64 等）转换为字符串（string）是一个非常常见的操作。例如，在打印输出、文件写入、网络传输或构建 API 响应时，我们都需要将数值表示转换为可读的文本格式。

Go 语言提供了多种方法来实现 int 到 string 的转换，每种方法都有其适用场景、优缺点和性能特点。理解这些方法并知道何时使用哪一种，对于编写高效、健壮且易于维护的 Go 代码至关重要。

本文将详细介绍 Go 语言中将 int 类型转换为 string 的各种方法，包括标准库 strconv 包提供的函数、通用的 fmt 包函数，以及一个需要特别注意的陷阱：直接类型转换。我们将深入探讨每种方法的用法、原理、适用场景、性能差异，并提供丰富的代码示例。

目录

1. 引言：为什么需要 int 转 string
2. strconv 包：数值转换的专业工具
   • strconv.Itoa()：最常用、最简洁的方法
     • 用法与示例
     • 底层原理与适用范围
   • strconv.FormatInt()：更灵活的方法
     • 用法与示例 (指定基数和类型)
     • 与 Itoa 的关系
   • strconv.FormatUint()：处理无符号整型
     • 用法与示例
3. fmt 包：通用的格式化利器
   • fmt.Sprintf()：万能的格式化函数
     • 用法与示例 (使用 %d 和 %v)
     • 与其他方法的比较
4. 陷阱警告：string(int) 直接类型转换
   • 这是做什么？
   • 为什么它不是你想要的数值转字符串
   • 正确的使用场景 (符文/ASCII 码)
   • 示例与深刻理解
5. 性能比较与选择建议
   • 理论分析
   • 实际基准测试 (Benchmark) 示例
   • 结果解读与实践指导
6. 不同整型类型的处理 (int8, int16, int32, int64, uint, etc.)
   • 如何使用上述方法处理不同位数的整型
7. 总结：何时选择哪种方法

---

1. 引言：为什么需要 int 转 string

计算机内部存储的数字是以二进制形式存在的。当我们需要将这些数字展示给用户、写入文本文件、通过网络发送文本协议数据，或者与需要文本格式的外部系统交互时，就需要将内部的数值表示转换为外部的字符串表示。

例如，你有一个计算结果 totalScore int = 95，你想在控制台打印出 “Your score is 95″。这里的 95 就需要从整型转换为字符串 “95”，然后与 “Your score is ” 拼接起来。

Go 语言的标准库为这种常见的转换提供了多种便捷且高效的工具。

2. strconv 包：数值转换的专业工具

strconv 包（strconv 即 string conversion）专门负责基本数据类型和字符串之间的转换。它是进行 int 和 string 之间相互转换的首选包，因为它通常更高效且语义更明确。

2.1 strconv.Itoa()：最常用、最简洁的方法

Itoa 是 “Integer to ASCII” 的缩写，用于将一个 int 类型的值转换为其对应的十进制字符串表示。这是 Go 语言中将 int 转换为 string 最直接、最常用的方法。

函数签名：
go
func Itoa(i int) string

它接收一个 int 类型的参数 i，返回一个 string 类型的结果。

用法与示例：

“`go
package main

import (
“fmt”
“strconv”
)

func main() {
num := 123
str := strconv.Itoa(num)

fmt.Printf("原始 int 类型: %d (类型: %T)\n", num, num)
fmt.Printf("转换后 string 类型: %s (类型: %T)\n", str, str)

// 验证类型
fmt.Println("Is str a string?", str == "123") // true

}
“`

输出：
原始 int 类型: 123 (类型: int)
转换后 string 类型: 123 (类型: string)
Is str a string? true

底层原理与适用范围：

strconv.Itoa(i) 实际上是 strconv.FormatInt(int64(i), 10) 的一个快捷方式。它专门用于处理 Go 的原生 int 类型（其大小取决于系统架构，可能是 32 位或 64 位），并始终将其转换为十进制（Base 10）的字符串。

由于它是一个专门优化的函数，对于简单的 int 到十进制字符串的转换，Itoa 通常是最高效的方法之一，并且代码简洁易读。

适用范围：
* 将 int 类型变量转换为十进制字符串。
* 追求简洁和效率的常见场景。

局限性：
* 只能处理 int 类型，不能直接处理 int64、uint 等其他整型。
* 只能转换为十进制字符串。

2.2 strconv.FormatInt()：更灵活的方法

FormatInt 提供了更高的灵活性，它可以将一个 int64 类型的值转换为指定基数（base）的字符串表示。

函数签名：
go
func FormatInt(i int64, base int) string

它接收两个参数：
1. i int64: 需要转换的整型值。注意这里要求是 int64。如果你的数值是其他整型类型（如 int, int32, int16, int8），需要先将其转换为 int64。
2. base int: 转换后的字符串表示所使用的基数。常见的基数有：
* 2: 二进制
* 8: 八进制
* 10: 十进制
* 16: 十六进制
* 其他基数范围为 2 到 36。

用法与示例 (指定基数和类型)：

“`go
package main

import (
“fmt”
“strconv”
)

func main() {
var num int64 = 42 // FormatInt 需要 int64 类型

// 转换为十进制 (相当于 Itoa 的底层实现)
strDecimal := strconv.FormatInt(num, 10)
fmt.Printf("十进制 (base 10): %s (类型: %T)\n", strDecimal, strDecimal)

// 转换为二进制
strBinary := strconv.FormatInt(num, 2)
fmt.Printf("二进制 (base 2): %s (类型: %T)\n", strBinary, strBinary)

// 转换为十六进制
strHex := strconv.FormatInt(num, 16)
fmt.Printf("十六进制 (base 16): %s (类型: %T)\n", strHex, strHex)

// 转换为八进制
strOctal := strconv.FormatInt(num, 8)
fmt.Printf("八进制 (base 8): %s (类型: %T)\n", strOctal, strOctal)

// 如果是 int 类型，需要先转换为 int64
numInt := 99
strFromInt := strconv.FormatInt(int64(numInt), 10)
fmt.Printf("从 int 转换为 string (通过 FormatInt): %s (类型: %T)\n", strFromInt, strFromInt)

}
“`

输出：
十进制 (base 10): 42 (类型: string)
二进制 (base 2): 101010 (类型: string)
十六进制 (base 16): 2a (类型: string)
八进制 (base 8): 52 (类型: string)
从 int 转换为 string (通过 FormatInt): 99 (类型: string)

与 Itoa 的关系：

正如前面提到的，strconv.Itoa(i) 的实现就是 return FormatInt(int64(i), 10)。这意味着 Itoa 是 FormatInt 在特定场景（int 类型，基数 10）下的一个方便的特例。当你需要转换 int64 或需要指定非十进制基数时，就必须使用 FormatInt。

适用范围：
* 需要将 int64 类型变量转换为字符串。
* 需要将整型转换为非十进制（二进制、八进制、十六进制等）字符串表示。

局限性：
* 要求输入类型是 int64（或需要强制转换为 int64）。
* 只能处理带符号整型（int64）。

2.3 strconv.FormatUint()：处理无符号整型

与 FormatInt 类似，strconv 包还提供了 FormatUint 函数用于处理无符号整型（uint, uint64 等）。

函数签名：
go
func FormatUint(i uint64, base int) string

它接收两个参数：
1. i uint64: 需要转换的无符号整型值。需要是 uint64 类型。
2. base int: 转换后的字符串表示所使用的基数 (2 到 36)。

用法与示例：

“`go
package main

import (
“fmt”
“strconv”
)

func main() {
var numUint uint64 = 255 // FormatUint 需要 uint64 类型

// 转换为十进制
strDecimal := strconv.FormatUint(numUint, 10)
fmt.Printf("无符号整型 十进制 (base 10): %s (类型: %T)\n", strDecimal, strDecimal)

// 转换为十六进制
strHex := strconv.FormatUint(numUint, 16)
fmt.Printf("无符号整型 十六进制 (base 16): %s (类型: %T)\n", strHex, strHex) // 255 在16进制是 ff

// 如果是 uint 类型，需要先转换为 uint64
var numPlainUint uint = 1024
strFromUint := strconv.FormatUint(uint64(numPlainUint), 10)
fmt.Printf("从 uint 转换为 string (通过 FormatUint): %s (类型: %T)\n", strFromUint, strFromUint)

}
“`

输出：
无符号整型 十进制 (base 10): 255 (类型: string)
无符号整型 十六进制 (base 16): ff (类型: string)
从 uint 转换为 string (通过 FormatUint): 1024 (类型: string)

适用范围：
* 需要将无符号整型（uint, uint64, uint32 等）转换为字符串。
* 需要将无符号整型转换为非十进制字符串表示。

总结 strconv 方法：
* Itoa(i int): 最快、最简洁，仅限 int 到十进制。
* FormatInt(i int64, base int): 灵活，处理 int64 和指定基数，用于带符号整型。
* FormatUint(i uint64, base int): 灵活，处理 uint64 和指定基数，用于无符号整型。

对于其他整数类型（int8, int16, int32, uint8, uint16, uint32），需要先强制转换为 int64 或 uint64 后再使用 FormatInt 或 FormatUint。Go 语言允许在不同大小的整型之间进行显式转换。

3. fmt 包：通用的格式化利器

fmt 包提供了格式化输入输出的功能，其中最常用的是 fmt.Sprintf 函数，它可以根据指定的格式字符串将各种类型的值格式化并输出到一个字符串中。

3.1 fmt.Sprintf()：万能的格式化函数

fmt.Sprintf 函数类似于 C 语言的 sprintf，它接收一个格式字符串和可变数量的参数，根据格式字符串的指示对参数进行格式化，并返回一个格式化后的字符串。

函数签名 (简化版)：
go
func Sprintf(format string, a ...interface{}) string
它接收一个格式字符串 format 和一个可变参数列表 a，其中每个参数都可以是任意类型（通过 interface{} 实现）。

用法与示例 (使用 %d 和 %v)：

对于整型，常用的格式化动词有：
* %d: 十进制整数
* %v: 值的默认格式 (对于整型也是十进制)
* %b: 二进制
* %o: 八进制
* %x: 十六进制 (小写)
* %X: 十六进制 (大写)

“`go
package main

import (
“fmt”
)

func main() {
num := 456 // 可以是 int, int64, uint 等多种整型类型

// 使用 %d 格式化十进制
strDecimalD := fmt.Sprintf("%d", num)
fmt.Printf("使用 %%d (十进制): %s (类型: %T)\n", strDecimalD, strDecimalD)

// 使用 %v 格式化 (默认也是十进制)
strDecimalV := fmt.Sprintf("%v", num)
fmt.Printf("使用 %%v (默认): %s (类型: %T)\n", strDecimalV, strDecimalV)

// 格式化为二进制
strBinary := fmt.Sprintf("%b", num)
fmt.Printf("使用 %%b (二进制): %s (类型: %T)\n", strBinary, strBinary)

// 格式化为十六进制
strHex := fmt.Sprintf("%x", num)
fmt.Printf("使用 %%x (十六进制): %s (类型: %T)\n", strHex, strHex)

// fmt.Sprintf 的强大之处在于可以将数字嵌入到其他字符串中
age := 30
message := fmt.Sprintf("用户年龄: %d 岁", age)
fmt.Println(message) // 输出: 用户年龄: 30 岁

var bigNum int64 = 9876543210
strBigNum := fmt.Sprintf("%d", bigNum) // Sprintf 可以直接处理 int64
fmt.Printf("使用 %%d 处理 int64: %s (类型: %T)\n", strBigNum, strBigNum)

var uNum uint = 12345
strUNum := fmt.Sprintf("%d", uNum) // Sprintf 也可以直接处理 uint
fmt.Printf("使用 %%d 处理 uint: %s (类型: %T)\n", strUNum, strUNum)

}
“`

输出：
使用 %d (十进制): 456 (类型: string)
使用 %v (默认): 456 (类型: string)
使用 %b (二进制): 111001000 (类型: string)
使用 %x (十六进制): 1c8 (类型: string)
用户年龄: 30 岁
使用 %d 处理 int64: 9876543210 (类型: string)
使用 %d 处理 uint: 12345 (类型: string)

与其他方法的比较：

• 优点： fmt.Sprintf 是最灵活的方法。它可以处理几乎所有 Go 类型，并且可以将数值直接嵌入到更复杂的格式化字符串中，非常方便构建带有数值的文本消息。它可以直接处理不同大小的整型（int, int64, uint 等），无需手动类型转换（相对于 strconv.FormatInt/FormatUint）。
• 缺点： 相对于 strconv.Itoa 或 strconv.FormatInt，fmt.Sprintf 通常性能较低。因为它需要解析格式字符串，处理可变参数列表，并且内部可能涉及到反射等更复杂的机制。对于简单的 int 到十进制字符串的转换，它的开销比 strconv.Itoa 大。

适用范围：
* 需要将整型（或任何其他类型）格式化为字符串，特别是需要控制输出格式（如宽度、填充、基数等）。
* 需要将数值嵌入到更长的、格式化的文本消息中。
* 对性能要求不是极致苛刻的场景。

4. 陷阱警告：string(int) 直接类型转换

这是 Go 语言新手（甚至是有其他语言背景的开发者）经常会犯的一个错误。在 Go 中，直接将一个整数类型强制转换为 string (string(i)) 不会 将整数的数值转换为其十进制字符串表示！

这是做什么？

当我们将一个整数 i 使用 string(i) 进行类型转换时，Go 会将这个整数 i 解释为 Unicode 码点 (rune)。然后，它会创建一个包含这个 Unicode 码点对应的单个字符的字符串。

为什么它不是你想要的数值转字符串？

如果你想将数字 65 转换为字符串 “65”，使用 string(65) 的结果是 “A”，因为在 ASCII 和 Unicode 中，65 是大写字母 ‘A’ 的码点。同样，string(49) 的结果是 “1”，因为 49 是数字字符 ‘1’ 的码点。但这只适用于个别数字字符的码点恰好是该数字加 ‘0’ 的 ASCII 值的情况。对于多位数或特殊字符，这个方法是完全错误的。

正确的使用场景 (符文/ASCII 码)：

string(i) 的正确用法是当你有一个整数代表一个 Unicode 码点或 ASCII 值，并且你想获取这个码点对应的字符时。

“`go
package main

import “fmt”

func main() {
// 错误示例：试图将数值 123 转换为字符串 “123”
num := 123
// str := string(num) // 这样做是错误的，结果不是 “123”
// fmt.Printf(“错误转换结果: %s (类型: %T)\n”, str, str) // 可能输出一些奇怪的字符或空字符串

// 错误示例：试图将数值 65 转换为字符串 "65"
asciiValue := 65
// strAscii := string(asciiValue) // 结果是 "A"
// fmt.Printf("错误转换结果 (65): %s\n", strAscii) // 输出 "A"

// 正确的使用场景：将 Unicode 码点转换为字符
unicodeA := 65        // 'A' 的 Unicode 码点
unicodeSmile := 0x2323 // 某个笑脸符号的 Unicode 码点 (这里随便举例，实际码点请查表)
unicodeNewline := 10  // 换行符 '\n' 的 Unicode 码点

charA := string(unicodeA)
charSmile := string(unicodeSmile)
charNewline := string(unicodeNewline) // 结果是一个只包含换行符的字符串

fmt.Printf("码点 %d 对应的字符: %s\n", unicodeA, charA)
fmt.Printf("码点 %x 对应的字符: %s\n", unicodeSmile, charSmile)
fmt.Printf("码点 %d 对应的字符: %q (使用 %%q 显示字符串中的不可见字符)\n", unicodeNewline, charNewline)

// 另一个相关用法：从单字符符文 slice 创建字符串
runes := []rune{'H', 'e', 'l', 'l', 'o'}
s := string(runes) // 这是将符文 slice 转换为字符串的正确方法
fmt.Println("从符文 slice 创建字符串:", s) // 输出: Hello

}
“`

输出：
码点 65 对应的字符: A
码点 2323 对应的字符: ⌣ (注意：实际输出取决于你的终端是否支持该 Unicode 字符)
码点 10 对应的字符: "\n"
从符文 slice 创建字符串: Hello

切记： 除了将代表 单个字符码点 的整数转换为字符串，或者将 符文 slice 转换为字符串外，绝不要 使用 string(i) 的方式来将整数的 数值 转换为其十进制字符串表示。这几乎肯定不是你想要的结果。

5. 性能比较与选择建议

在大多数应用程序中，int 到 string 的转换不是性能瓶颈。因此，优先考虑代码的可读性和简洁性通常是更好的选择。然而，在高性能计算、处理大量数据或紧密的循环中，转换方法的性能差异可能变得重要。

理论分析：

1. strconv.Itoa / strconv.FormatInt / strconv.FormatUint: 这些函数是专门为数值和字符串之间的转换而设计的。它们使用优化的算法（通常是基于查表或高效的数学运算）来直接计算数值的十进制（或其他基数）表示，并将结果写入一个字节切片，然后转换为字符串。它们的开销相对较低，特别是 Itoa。
2. fmt.Sprintf: 这个函数是一个通用的格式化引擎。它需要解析格式字符串（如 %d），通过接口 (interface{}) 处理输入值，然后调用内部逻辑进行格式化。这些步骤带来的开销通常比专门的 strconv 函数要大。

实际基准测试 (Benchmark) 示例：

我们可以使用 Go 的内置 testing 包来编写基准测试，比较不同方法的性能。

“`go
package main

import (
“fmt”
“strconv”
“testing” // 导入 testing 包
)

// 为了运行 benchmark，这段代码通常放在一个以 _test.go 结尾的文件中
// 例如: int_to_string_test.go

// go test -bench=. -benchmem

func BenchmarkItoa(b *testing.B) {
i := 123456789
b.ReportAllocs() // 报告内存分配次数
b.ResetTimer() // 重置计时器，不计算准备时间
for n := 0; n < b.N; n++ {
strconv.Itoa(i)
}
}

func BenchmarkFormatInt(b *testing.B) {
i := 123456789
b.ReportAllocs()
b.ResetTimer()
for n := 0; n < b.N; n++ {
strconv.FormatInt(int64(i), 10)
}
}

func BenchmarkSprintf(b *testing.B) {
i := 123456789
b.ReportAllocs()
b.ResetTimer()
for n := 0; n < b.N; n++ {
fmt.Sprintf(“%d”, i)
}
}

// 你可以在同一个测试文件中添加一个 main 函数来执行普通代码，
// 但 benchmark 需要通过 go test 命令运行。
// 如果你只需要一个文件，可以把 main 函数放在这里，但运行 benchmark 时需要指定文件
func main() {
// 这是一个普通的 main 函数，不会被 go test -bench 执行
fmt.Println(“Run go test -bench=. -benchmem to see benchmark results.”)
}
“`

保存上面的代码为 int_to_string_test.go，然后在终端中运行 go test -bench=. -benchmem。输出可能类似于：

goos: linux
goarch: amd64
pkg: your_module_path/your_package_name
cpu: Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz
BenchmarkItoa-12 100000000 11.39 ns/op 8 B/allocs 1 allocs/op
BenchmarkFormatInt-12 100000000 11.57 ns/op 8 B/allocs 1 allocs/op
BenchmarkSprintf-12 17435042 67.26 ns/op 16 B/allocs 2 allocs/op
PASS
ok your_module_path/your_package_name 3.608s

结果解读与实践指导：

从基准测试结果可以看出 (具体数值会因机器和 Go 版本而异)：

• strconv.Itoa 和 strconv.FormatInt(int64(i), 10) 的性能非常接近，它们是最高效的。每次操作的纳秒数 (ns/op) 最低，内存分配 (allocs/op) 通常只有一次，分配的字节数 (B/allocs) 也最少。
• fmt.Sprintf 的性能明显低于 strconv 的方法。ns/op 更高，allocs/op 可能是 2 次或更多，分配的字节数也可能更多。这是因为 fmt.Sprintf 的通用性带来了更大的开销。

实践指导：

1. 首选 strconv.Itoa(i): 当你需要将一个普通的 int 类型变量转换为十进制字符串时，使用 strconv.Itoa。它最简洁，性能最好，是你的默认选择。
2. 使用 strconv.FormatInt(int64(i), base) / strconv.FormatUint(uint64(i), base): 当你需要转换 int64、uint64 或其他大小的整型（需要先转换为 int64/uint64），或者需要转换为非十进制基数时，使用这些方法。它们的性能也很高，是专门为这些场景设计的。
3. 使用 fmt.Sprintf("%d", i) 或其他格式化动词： 当你需要将数值嵌入到更复杂的字符串中，或者需要使用 fmt 包提供的各种格式化选项（如宽度、填充、对齐等）时，使用 fmt.Sprintf。它的代码可能更易于编写和阅读（特别是复杂格式），尽管性能略低。在大多数非性能关键的应用场景中，这点性能差异可以忽略不计。
4. 避免 string(i)： 再次强调，除非你明确知道 i 是一个 Unicode 码点并想获取该码点对应的字符，否则 绝不 使用 string(i) 来进行数值到字符串的转换。

6. 不同整型类型的处理 (int8, int16, int32, int64, uint, etc.)

Go 提供了多种大小和有无符号的整型类型。前面提到的 strconv.Itoa 只接受 int，而 strconv.FormatInt 和 strconv.FormatUint 分别接受 int64 和 uint64。

对于其他整型类型，我们需要进行类型转换才能使用 strconv 包的 Format 函数。fmt.Sprintf 则通常可以直接处理各种整型类型。

使用 strconv 处理不同整型：

“`go
package main

import (
“fmt”
“strconv”
)

func main() {
var i8 int8 = -10
var i16 int16 = 1000
var i32 int32 = -50000
var i64 int64 = 9876543210

var u8 uint8 = 250
var u16 uint16 = 60000
var u32 uint32 = 4000000000
var u64 uint64 = 18000000000000000000

// 转换为 string 使用 strconv

// int8, int16, int32 转 string -> 需要转换为 int64
strI8 := strconv.FormatInt(int64(i8), 10)
strI16 := strconv.FormatInt(int64(i16), 10)
strI32 := strconv.FormatInt(int64(i32), 10)
strI64 := strconv.FormatInt(i64, 10) // int64 直接使用 FormatInt

fmt.Printf("int8 %d -> %s\n", i8, strI8)
fmt.Printf("int16 %d -> %s\n", i16, strI16)
fmt.Printf("int32 %d -> %s\n", i32, strI32)
fmt.Printf("int64 %d -> %s\n", i64, strI64)

// uint8, uint16, uint32, uint64 转 string -> 需要转换为 uint64
strU8 := strconv.FormatUint(uint64(u8), 10)
strU16 := strconv.FormatUint(uint64(u16), 10)
strU32 := strconv.FormatUint(uint64(u32), 10)
strU64 := strconv.FormatUint(u64, 10) // uint64 直接使用 FormatUint

fmt.Printf("uint8 %d -> %s\n", u8, strU8)
fmt.Printf("uint16 %d -> %s\n", u16, strU16)
fmt.Printf("uint32 %d -> %s\n", u32, strU32)
fmt.Printf("uint64 %d -> %s\n", u64, strU64)

}
“`

输出：
int8 -10 -> -10
int16 1000 -> 1000
int32 -50000 -> -50000
int64 9876543210 -> 9876543210
uint8 250 -> 250
uint16 60000 -> 60000
uint32 4000000000 -> 4000000000
uint64 18000000000000000000 -> 18000000000000000000

使用 fmt.Sprintf 处理不同整型：

fmt.Sprintf 通常可以直接接收各种整型类型作为 %d 或 %v 的参数，它内部会处理不同类型。

“`go
package main

import “fmt”

func main() {
var i8 int8 = -10
var i16 int16 = 1000
var i32 int32 = -50000
var i64 int64 = 9876543210

var u8 uint8 = 250
var u16 uint16 = 60000
var u32 uint32 = 4000000000
var u64 uint64 = 18000000000000000000

// 转换为 string 使用 fmt.Sprintf

fmt.Printf("int8 %d -> %s\n", i8, fmt.Sprintf("%d", i8))
fmt.Printf("int16 %d -> %s\n", i16, fmt.Sprintf("%d", i16))
fmt.Printf("int32 %d -> %s\n", i32, fmt.Sprintf("%d", i32))
fmt.Printf("int64 %d -> %s\n", i64, fmt.Sprintf("%d", i64)) // 直接处理 int64

fmt.Printf("uint8 %d -> %s\n", u8, fmt.Sprintf("%d", u8))   // %d 可以处理无符号整型
fmt.Printf("uint16 %d -> %s\n", u16, fmt.Sprintf("%d", u16))
fmt.Printf("uint32 %d -> %s\n", u32, fmt.Sprintf("%d", u32))
fmt.Printf("uint64 %d -> %s\n", u64, fmt.Sprintf("%d", u64)) // 直接处理 uint64

// %v 也是一个通用选项
fmt.Printf("int32 %d -> %s (using %%v)\n", i32, fmt.Sprintf("%v", i32))
fmt.Printf("uint64 %d -> %s (using %%v)\n", u64, fmt.Sprintf("%v", u64))

}
**输出：**
int8 -10 -> -10
int16 1000 -> 1000
int32 -50000 -> -50000
int64 9876543210 -> 9876543210
uint8 250 -> 250
uint16 60000 -> 60000
uint32 4000000000 -> 4000000000
uint64 18000000000000000000 -> 18000000000000000000
int32 -50000 -> -50000 (using %v)
uint64 18000000000000000000 -> 18000000000000000000 (using %v)
``
正如所见，fmt.Sprintf在处理不同大小和有无符号的整型时更为便捷，无需强制类型转换，只要使用%d或%v` 等合适的格式化动词即可。

总结处理不同整型：
* 对于 int 到十进制字符串，strconv.Itoa 最优。
* 对于其他整型（int8 到 int64，以及 uint8 到 uint64）到指定基数（包括十进制）的字符串，推荐使用 strconv.FormatInt(int64(i), base) 或 strconv.FormatUint(uint64(i), base)。虽然需要显式转换类型，但在性能敏感的场景下仍然比 fmt.Sprintf 更优。
* 对于需要通用格式化或将数值嵌入复杂字符串的场景，以及对性能要求不极致的场景，fmt.Sprintf 是最方便的选择，它直接支持各种整型类型。

7. 总结：何时选择哪种方法

掌握了 Go 语言中 int 转 string 的多种方法后，我们可以根据具体的应用场景做出最佳选择：

1. 最常见、最简洁、性能最优： 如果你只需要将一个普通的 int 变量转换为其十进制字符串表示，请毫不犹豫地使用 strconv.Itoa(i)。这是最符合 Go 语言简洁哲学的方式，并且性能通常是最好的。
2. 需要处理 int64 或指定基数： 如果你的整型是 int64，或者你需要将整型转换为非十进制（如二进制、十六进制）字符串，使用 strconv.FormatInt(i int64, base int)。对于其他带符号整型 (int8, int16, int32)，先强制转换为 int64 再调用此函数。
3. 需要处理无符号整型或指定基数： 如果你的整型是无符号类型（uint, uint64 等），并且需要转换为指定基数，使用 strconv.FormatUint(i uint64, base int)。对于其他无符号整型，先强制转换为 uint64 再调用。
4. 需要通用格式化或嵌入字符串： 如果你需要将数值嵌入到更复杂的字符串中，或者需要利用 fmt.Sprintf 提供的丰富格式化选项（如宽度、精度、对齐等），那么 fmt.Sprintf("%d", i) 或 fmt.Sprintf("%v", i) 是最方便的选择。它能直接处理各种整型类型，但性能略逊于 strconv 方法。
5. 绝对避免的陷阱： 切记 不要 使用 string(i) 直接将整数数值转换为字符串，除非你意图是将整数视为 Unicode 码点来获取对应的字符。这是新手最容易犯的错误。

在绝大多数应用场景中，strconv.Itoa 或 fmt.Sprintf 就足够使用了。只有在处理 int64/uint64、非十进制转换或对性能有极致要求的场景下，才需要更深入地考虑 strconv.FormatInt/FormatUint。

通过理解这些方法的差异和适用场景，你可以写出更清晰、更高效的 Go 代码，自信地处理数值与文本之间的转换任务。

---