Golang 中整数转字符串的方法

2023-09-11 06:23:05 76

整形转字符串经常会用到，本文讨论一下Golang提供的这几种方法。基于go1.10.1

fmt.Sprintf

fmt包应该是最常见的了，从刚开始学习Golang就接触到了，写‘hello,world'就得用它。它还支持格式化变量转为字符串。

funcSprintf(formatstring,a...interface{})string
Sprintfformatsaccordingtoaformatspecifierandreturnstheresultingstring.
fmt.Sprintf("%d",a)

%d代表十进制整数。

strconv.Itoa

funcItoa(iint)string
ItoaisshorthandforFormatInt(int64(i),10).
strconv.Itoa(a)

strconv.FormatInt

funcFormatInt(iint64,baseint)string
FormatIntreturnsthestringrepresentationofiinthegivenbase,for2<=base<=36.Theresultusesthelower-caseletters‘a'to‘z'fordigitvalues>=10.

参数i是要被转换的整数，base是进制，例如2进制，支持2到36进制。

strconv.Format(int64(a),10)

Format的实现

[0,99)的两位整数

对于小的（小于等于100）十进制正整数有加速优化算法：

iffastSmalls&&0<=i&&i
加速的原理是提前算好100以内非负整数转换后的字符串。
constsmallsString="00010203040506070809"+
"10111213141516171819"+
"20212223242526272829"+
"30313233343536373839"+
"40414243444546474849"+
"50515253545556575859"+
"60616263646566676869"+
"70717273747576777879"+
"80818283848586878889"+
"90919293949596979899"

可以看出来，转换后的结果是从1到99都有，而且每个结果只占两位。当然个人数的情况还得特殊处理，个位数结果只有一位。
funcsmall(iint)string{
off:=0
ifi<10{
off=1
}
returnsmallsString[i*2+off:i*2+2]
}

如果被转换的数字是个位数，那么偏移量变成了1，默认情况是0。
只支持2到36进制的转换。36进制是10个数字加26个小写字母，超过这个范围无法计算。
vara[64+1]byte
整形最大64位，加一位是因为有个符号。转换计算时，要分10进制和非10进制的情况。
10进制转换


10进制里，两位两位转换，为什么这么干？两位数字时100以内非负整数转换可以用上面的特殊情况加速。很有意思。
us:=uint(u)
forus>=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进制的转换。


constdigits="0123456789abcdefghijklmnopqrstuvwxyz"

varshifts=[len(digits)+1]uint{
1<<1:1,
1<<2:2,
1<<3:3,
1<<4:4,
1<<5:5,
}

ifs:=shifts[base];s>0{
//baseispowerof2:useshiftsandmasksinsteadof/and%
b:=uint64(base)
m:=uint(base)-1//==1<=b{
i--
a[i]=digits[uint(u)&m]
u>>=s
}
//u
通过循环求余实现。进制的转换也是这种方式。
foru>=b{
i--
a[i]=uint(u)&m
u>>=s
}
上面的代码实现了进制的转换。而digits[uint(u)&m]实现了转换后的结果再转成字符。
常规情况


b:=uint64(base)
foru>=b{
i--
q:=u/b
a[i]=digits[uint(u-q*b)]
u=q
}
//u
依然是循环求余来实现。这段代码更像是给人看的。和上面2的倍数的进制转换的区别在于，上面的代码把除法/换成了右移（>>）s位，把求余%换成了逻辑与&操作。
Sprintf的实现


switchf:=arg.(type){
casebool:
p.fmtBool(f,verb)
casefloat32:
p.fmtFloat(float64(f),32,verb)
casefloat64:
p.fmtFloat(f,64,verb)
casecomplex64:
p.fmtComplex(complex128(f),64,verb)
casecomplex128:
p.fmtComplex(f,128,verb)
caseint:
p.fmtInteger(uint64(f),signed,verb)
...
}
判断类型，如果是整数int类型，不需要反射，直接计算。支持的都是基础类型，其它类型只能通过反射实现。
Sprintf支持的进制只有10%d、16x、8o、2b这四种，其它的会包fmt:unknownbase;can'thappen异常。
switchbase{
case10:
foru>=10{
i--
next:=u/10
buf[i]=byte('0'+u-next*10)
u=next
}
case16:
foru>=16{
i--
buf[i]=digits[u&0xF]
u>>=4
}
case8:
foru>=8{
i--
buf[i]=byte('0'+u&7)
u>>=3
}
case2:
foru>=2{
i--
buf[i]=byte('0'+u&1)
u>>=1
}
default:
panic("fmt:unknownbase;can'thappen")
}
2、8、16进制和之前FormatInt差不多，而10进制的性能差一些，每次只能处理一位数字，而不像FormatInt一次处理两位。
性能对比


varsmallInt=35
varbigInt=999999999999999

funcBenchmarkItoa(b*testing.B){
fori:=0;i
压测有三组对比，小于100的情况，大数字的情况，还有二进制的情况。
BenchmarkItoa-83000000004.58ns/op0B/op0allocs/op
BenchmarkItoaFormatInt-85000000003.07ns/op0B/op0allocs/op
BenchmarkItoaBase2Sprintf-82000000086.4ns/op16B/op2allocs/op
BenchmarkItoaBase2FormatInt-85000000030.2ns/op8B/op1allocs/op
BenchmarkItoaSprintf-82000000083.5ns/op16B/op2allocs/op
BenchmarkItoaBig-83000000044.6ns/op16B/op1allocs/op
BenchmarkItoaFormatIntBig-83000000043.9ns/op16B/op1allocs/op
BenchmarkItoaSprintfBig-820000000108ns/op24B/op2allocs/op


Sprintf在所有情况中都是最差的，还是别用这个包了。
小于100的情况会有加速，不光是性能上的加速，因为结果是提前算好的，也不需要申请内存。
FormatInt10进制性能最好，其它的情况差一个数量级。
Itoa虽然只是封装了FormatInt，对于性能还是有一些影响的。

本文涉及的代码可以从这里下载。


以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

Golang 中整数转字符串的方法

热门推荐

随机推荐