Golang: verify that string is a valid hex string? - string

Question

I have a struct:
type Name struct {
hexID string
age uint8
}
What is the easiest way to check that hexID field is a valid hex string? And if not - rise an error.
For example:
var n Name
n.hexID = "Hello World >)" // not a valid hex
n.hexID = "aaa12Eb9990101010101112cC" // valid hex
Or maybe there are somewhere struct tag exists?

Answer 1

Iterate over the characters of the string, and check if each is a valid hex digit.
func isValidHex(s string) bool {
for _, r := range s {
if !(r >= '0' && r <= '9' || r >= 'a' && r <= 'f' || r >= 'A' && r <= 'F') {
return false
}
}
return true
}
Testing it:
fmt.Println(isValidHex("Hello World >)"))
fmt.Println(isValidHex("aaa12Eb9990101010101112cC"))
Output (try it on the Go Playground):
false
true
Note: you'd be tempted to use hex.DecodeString() and check the returned error: if it's nil, it's valid. But do note that this function expects that the string has even length (as it produces bytes from the hex digits, and 2 hex digits forms a byte). Not to mention that if you don't need the result (as a byte slice), this is slower and creates unnecessary garbage (for the gc to collect).
Another solution could be using big.Int.SetString():
func isValidHex(s string) bool {
_, ok := new(big.Int).SetString(s, 16)
return ok
}
This outputs the same, try it on the Go Playground. But this again is slower and uses memory allocations (generates garbage).

Answer 2

What about this one
regexp.MatchString("[^0-9A-Fa-f]", n.hexID)
True if string contains HEX illegal characters

Answer 3

Comment: I'm completely confused now which one to use :( – armaka
Different inplementations have different performance. For example,
func isHexRock(s string) bool {
for _, b := range []byte(s) {
if !(b >= '0' && b <= '9' || b >= 'a' && b <= 'f' || b >= 'A' && b <= 'F') {
return false
}
}
return true
}
func isHexIcza(s string) bool {
for _, r := range s {
if !(r >= '0' && r <= '9' || r >= 'a' && r <= 'f' || r >= 'A' && r <= 'F') {
return false
}
}
return true
}
var rxNotHex = regexp.MustCompile("[^0-9A-Fa-f]")
func isHexOjacoGlobal(s string) bool {
return !rxNotHex.MatchString(s)
}
func isHexOjacoLocal(s string) bool {
notHex, err := regexp.MatchString("[^0-9A-Fa-f]", s)
if err != nil {
panic(err)
}
return !notHex
}
Some benchmark results:
BenchmarkRock-4 36386997 30.92 ns/op 0 B/op 0 allocs/op
BenchmarkIcza-4 21100798 52.86 ns/op 0 B/op 0 allocs/op
BenchmarkOjacoGlobal-4 5958829 209.9 ns/op 0 B/op 0 allocs/op
BenchmarkOjacoLocal-4 227672 4648 ns/op 1626 B/op 22 allocs/op

Answer 4

I think ParseInt method can also tackle this -
_, err := strconv.ParseInt("deadbeef", 16, 64)
if err != nil {
fmt.Println("not a hex string")
} else {
fmt.Println("it is a hex string")
}