• 企业400电话
  • 微网小程序
  • AI电话机器人
  • 电商代运营
  • 全 部 栏 目

    企业400电话 网络优化推广 AI电话机器人 呼叫中心 网站建设 商标✡知产 微网小程序 电商运营 彩铃•短信 增值拓展业务
    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 // == 1s - 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)
      case int:
        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--
     next := u / 10
     buf[i] = byte('0' + u - next*10)
     u = next
     }
    case 16:
     for u >= 16 {
     i--
     buf[i] = digits[u0xF]
     u >>= 4
     }
    case 8:
     for u >= 8 {
     i--
     buf[i] = byte('0' + u7)
     u >>= 3
     }
    case 2:
     for u >= 2 {
     i--
     buf[i] = byte('0' + u1)
     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)
        _ = val
      }
    }
    
    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 ,对于性能还是有一些影响的。

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

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

    您可能感兴趣的文章:
    • golang 中获取字符串个数的方法
    • 简单谈谈Golang中的字符串与字节数组
    • Golang 统计字符串字数的方法示例
    • Golang中文字符串截取函数实现原理
    • Golang实现字符串倒序的几种解决方案
    • Golang 语言高效使用字符串的方法
    上一篇:浅谈Golang中创建一个简单的服务器的方法
    下一篇:详解golang consul-grpc 服务注册与发现
  • 相关文章
  • 

    © 2016-2020 巨人网络通讯 版权所有

    《增值电信业务经营许可证》 苏ICP备15040257号-8

    Golang 中整数转字符串的方法 Golang,中,整数,转,字符串,