Golang int 转 string、string 转 int 与类型转换

Go 从不进行隐式类型转换。兼容的类型之间用 T(v) 转换，数字和文本之间用 strconv 包转换。下面是被搜索最多的两种转换：

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// int to string
	n := 42
	s := strconv.Itoa(n)
	fmt.Println(s, len(s))

	// string to int
	parsed, err := strconv.Atoi("1234")
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(parsed + 1)
}

strconv.Itoa（“integer to ASCII”）把 int 格式化成十进制文本。strconv.Atoi（“ASCII to integer”）把文本解析成 int，文本不是有效数字时返回错误。一定要检查这个错误。

T(v) 转换

Go 的转换语法看起来像一次以目标类型命名的函数调用。它适用于三种情况：

1. 数值类型之间（int、int64、float64、uint8 等），
2. string 与 []byte 或 []rune 之间，
3. 底层类型相同的类型之间（Celsius 和 float64）。

package main

import (
	"fmt"
	"math"
)

type Celsius float64

func main() {
	count := 7
	total := 2.5

	// numeric conversions
	avg := total / float64(count)
	fmt.Printf("%.3f\n", avg)

	// float to int truncates toward zero
	up, down := 3.9, -3.9
	fmt.Println(int(up), int(down))
	fmt.Println(int(math.Round(up)), int(math.Round(-3.5)))

	// narrowing an integer keeps the low bits
	big, mid := 300, 200
	fmt.Println(uint8(big), int8(mid))

	// named type to underlying type and back
	t := Celsius(21.5)
	f := float64(t)
	fmt.Println(t, f)
}

仔细看看结果：

• int(3.9) 是 3，int(-3.9) 是 -3。转换会向零截断，而不是四舍五入。要选择其他行为，先用 math.Round、math.Floor 或 math.Ceil。math.Round 遇到 .5 时朝远离零的方向取整，所以 -3.5 变成 -4。
• uint8(300) 是 44，因为只保留了低 8 位（300 减 256），int8(200) 是 -56 也是同样的原因。没有错误，也不会 panic。
• Celsius 和 float64 的底层类型相同，所以可以自由转换，但必须显式转换。

这些值特意放在变量里。如果用常量，同样的转换无法编译。

常量会被检查，变量不会

转换一个放不下的常量会导致编译错误。转换值相同的变量则会悄悄回绕：

fmt.Println(uint8(300)) // compile error
x := 300
fmt.Println(uint8(x)) // 44

./main.go:6:20: constant 300 overflows uint8

把非整数常量转换成整数类型同样会被拒绝，而变量中的相同值则会被截断：

./main.go:7:18: cannot convert -3.9 (untyped float constant) to type int

如果浮点数超出了目标整数类型的范围（比如 int64(1e20)），结果取决于具体实现：例如 amd64 和 arm64 会给出不同的答案。转换不可信的值之前，先检查范围。

数字转字符串

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var id int64 = 9007199254740993
	fmt.Println(strconv.FormatInt(id, 10))
	fmt.Println(strconv.FormatInt(255, 2), strconv.FormatInt(255, 16))

	f := 1234.5678
	fmt.Println(strconv.FormatFloat(f, 'f', 2, 64))  // fixed, 2 decimals
	fmt.Println(strconv.FormatFloat(f, 'e', 3, 64))  // scientific
	fmt.Println(strconv.FormatFloat(f, 'f', -1, 64)) // shortest exact form
	fmt.Println(strconv.FormatFloat(0.1, 'f', -1, 64))

	fmt.Println(fmt.Sprintf("%.1f%%", 45.67))
	fmt.Println("item-" + strconv.Itoa(7))
}

FormatFloat 接收一个格式字节（'f' 表示定点，'e' 表示指数形式，'g' 表示取两者中较短的）、一个精度（-1 表示“能精确往返转换的最少位数”），以及原浮点数的位数（64 或 32）。

strconv 比 fmt.Sprint 更快，后者会把值装进接口，再走 fmt 通用的格式化流程。在热点循环中这个差距会显现出来；偶尔转换一下的话，选读起来更顺的那个就行。

字符串转数字

ParseInt 总是返回 int64。bitSize 参数（0、8、16、32、64）设定它接受的范围，所以把结果转换成更小的类型时保证放得下。base 为 0 表示“根据前缀推断”，所以 0x1f、0o17、0b101 和 1_000 都能解析。

