我正在尝试将 10 百万 int 转换为十六进制,然后用 0 填充它以获得代表十六进制数的 4 个字符的字符串。
到目前为止,我尝试了以下方法:
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
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
我不确定这是最好的方法,但我有一个要点和游乐场来说明您试图解决的问题以及我最终采取的方法。
// hex formater with %x can lose a leading 0
// This can produce strings with an odd number of hex digits
package main
import (
"encoding/binary"
"encoding/hex"
"fmt"
)
func main() {
var foo uint16 = 0x0ABC // decimal 2748
with_pct := fmt.Sprintf("%x", foo)
fmt.Printf("With string formatter: %qn", with_pct)
// Outputs: With string formatter: "abc"
// I hope there is a cleaner way to get an integer into a []byte
foo_bytes := make([]byte, 2)
binary.BigEndian.PutUint16(foo_bytes, foo)
with_bytes := hex.EncodeToString(foo_bytes)
fmt.Printf("With hex encoding: %qn", with_bytes)
// Outputs: With hex encoding: "0abc"
}
我对这种方法不是特别满意。我必须根据 int 的大小手动设置字节数组的长度,因为 Go 的 len()
函数不像 C 的 size_of
运算符。
当试图获得非负大的十六进制表示时,这确实效果更好。Int,因为.Bytes()
给了我们大端字节数组。
你应该能够使用 strconv,然后手动填充。这可能做更少的工作。
strconv.FormatInt(idx,16)