Golang strconv.ParseInt
最后修改于 2025 年 4 月 20 日
本教程解释了如何在 Go 中使用 strconv.ParseInt 函数。我们将涵盖具有不同基数和位大小的字符串到整数的转换。
strconv.ParseInt 函数将字符串转换为具有指定基数（0 到 36）和位大小（0 到 64）的整数。它比 Atoi 更灵活。
ParseInt 在给定基数下解析字符串，并返回相应的整数值。它返回两个值：解析后的整数和转换失败时的错误。
基本的 strconv.ParseInt 示例
strconv.ParseInt 最简单的用法是将基数为 10 的字符串转换为 64 位整数。这里我们演示了成功的转换和错误处理。
package main
import (
"fmt"
"strconv"
)
func main() {
numStr := "42"
num, err := strconv.ParseInt(numStr, 10, 64)
if err != nil {
fmt.Println("Conversion error:", err)
return
}
fmt.Printf("String '%s' converted to integer %d\n", numStr, num)
}
我们使用基数 10 将字符串 "42" 转换为 64 位整数。检查错误以处理转换失败的情况。成功的转换将打印整数值。
处理不同的基数
strconv.ParseInt 可以解析各种基数的数字。此示例显示了十六进制、二进制和八进制数字的转换。
package main
import (
"fmt"
"strconv"
)
func main() {
// Hexadecimal (base 16)
hexNum, _ := strconv.ParseInt("2a", 16, 64)
fmt.Println("Hexadecimal 2a:", hexNum)
// Binary (base 2)
binNum, _ := strconv.ParseInt("1010", 2, 64)
fmt.Println("Binary 1010:", binNum)
// Octal (base 8)
octNum, _ := strconv.ParseInt("12", 8, 64)
fmt.Println("Octal 12:", octNum)
}
我们演示了在基数 16（十六进制）、基数 2（二进制）和基数 8（八进制）下解析数字。当给出正确的基数时，该函数可以正确处理所有这些情况。
自动基数检测
当指定基数 0 时，ParseInt 会从字符串前缀中检测基数。此示例显示了它如何处理不同的数字格式。
package main
import (
"fmt"
"strconv"
)
func main() {
// Detects base from prefix
decNum, _ := strconv.ParseInt("42", 0, 64)
hexNum, _ := strconv.ParseInt("0x2a", 0, 64)
octNum, _ := strconv.ParseInt("052", 0, 64)
fmt.Println("Decimal 42:", decNum)
fmt.Println("Hexadecimal 0x2a:", hexNum)
fmt.Println("Octal 052:", octNum)
}
使用基数 0，该函数将 0x 前缀识别为十六进制，将 0 前缀识别为八进制。没有前缀则表示基数 10。这提供了灵活的输入处理。
处理不同的位大小
bitSize 参数决定了将保存结果的整数类型。此示例显示了转换为不同位大小的情况。
package main
import (
"fmt"
"strconv"
)
func main() {
// 8-bit integer
num8, _ := strconv.ParseInt("127", 10, 8)
fmt.Printf("8-bit: %d (type: %T)\n", num8, num8)
// 16-bit integer
num16, _ := strconv.ParseInt("32767", 10, 16)
fmt.Printf("16-bit: %d (type: %T)\n", num16, num16)
// 32-bit integer
num32, _ := strconv.ParseInt("2147483647", 10, 32)
fmt.Printf("32-bit: %d (type: %T)\n", num32, num32)
// 64-bit integer
num64, _ := strconv.ParseInt("9223372036854775807", 10, 64)
fmt.Printf("64-bit: %d (type: %T)\n", num64, num64)
}
bitSize 参数会影响返回类型。超出指定大小的值将返回错误。尽管 bitSize 不同，但实际类型始终是 int64。
错误处理场景
ParseInt 可能因多种原因而失败。此示例演示了不同的错误情况以及如何正确处理它们。
package main
import (
"fmt"
"strconv"
)
func main() {
testCases := []struct {
input string
base int
bits int
}{
{"123", 10, 64},
{"12.3", 10, 64},
{"abc", 10, 64},
{"123abc", 10, 64},
{"", 10, 64},
{"7fffffffffffffff", 16, 32},
}
for _, tc := range testCases {
_, err := strconv.ParseInt(tc.input, tc.base, tc.bits)
if err != nil {
fmt.Printf("Error parsing '%s' (base %d, bits %d): %v\n",
tc.input, tc.base, tc.bits, err)
}
}
}
我们测试了各种错误场景，包括无效字符、空字符串和溢出条件。每个错误都会提供有关失败的具体信息。
比较 ParseInt 和 Atoi
strconv.Atoi 实际上是 ParseInt 的包装器。此示例显示了它们之间的关系以及何时使用它们。
package main
import (
"fmt"
"strconv"
)
func main() {
numStr := "42"
// Using Atoi
num1, err1 := strconv.Atoi(numStr)
if err1 != nil {
fmt.Println("Atoi error:", err1)
} else {
fmt.Println("Atoi result:", num1)
}
// Equivalent ParseInt call
num2, err2 := strconv.ParseInt(numStr, 10, 0)
if err2 != nil {
fmt.Println("ParseInt error:", err2)
} else {
fmt.Println("ParseInt result:", num2)
}
}
对于基数 10 的转换，Atoi 更简单，而 ParseInt 提供了更多的控制。对于有效的基数 10 输入，它们产生相同的结果。
实际示例：十六进制颜色解析器
这个实际示例演示了如何使用 ParseInt 从十六进制字符串解析 RGB 颜色值。
package main
import (
"fmt"
"strconv"
)
func parseHexColor(color string) (r, g, b int, err error) {
if len(color) != 7 || color[0] != '#' {
return 0, 0, 0, fmt.Errorf("invalid color format")
}
// Parse red component
r64, err := strconv.ParseInt(color[1:3], 16, 64)
if err != nil {
return 0, 0, 0, err
}
// Parse green component
g64, err := strconv.ParseInt(color[3:5], 16, 64)
if err != nil {
return 0, 0, 0, err
}
// Parse blue component
b64, err := strconv.ParseInt(color[5:7], 16, 64)
if err != nil {
return 0, 0, 0, err
}
return int(r64), int(g64), int(b64), nil
}
func main() {
color := "#ff00cc"
r, g, b, err := parseHexColor(color)
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Printf("Color %s: R=%d, G=%d, B=%d\n", color, r, g, b)
}
我们将十六进制颜色字符串解析为其 RGB 分量。每个颜色通道被提取为子字符串，并使用基数 16 进行解析。
来源
本教程通过各种场景下的字符串到整数转换的实际示例，介绍了 Go 中的 strconv.ParseInt 函数。