將int轉換爲十六進制字符串，然後在Golang中使用0填充的有效方法？

我想將10百萬的int轉換爲十六進制，然後用0填充它以獲得一個代表十六進制數字的4個字符的字符串。將int轉換爲十六進制字符串，然後在Golang中使用0填充的有效方法？

到目前爲止，我試過如下：

var hexNumber string 
for idx := O; idx < 10000000; idx++ { 
    hexNumber = fmt.Sprintf("%04x", idx) 

    // Do some stuff .... 
}

但fmt.Sprintf是不是很有效。我怎樣才能以有效的方式實現這一目標？

解決方案：事實證明@peterSO strconv.AppendInt解決方案更快。

package bench 

import (
    "fmt" 
    "strconv" 
    "strings" 
    "testing" 
) 

var stringHex [16]string 
var runesHex [16]rune 

func init() { 
    stringHex = [16]string{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"} 
    runesHex = [16]rune{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'} 
} 

func intToHex1(intNumber int) string { 
    hexNumber := []rune("0000") 
    for i, j := int(0), uint(12); i < 4; i, j = i+1, j-4 { 
     hexNumber[i] = runesHex[(intNumber>>j)&0x0f] 
    } 
    return string(hexNumber) 
} 

func intToHex2(intNumber int) string { 
    hexNumber := "0000" 
    for i, j := int(0), uint(12); i < 4; i, j = i+1, j-4 { 
     hexNumber = hexNumber[:i] + stringHex[(intNumber>>j)&0x0f] + hexNumber[i+1:] 
    } 
    return hexNumber 
} 

func BenchmarkFmtSprintf(b *testing.B) { 
    b.ReportAllocs() 
    for n := 0; n < b.N; n++ { 
     hexNumber := fmt.Sprintf("%04x", n) 
     _ = hexNumber 
    } 
} 

func BenchmarkStrconvFormatInt(b *testing.B) { 
    b.ReportAllocs() 
    for n := 0; n < b.N; n++ { 
     retStr := strings.Repeat("0", 4) + strconv.FormatInt(int64(n), 16) 
     hexNumber := retStr[(len(retStr) - 4):] 
     _ = hexNumber 
    } 
} 

func BenchmarkAppend(b *testing.B) { 
    b.ReportAllocs() 
    buf := []byte{'0', '0', '0', '0', 4 + 16: 0} 
    for n := 0; n < b.N; n++ { 
     buf = strconv.AppendInt(buf[:4], int64(n), 16) 
     hexNumber := string(buf[len(buf)-4:]) 
     _ = hexNumber 
    } 
} 

func BenchmarkIntToHex1(b *testing.B) { 
    b.ReportAllocs() 
    for n := 0; n < b.N; n++ { 
     hexNumber := intToHex1(n) 
     _ = hexNumber 
    } 
} 

func BenchmarkIntToHex2(b *testing.B) { 
    b.ReportAllocs() 
    for n := 0; n < b.N; n++ { 
     hexNumber := intToHex2(n) 
     _ = hexNumber 
    } 
}

所以基準：

BenchmarkFmtSprintf-2   3000000    364 ns/op    16 B/op   2 allocs/op 
BenchmarkStrconvFormatInt-2  5000000    354 ns/op    15 B/op   3 allocs/op 
BenchmarkAppend-2    20000000    75.6 ns/op    0 B/op   0 allocs/op 
BenchmarkIntToHex1-2   10000000    162 ns/op    8 B/op   1 allocs/op 
BenchmarkIntToHex2-2    3000000    536 ns/op    16 B/op   4 allocs/op

來源

2017-10-21 LeMoussel

你應該夾緊N'的'值或's'到'[0x0000時，爲0xFFFF]''爲S：= fmt.Sprintf（「％04x」，n）'。否則，當'b.N> 0xFFFF'（65,535）時，你會得到太多的十六進制數字。例如，'n：= 0x7FFFF; s：= fmt.Sprintf（「％04x」，n）'，'s'是'7ffff'，五個十六進制數字：https：//play.golang.org/p/hX4R1aocIJ。看到我修改後的答案，更快的Append版本。 – peterSO

strconv.AppendUint看起來比fmt.Sprintf快。例如，

hex_test.go：

package main 

import (
    "fmt" 
    "strconv" 
    "testing" 
) 

func BenchmarkFmtSprintf(b *testing.B) { 
    b.ReportAllocs() 
    for n := 0; n < b.N; n++ { 
     hexNumber := fmt.Sprintf("%04x", n&0xFFFF) 
     _ = hexNumber 
    } 
} 

func BenchmarkAppend(b *testing.B) { 
    b.ReportAllocs() 
    for n := 0; n < b.N; n++ { 
     buf := []byte{'0', '0', '0', 3 + 4: 0} 
     buf = strconv.AppendUint(buf[:3], uint64(n)&0xFFFF, 16) 
     hexNumber := string(buf[len(buf)-4:]) 
     _ = hexNumber // Do some stuff .... 
    } 
}

輸出：

$ go test -bench=. hex_test.go 
BenchmarkSprintf-4  10000000  116 ns/op  16 B/op  1 allocs/op 
BenchmarkAppend-4  100000000  19.2 ns/op  0 B/op  0 allocs/op

來源

2017-10-21 09:09:50 peterSO

更新到更快的版本。 – peterSO

您應該能夠使用STRCONV，那麼就手動墊。這可能會減少工作量。

strconv.FormatInt(idx,16)

來源

2017-10-21 07:56:47

將int轉換爲十六進制字符串，然後在Golang中使用0填充的有效方法？

回答

相關問題