在 Golang 中将 int32 转换为字符串答案

【问题标题】：Convert int32 to string in Golang在 Golang 中将 int32 转换为字符串
【发布时间】：2017-01-19 09:51:00
【问题描述】：

我需要在 Golang 中将 int32 转换为 string。是否可以在Golang中将int32转换为string而不先转换为int或int64？

Itoa 需要int。 FormatInt 需要 int64。

【问题讨论】：

首先将int32 转换为int 有什么不好？为什么要避免它？
为什么会出现这个问题？无论如何，您将值传递给的任何格式化函数都必须在内部进行转换。
fmt.Sprint(i) 或 strconv.Itoa(int(i)) 将 int32 设置为字符串。见stackoverflow.com/a/62737936/12817546。 strconv.Atoi(s) 和 int32(i) 将字符串设置为 int32。见stackoverflow.com/a/62740786/12817546。

标签： go

【解决方案1】：

一行答案是fmt.Sprint(i)。

反正有很多转换，即使在像fmt.Sprint(i)这样的标准库函数中，所以你有一些选择（试试The Go Playground）：

1- 您可以编写转换函数（Fastest）：

func String(n int32) string {
    buf := [11]byte{}
    pos := len(buf)
    i := int64(n)
    signed := i < 0
    if signed {
        i = -i
    }
    for {
        pos--
        buf[pos], i = '0'+byte(i%10), i/10
        if i == 0 {
            if signed {
                pos--
                buf[pos] = '-'
            }
            return string(buf[pos:])
        }
    }
}

2- 你可以使用fmt.Sprint(i)（慢）
看里面：

// Sprint formats using the default formats for its operands and returns the resulting string.
// Spaces are added between operands when neither is a string.
func Sprint(a ...interface{}) string {
    p := newPrinter()
    p.doPrint(a)
    s := string(p.buf)
    p.free()
    return s
}

3- 您可以使用strconv.Itoa(int(i))（快速）
看里面：

// Itoa is shorthand for FormatInt(int64(i), 10).
func Itoa(i int) string {
    return FormatInt(int64(i), 10)
}

4- 您可以使用strconv.FormatInt(int64(i), 10)（更快）
看里面：

// 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.
func FormatInt(i int64, base int) string {
    _, s := formatBits(nil, uint64(i), base, i < 0, false)
    return s
}

比较和基准测试（50000000 次迭代）：

s = String(i)                       takes:  5.5923198s
s = String2(i)                      takes:  5.5923199s
s = strconv.FormatInt(int64(i), 10) takes:  5.9133382s
s = strconv.Itoa(int(i))            takes:  5.9763418s
s = fmt.Sprint(i)                   takes: 13.5697761s

代码：

package main

import (
    "fmt"
    //"strconv"
    "time"
)

func main() {
    var s string
    i := int32(-2147483648)
    t := time.Now()
    for j := 0; j < 50000000; j++ {
        s = String(i) //5.5923198s
        //s = String2(i) //5.5923199s
        //s = strconv.FormatInt(int64(i), 10) // 5.9133382s
        //s = strconv.Itoa(int(i)) //5.9763418s
        //s = fmt.Sprint(i) // 13.5697761s
    }
    fmt.Println(time.Since(t))
    fmt.Println(s)
}

func String(n int32) string {
    buf := [11]byte{}
    pos := len(buf)
    i := int64(n)
    signed := i < 0
    if signed {
        i = -i
    }
    for {
        pos--
        buf[pos], i = '0'+byte(i%10), i/10
        if i == 0 {
            if signed {
                pos--
                buf[pos] = '-'
            }
            return string(buf[pos:])
        }
    }
}

func String2(n int32) string {
    buf := [11]byte{}
    pos := len(buf)
    i, q := int64(n), int64(0)
    signed := i < 0
    if signed {
        i = -i
    }
    for {
        pos--
        q = i / 10
        buf[pos], i = '0'+byte(i-10*q), q
        if i == 0 {
            if signed {
                pos--
                buf[pos] = '-'
            }
            return string(buf[pos:])
        }
    }
}

【讨论】：

问题是如何做到不将n转换为另一种整数类型。
@RolandIllig ：查看此新编辑。

【解决方案2】：

Sprint 函数将给定值转换为字符串。

package main

import (
     "fmt"
)

func main() {

      var sampleInt int32 = 1

      sampleString := fmt.Sprint(sampleInt)
      fmt.Printf("%+V %+V\n", sampleInt, sampleString)
}

// %!V(int32=+1) %!V(string=1)

看到这个example。

【讨论】：

【解决方案3】：

使用 conversion 和 strconv.FormatInt 将 int32 值格式化为字符串。在大多数平台上，转换成本为零。

s := strconv.FormatInt(int64(n), 10)

如果你有很多这样的调用，考虑编写一个类似于strconv.Itoa的辅助函数：

func formatInt32(n int32) string {
    return strconv.FormatInt(int64(n), 10)
}

标准库中的所有低级整数格式化代码都适用于int64 值。使用标准库（包括 fmt 包）中的格式化代码对此问题的任何答案都需要在某处使用 conversion 到 int64。避免转换的唯一方法是从头开始编写格式化函数，但这样做没有什么意义。

【讨论】：