Un moyen efficace de convertir un int en chaîne hexadécimale, puis le pad avec des 0 dans Golang?

Question

J'essaie de convertir 10 millions d'entiers en Hex, puis de le remplir avec 0 pour obtenir une chaîne de 4 caractères qui représente le nombre hexadécimal.

Jusqu'à présent, j'ai essayé les suivantes:

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

    // Do some stuff .... 
} 

Mais fmt.Sprintf est pas très efficace. Comment puis-je y parvenir de manière efficace?

Solution: Il s'avère que la solution @peterSO strconv.AppendInt est beaucoup plus rapide.

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

Ainsi, la référence:

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 

Answer 1

strconv.AppendUint semble être plus rapide que fmt.Sprintf. Par exemple,

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

Sortie:

$ 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 

Answer 2

Vous devriez pouvoir utiliser ConvChaîne, puis juste pad manuellement. Cela fait probablement moins de travail.

strconv.FormatInt(idx,16)