How to write isNumeric function in Golang?

I want to check if a string is numeric.

For example:

• "abcd123" should return false.
• "1.4" or "240" should return true.

I thought about using ParseInt and ParseFloat (from the strconv package), but am not sure if that is the right way.

> I was thinking of using strconv ParseInt and ParseFloat but not sure
> if that is the right way.

Well, it's certainly a right way.

You don't need to use ParseInt, though. ParseFloat will do the job.

func isNumeric(s string) bool {
    _, err := strconv.ParseFloat(s, 64)
    return err == nil
}

See an example here: https://play.golang.org/p/D53HRS-KIL

If you need to convert the string to a floating-point number strconv.ParseFloat is the first choice.
Here you just need to know that there is only "0123456789" and maximum one '.' in your string, here for me isNumDot is 12x faster than isNumeric, see:
Consider this (1.7 seconds) - optimized for performance:

func isNumDot(s string) bool {
	dotFound := false
	for _, v := range s {
		if v == '.' {
			if dotFound {
				return false
			}
			dotFound = true
		} else if v < '0' || v > '9' {
			return false
		}
	}
	return true
}

and this (21.7 seconds - doing more extra works "converts the string to a floating-point number"):

func isNumeric(s string) bool {
    _, err := strconv.ParseFloat(s, 64)
    return err == nil
}

Try it:

package main

import (
	"fmt"
	"strconv"
	"time"
)

func isNumDot(s string) bool {
	dotFound := false
	for _, v := range s {
		if v == '.' {
			if dotFound {
				return false
			}
			dotFound = true
		} else if v < '0' || v > '9' {
			return false
		}
	}
	return true
}

func isNumeric(s string) bool {
	_, err := strconv.ParseFloat(s, 64)
	return err == nil
}

func main() {
	fmt.Println(isNumDot("240"))     //true
	fmt.Println(isNumDot("abcd123")) //false
	fmt.Println(isNumDot("0.4."))    //false
	fmt.Println(isNumDot("240 "))    //false
	benchmark(isNumDot)
	benchmark(isNumeric)
}

func benchmark(f func(string) bool) {
	var res bool
	t := time.Now()
	for i := 0; i < 100000000; i++ {
		res = f("a 240") || f("abcd123") || f("0.4.") || f("240 ")
	}
	fmt.Println(time.Since(t))
	fmt.Println(res)
}

output:

true
false
false
false
1.7822s
false
21.723s
false

Using the benchmark (isNumDot is faster than isNumeric):

BenchmarkIsNumDot-8    	34117197	        31.2 ns/op	       0 B/op	       0 allocs/op
BenchmarkIsNumeric-8   	 1931089	       630 ns/op	     192 B/op	       4 allocs/op

// r = isNumDot("2.22")
BenchmarkIsNumDot-8    	102849996	        11.4 ns/op	       0 B/op	       0 allocs/op
BenchmarkIsNumeric-8   	21994874	        48.5 ns/op	       0 B/op	       0 allocs/op

// r = isNumDot("a 240")
BenchmarkIsNumDot-8    	256610877	         4.58 ns/op	       0 B/op	       0 allocs/op
BenchmarkIsNumeric-8   	 8962381	       140 ns/op	      48 B/op	       1 allocs/op

The benchmark:

package main

import (
	"testing"
)

var r bool

func BenchmarkIsNumDot(b *testing.B) {
	for i := 0; i < b.N; i++ {
		r = isNumDot("a 240") || isNumDot("abcd123") || isNumDot("0.4.") || isNumDot("240 ")
	}
}

func BenchmarkIsNumeric(b *testing.B) {
	for i := 0; i < b.N; i++ {
		r = isNumeric("a 240") || isNumeric("abcd123") || isNumeric("0.4.") || isNumeric("240 ")
	}
}

I tried to comment on Adrian's answer but I guess I don't have enough reputation points. Building on his excellent response, here is a variation using PCRE. Some brief explanation on the symbols if you are unfamiliar with regular expressions:

"^" matches the start of input (i.e. beginning of your string)

"$" matches the end of input (i.e. the end of your string)

"()" are grouping operators

"*" matches 0 or more

"+" matches 1 or more

"?" matches exactly 0 or 1

"\d" is a character class which represents the character values 0 through 9

So, the following would require at least a leading 0, permit "0.", and everything else that is normally identified as a floating point value. You can experiment with this a bit.

func isFloat(s string) bool {
    return regexp.MatchString(`^\d+(\.\d*)?$`, s)
}

Naturally, if you are calling this function to validate data, it should be cleaned:

str := strings.TrimSpace(someString)
if isFloat(str) {
  ...
}

That only works on ASCII characters. If you are dealing with UTF8 or another multi-byte character set (MBCS), it can be done with regexp but more work would be required and perhaps another approach altogether.

You can use the strconv.Atoi function for check integer values, and the strconv.ParseFloat for float values. Below is an example:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	v1 := "14"
	
	if _, err := strconv.Atoi(v1); err == nil {
	    fmt.Printf("%q looks like a number.\n", v1)
	} else {
	    fmt.Printf("%q is not a number.\n", v1)
	}
	
	v2 := "1.4"
	if _, err := strconv.ParseFloat(v2, 64); err == nil {
	    fmt.Printf("%q looks like a float.\n", v2)
	} else {
	    fmt.Printf("%q is not a float.\n", v2)
	}
}

/* Output:
"14" looks like a number.
"1.4" looks like a float.
*/

You can check it on the Go Playground.

All the answers are valid, but there's another option not yet suggested:

re := regexp.MustCompile(`^[0-9]+(\.[0-9]+)?$`)
isNum := re.Match([]byte("ab123"))

Playground demo

I hit this in a high-throughput system today and did a benchmark of the three suggestions. Results:

BenchmarkNumDot-4: 657966132: 18.2 ns/op
BenchmarkNumeric-4: 49575919: 226 ns/op
BenchmarkRegexp-4: 18817201: 628 ns/op

Code follows since the playground does not support benchmarking.

package main
import (
"regexp"
"strconv"
"testing"
)
func BenchmarkNumDot(b *testing.B) {
for i := 0; i < b.N; i++ {
isNumDot("abc")
isNumDot("123")
isNumDot("12.34")
isNumDot("1.2.3.4")
}
}
func BenchmarkNumeric(b *testing.B) {
for i := 0; i < b.N; i++ {
isNumeric("abc")
isNumeric("123")
isNumeric("12.34")
isNumeric("1.2.3.4")
}
}
func BenchmarkRegexp(b *testing.B) {
re := regexp.MustCompile(`^[0-9]+(\.[0-9]+)?$`)
for i := 0; i < b.N; i++ {
isNumReg("abc", re)
isNumReg("123", re)
isNumReg("12.34", re)
isNumReg("1.2.3.4", re)
}
}
func isNumDot(s string) bool {
dotFound := false
for _, v := range s {
if v == '.' {
if dotFound {
return false
}
dotFound = true
} else if v < '0' || v > '9' {
return false
}
}
return true
}
func isNumeric(s string) bool {
_, err := strconv.ParseFloat(s, 64)
return err == nil
}
func isNumReg(s string, re *regexp.Regexp) bool {
return re.Match([]byte(s))
}