Golang: verify that string is a valid hex string?

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?

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

> 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

What about this one

regexp.MatchString("[^0-9A-Fa-f]", n.hexID)

True if string contains HEX illegal characters

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