douchenchepan6465
2016-09-12 01:09
浏览 892
已采纳

在Golang中将int32转换为字符串

I need to convert an int32 to string in Golang. Is it possible to convert int32 to string in Golang without converting to int or int64 first?

Itoa needs an int. FormatInt needs an int64.

图片转代码服务由CSDN问答提供 功能建议

我需要在Golang中将 int32 转换为 string 。 可以在Golang中将 int32 转换为 string 而不先转换为 int int64 吗?

Itoa 需要一个 int FormatInt 需要一个 int64

  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

3条回答 默认 最新

  • ds2128629 2016-09-12 05:46
    已采纳

    One line answer is fmt.Sprint(i).

    Anyway there are many conversions, even inside standard library function like fmt.Sprint(i), so you have some options (try The Go Playground):


    1- You may write your conversion function (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- You may use fmt.Sprint(i) (Slow)
    See inside:

    // 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- You may use strconv.Itoa(int(i)) (Fast)
    See inside:

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

    4- You may use strconv.FormatInt(int64(i), 10) (Faster)
    See inside:

    // 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
    }
    

    Comparison & Benchmark (with 50000000 iterations):

    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
    

    Code:

    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:])
            }
        }
    }
    
    已采纳该答案
    打赏 评论
  • dongqin8652 2016-09-12 01:38

    The Sprint function converts a given value to string.

    package main
    
    import (
         "fmt"
    )
    
    func main() {
    
          var sampleInt int32 = 1
    
          sampleString := fmt.Sprint(sampleInt)
          fmt.Printf("%+V %+V
    ", sampleInt, sampleString)
    }
    
    // %!V(int32=+1) %!V(string=1)
    

    See this example.

    打赏 评论
  • dongyi1921 2016-09-12 04:07

    Use a conversion and strconv.FormatInt to format int32 values as a string. The conversion has zero cost on most platforms.

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

    If you have many calls like this, consider writing a helper function similar to strconv.Itoa:

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

    All of the low-level integer formatting code in the standard library works with int64 values. Any answer to this question using formatting code in the standard library (fmt package included) requires a conversion to int64 somewhere. The only way to avoid the conversion is to write formatting function from scratch, but there's little point in doing that.

    打赏 评论

相关推荐 更多相似问题