package main

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
)

func main() {
	inputs := []string{"42", " 42", "4.2", "abc", "99999999999999999999"}
	for _, in := range inputs {
		n, err := strconv.Atoi(in)
		fmt.Printf("%-24q -> %d, %v\n", in, n, err)
	}

	// trim first when the input may have spaces or a newline
	n, err := strconv.Atoi(strings.TrimSpace(" 42\n"))
	fmt.Println(n, err)

	// ParseInt with a size limit
	v, err := strconv.ParseInt("300", 10, 8)
	fmt.Println(v, err)

	// base 0 reads the prefix
	h, _ := strconv.ParseInt("0xff", 0, 64)
	fmt.Println(h)

	// inspect the error kind
	_, err = strconv.Atoi("12a")
	if errors.Is(err, strconv.ErrSyntax) {
		fmt.Println("not a number")
	}
	_, err = strconv.ParseInt("300", 10, 8)
	if errors.Is(err, strconv.ErrRange) {
		fmt.Println("too big for int8")
	}

	price, err := strconv.ParseFloat("19.99", 64)
	fmt.Println(price*2, err)

	ok, err := strconv.ParseBool("true")
	fmt.Println(ok, err)
}

输出说明了这些事情：

• " 42" 会失败。Atoi 只接受一个可选的正负号和数字，其他都不接受。来自 bufio 的输入通常以 \n 结尾，所以要先去掉。
• "4.2" 对 Atoi 来说是无效的。小数请用 ParseFloat。
• 发生超出范围的错误时，ParseInt 会返回能放得下的最大值（int8 为 127），同时返回错误。错误不为 nil 时不要使用这个值。
• 这些错误是包装了 strconv.ErrSyntax 或 strconv.ErrRange 的 *strconv.NumError 值，所以可以用 errors.Is 区分它们。

ParseBool 接受 1、t、T、TRUE、true、True 以及对应的表示 false 的形式。"yes" 和 "on" 都会报错。

string(65) 陷阱

把整数转换成 string 得到的不是数字字符，而是以该数为 Unicode 码点的那个字符：

n := 65
s := string(n) // "A", not "65"

编译器会接受它，但 go vet 会报告：

./main.go:10:7: conversion from int to string yields a string of one rune, not a string of digits

如果你确实想要那个字符，就用 rune 明确表达：string(rune(n))。如果你想要的是数字文本，用 strconv.Itoa(n)。把 rune 或 byte 转换成 string 没有问题，也很常见：

package main

import (
	"fmt"
	"strconv"
)

func main() {
	n := 65
	fmt.Println(strconv.Itoa(n)) // "65"
	fmt.Println(string(rune(n))) // "A"

	letter := 'é'
	fmt.Println(string(letter))

	word := "go"
	fmt.Println(string(word[0])) // a byte converted to a one-character string
}

字符串、字节与 rune

string、[]byte 和 []rune 可以用 T(v) 互相转换。每次转换都会复制数据，因为字符串是不可变的，而切片不是：

package main

import "fmt"

func main() {
	s := "héllo"

	b := []byte(s) // UTF-8 bytes
	r := []rune(s) // Unicode code points

	fmt.Println(len(b), b)
	fmt.Println(len(r), r)

	r[1] = 'e'
	fmt.Println(string(r))

	b[0] = 'H'
	fmt.Println(string(b), s) // s is unchanged
}

需要按字符索引或修改时，转换成 []rune；做 I/O、哈希和字节级修改时，转换成 []byte。rune 和字节一节会详细讲解 UTF-8。

转换与类型断言

转换是把一个值从一种具体类型变成另一种具体类型。从接口（any、error、io.Reader）中取出具体的值是另一种操作，即类型断言：

var v any = 42

n := v.(int)       // type assertion: v holds an int, give it to me
f := float64(n)    // conversion: int to float64
// f := float64(v) // compile error: cannot convert v (variable of interface type any)
//                  // to type float64: need type assertion

先断言，再转换。comma-ok 形式 n, ok := v.(int) 可以避免类型不对时 panic。

速查表

n, err := strconv.Atoi("42")
if err != nil {
	// not a valid integer
}