How can I convert string to integer in golang

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

You can use these three functions to convert a string value to an integer or a float.

Note: the strconv builtin package must be imported to execute these functions.

1. func Atoi(s string) (int, error)
2. func ParseInt(s string, base int, bitSize int) (i int64, err error)
3. func ParseFloat(s string, bitSize int) (float64, error)

<!-- -->

package main

import (
	"fmt"
	"strconv"
)

func main() {
	i, _ := strconv.Atoi("-42")
	fmt.Println(i)

	j,_ := strconv.ParseInt("-42", 10, 8)
 	fmt.Println(j)

	k,_ := strconv.ParseFloat("-42.8", 8)
	fmt.Println(k)
}

package main

import "strconv"
import "fmt"

// The built-in package "strconv" provides the number parsing.

// For `ParseInt`, the `0` means infer the base from
// the string. `64` requires that the result fit in 64
// bits.


value, err := strconv.ParseInt("123", 0, 64)
if err != nil {
    panic(err)
}
fmt.Println(value)

For reference, Click Here

You can also pass a non-zero base (like 10) if you always want the same thing.

> 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\n", 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.

To add to the excellent answer by @MayankPatel and by @DeepakG. A string can be set to various numeric types. Various numeric types can be set to a string. Likewise, "true" can be set to a bool and true can be set to a string.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	//convert a string to another type
	f, _ := strconv.ParseFloat("70.99", 64)
	i, _ := strconv.Atoi(fmt.Sprintf("%.f", f))
	t, _ := strconv.ParseBool("true")
	c := []interface{}{[]byte("70.99"), f, i, rune(i), t}
	checkType(c) //[]uint8 [55 48 46 57 57], float64 70.99, int 71, int32 71, bool true

	//convert another type to a string
	c = []interface{}{fmt.Sprintf("%s", []byte("70.99")), fmt.Sprintf("%.f", f), strconv.Itoa(i), string(rune(i)), strconv.FormatBool(t)}
	checkType(c) //string 70.99, string 71, string 71, string G, string true
}

func checkType(s []interface{}) {
	for k, _ := range s {
		fmt.Printf("%T %v\n", s[k], s[k])
	}
}

A string type represents the set of string values. A string value is a (possibly empty) sequence of bytes. The number of bytes is called the length of the string and is never negative. Strings are immutable. See https://Golang.org/ref/spec#String_types.

Here are three ways to parse strings into integers, from fastest runtime to slowest: 1. strconv.ParseInt(...) fastest 2. strconv.Atoi(...) still very fast 3. fmt.Sscanf(...) not terribly fast but most flexible. See https://stackoverflow.com/a/47317150/12817546.

Avoid converting a string to []byte: b := []byte(s). It allocates a new memory space and copies the whole content into it. See https://stackoverflow.com/a/52943136/12817546. See https://stackoverflow.com/a/41460993/12817546. Quotes edited.

You can write a FieldsFunc to parse and get the number values alone separately.

Play it here

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.

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.

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                                                                                                           
 }    

import (
  "strconv"
  "strings"
)

func StrToInt(str string) int {
  // Delete any non-numeric character from the string
  str = strings.TrimFunc(str, func(r rune) bool {
      return r < '0' || r > '9'
  })

  // Convert the cleaned-up string to an integer
  n, _ := strconv.Atoi(str)
  return n
}