Golang中整数转字符串的⽅法
整形转字符串经常会⽤到，本⽂讨论⼀下 Golang 提供的这⼏种⽅法。基于 go1.10.1
fmt.Sprintf
fmt 包应该是最常见的了，从刚开始学习 Golang 就接触到了，写 ‘hello, world' 就得⽤它。它还⽀持格式化变量转为字符串。func Sprintf(format string, a ...interface{}) string
Sprintf formats according to a format specifier and returns the resulting string.
fmt.Sprintf("%d", a)
%d 代表⼗进制整数。
strconv.Itoa
func Itoa(i int) string
Itoa is shorthand for FormatInt(int64(i), 10).
strconv.Itoa(a)
strconv.FormatInt
func FormatInt(i int64, base int) string
FormatInt returns the string representation of i in the given base, for 2 <= base <= 36. The result uses the lower-case letters ‘a' to ‘z' for digit values >= 10.参数 i 是要被转换的整数， base 是进制，例如2进制，⽀持2到36进制。
strconv.Format(int64(a), 10)
Format 的实现
[0, 99)的两位整数
对于⼩的（⼩于等于100）⼗进制正整数有加速优化算法：
if fastSmalls && 0 <= i && i < nSmalls && base == 10 {
return small(int(i))
}
加速的原理是提前算好100以内⾮负整数转换后的字符串。
const smallsString = "00010203040506070809" +
"10111213141516171819" +
"20212223242526272829" +
"30313233343536373839" +
"40414243444546474849" +
"50515253545556575859" +
"60616263646566676869" +
"70717273747576777879" +
"80818283848586878889" +
"90919293949596979899"
可以看出来，转换后的结果是从1到99都有，⽽且每个结果只占两位。当然个⼈数的情况还得特殊处理，个位数结果只有⼀
位。
func small(i int) string {
off := 0
if i < 10 {
off = 1
}
return smallsString[i*2+off : i*2+2]
}
如果被转换的数字是个位数，那么偏移量变成了1，默认情况是0。
只⽀持2到36进制的转换。36进制是10个数字加26个⼩写字母，超过这个范围⽆法计算。
var a [64 + 1]byte
整形最⼤64位，加⼀位是因为有个符号。转换计算时，要分10进制和⾮10进制的情况。
10进制转换
10进制⾥，两位两位转换，为什么这么⼲？两位数字时100以内⾮负整数转换可以⽤上⾯的特殊情况加速。很有意思。
us := uint(u)
for us >= 100 {
is := us % 100 * 2
us /= 100
i -= 2
a[i+1] = smallsString[is+1]
a[i+0] = smallsString[is+0]
}
2、4、8、16、32进制的转换。
const digits = "0123456789abcdefghijklmnopqrstuvwxyz"
var shifts = [len(digits) + 1]uint{
1 << 1: 1,
1 << 2: 2,
1 << 3: 3,
1 << 4: 4,
1 << 5: 5,
}
if s := shifts[base]; s > 0 {
/
/ base is power of 2: use shifts and masks instead of / and %
b := uint64(base)
m := uint(base) - 1 // == 1<<s - 1
for u >= b {
i--
a[i] = digits[uint(u)&m]
u >>= s
}
// u < base
i--
a[i] = digits[uint(u)]
}
通过循环求余实现。进制的转换也是这种⽅式。
for u >= b {
i--
a[i] = uint(u)&m
u >>= s
}
上⾯的代码实现了进制的转换。⽽ digits[uint(u)&m] 实现了转换后的结果再转成字符。
常规情况
b := uint64(base)
for u >= b {
i--
q := u / b
a[i] = digits[uint(u-q*b)]
u = q
}
// u < base
i--
a[i] = digits[uint(u)]
依然是循环求余来实现。这段代码更像是给⼈看的。和上⾯2的倍数的进制转换的区别在于，上⾯的代码把除法 / 换成了右移（>> ） s 位，把求余 % 换成了逻辑与 & 操作。
Sprintf 的实现
switch f := arg.(type) {
case bool:
p.fmtBool(f, verb)
case float32:
p.fmtFloat(float64(f), 32, verb)
case float64:
p.fmtFloat(f, 64, verb)
case complex64:
p.fmtComplex(complex128(f), 64, verb)
case complex128:
p.fmtComplex(f, 128, verb)
p.fmtInteger(uint64(f), signed, verb)
.
..
}
判断类型，如果是整数 int 类型，不需要反射，直接计算。⽀持的都是基础类型，其它类型只能通过反射实现。
Sprintf ⽀持的进制只有10 %d 、16 x 、8 o 、2 b 这四种，其它的会包 fmt: unknown base; can't happen 异常。
switch base {
case 10:
for u >= 10 {
i--
switch case判断字符串next := u / 10
buf[i] = byte('0' + u - next*10)
u = next
}
case 16:
for u >= 16 {
i--
buf[i] = digits[u&0xF]
u >>= 4
}
case 8:
for u >= 8 {
i--
buf[i] = byte('0' + u&7)
u >>= 3
}
case 2:
for u >= 2 {
i--
buf[i] = byte('0' + u&1)
u >>= 1
}
default:
panic("fmt: unknown base; can't happen")
}
2、8、16进制和之前 FormatInt 差不多，⽽10进制的性能差⼀些，每次只能处理⼀位数字，⽽不像 FormatInt ⼀次处理两位。性能对⽐
var smallInt = 35
var bigInt = 999999999999999
func BenchmarkItoa(b *testing.B) {
for i := 0; i < b.N; i++ {
val := strconv.Itoa(smallInt)
_ = val
}
}
func BenchmarkItoaFormatInt(b *testing.B) {
for i := 0; i < b.N; i++ {
val := strconv.FormatInt(int64(smallInt), 10)
_ = val
}
}
func BenchmarkItoaSprintf(b *testing.B) {
for i := 0; i < b.N; i++ {
val := fmt.Sprintf("%d", smallInt)
_ = val
}
}
func BenchmarkItoaBase2Sprintf(b *testing.B) {
for i := 0; i < b.N; i++ {
val := fmt.Sprintf("%b", smallInt)
_ = val
}
}
func BenchmarkItoaBase2FormatInt(b *testing.B) {
for i := 0; i < b.N; i++ {
val := strconv.FormatInt(int64(smallInt), 2)
}
}
func BenchmarkItoaBig(b *testing.B) {
for i := 0; i < b.N; i++ {
val := strconv.Itoa(bigInt)
_ = val
}
}
func BenchmarkItoaFormatIntBig(b *testing.B) {
for i := 0; i < b.N; i++ {
val := strconv.FormatInt(int64(bigInt), 10)
_ = val
}
}
func BenchmarkItoaSprintfBig(b *testing.B) {
for i := 0; i < b.N; i++ {
val := fmt.Sprintf("%d", bigInt)
_ = val
}
}
压测有三组对⽐，⼩于100的情况，⼤数字的情况，还有⼆进制的情况。
BenchmarkItoa-8 300000000 4.58 ns/op 0 B/op 0 allocs/op
BenchmarkItoaFormatInt-8 500000000 3.07 ns/op 0 B/op 0 allocs/op
BenchmarkItoaBase2Sprintf-8 20000000 86.4 ns/op 16 B/op 2 allocs/op
BenchmarkItoaBase2FormatInt-8 50000000 30.2 ns/op 8 B/op 1 allocs/op
BenchmarkItoaSprintf-8 20000000 83.5 ns/op 16 B/op 2 allocs/op
BenchmarkItoaBig-8 30000000 44.6 ns/op 16 B/op 1 allocs/op
BenchmarkItoaFormatIntBig-8 30000000 43.9 ns/op 16 B/op 1 allocs/op
BenchmarkItoaSprintfBig-8 20000000 108 ns/op 24 B/op 2 allocs/op
1. Sprintf 在所有情况中都是最差的，还是别⽤这个包了。
2. ⼩于100的情况会有加速，不光是性能上的加速，因为结果是提前算好的，也不需要申请内存。
3. FormatInt 10进制性能最好，其它的情况差⼀个数量级。
4. Itoa 虽然只是封装了 FormatInt ，对于性能还是有⼀些影响的。
本⽂涉及的代码可以从下载。
以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论