I want to convert string to integer in golang. But I don't know the format of string. For example, "10" -> 10, "65.0" -> 65, "xx" -> 0, "11xx" -> 11, "xx11"->0
I do some searching and find strconv.ParseInt(). But it can not handle "65.0". So I have to check string's format.
Is there a better way?
I believe function you are looking for is
strconv.ParseFloat()
see example here
But return type of this function is float64.
If you don't need fractional part of the number passed as the string following function would do the job:
func StrToInt(str string) (int, error) {
nonFractionalPart := strings.Split(str, ".")
return strconv.Atoi(nonFractionalPart[0])
}
My current solution is:
// Convert string to integer in best effort.
// TODO: handle overflow and add unittest
func StrToInt(str string) (int64, error) {
if len(str) == 0 {
return 0, nil
}
negative := false
i := 0
if str[i] == '-' {
negative = true
i++
} else if str[i] == '+' {
i++
}
r := int64(0)
for ; i < len(str); i++ {
if unicode.IsDigit(rune(str[i])) {
r = r*10 + int64(str[i]-'0')
} else {
break
}
}
if negative {
r = -r
}
// TODO: if i < len(str), we should return error
return r, nil
}
You can write a FieldsFunc to parse and get the number values alone separately.
package main
import (
"fmt"
"strconv"
"strings"
"unicode"
)
func stripNonIntFloat(s string) string {
f := func(c rune) bool {
return !unicode.IsNumber(c) && (c != 46)
}
output := strings.FieldsFunc(s, f)
if len(output) > 0 {
return output[0]
} else {
return ""
}
}
func main() {
strList := []string{"10", "65.0", "xx", "11xx", "xx11"}
for i := 0; i < len(strList); i++ {
s := stripNonIntFloat(strList[i])
v, err := strconv.ParseFloat(s, 10)
if err != nil {
fmt.Println(strList[i], 0)
} else {
fmt.Println(strList[i], v)
}
}
}
The output here is
10 10
65.0 65
xx 0
11xx 11
xx11 11
Note that your last condition of xx11 handles it as 11.
I want to convert string to integer in golang.
As you've already mentioned, there is a strconv.ParseInt function that does exactly this!
But I don't know the format of string.
That sounds scary (and challenging), but after looking at your examples I can easily conclude you know the format and the problem can be stated like this:
How can I parse an initial portion of a string as an integer?
As strconv.ParseInt returns 0 on syntax error it's not a good fit; well, at least not a good fit directly. But it can parse your initial portion if you extract it. I'm sure you've already figured it out, but this is really the cleanest solution: extract your content from the string, parse it.
You can extract the leading integer in a few ways, one of them is by using regexp:
package main
import (
"fmt"
"regexp"
"strconv"
)
// Extract what you need
var leadingInt = regexp.MustCompile(`^[-+]?\d+`)
func ParseLeadingInt(s string) (int64, error) {
s = leadingInt.FindString(s)
if s == "" { // add this if you don't want error on "xx" etc
return 0, nil
}
return strconv.ParseInt(s, 10, 64)
}
func main() {
for _, s := range []string{"10", "65.0", "xx", "11xx", "xx11"} {
i, err := ParseLeadingInt(s)
fmt.Printf("%s\t%d\t%v
", s, i, err)
}
}
http://play.golang.org/p/d7sS5_WpLj
I believe this code is simple and clearly demonstrates the intentions. You're also using standard ParseInt which works and gives you all the error checking you need.
If for any reason you can't afford extracting the leading integer (you need it blazing fast parsing terabytes of data and your boss is screaming at you they need it now now now and better yesterday so bend the time and deliver it :hiss:) than I suggest diving into the source code and amending the standard parser so it doesn't report syntax errors, but returns a parsed portion of the string.
Extracting an int from the start of a string is one of the most common things I do. In C you can use atoi() or strtol(). It's ridiculous that Go does not have a std library function to do it. Anyway here is one I just rolled up:
// strToInt gets the integer from the start of the string.
// It returns the value and the offset of the first non-digit.
func StrToInt(s string) (v int, offset int) {
offset = strings.IndexFunc(s, func(r rune) bool { return r < '0' || r > '9' })
if offset == -1 { offset = len(s) }
if offset == 0 { return } // Avoid Atoi on empty string
v, _ = strconv.Atoi(s[:offset])
return
}
You'll need a slight fix if you want to handle -ve integers.
package main
import "strconv"
import "fmt"
// The built-in package "strconv" provides the number parsing.
//For `ParseInt`, the `10` means infer the base from
// the string. `64` requires that the result fit in 64
// bits.
value, err := strconv.ParseInt("123", 10, 64)
if err != nil {
panic(err)
}
fmt.Println(value)