# How to Convert String to Int64 in Golang

0
1173 Golang strconv.ParseInt() is a built-in function that parses a decimal string (base 10) and checks if it fits into an int64. The size of an int is implementation-specific; it’s either 32 or 64 bits, so you won’t lose any key info when converting from int to  int64.

## Golang string to int64

To convert string to int in Golang, use the strconv.ParseInt() method. Go strconv.ParseInt to convert a decimal string (base 10) and check that it fits into a 64-bit signed integer.

### func ParseInt()

ParseInt interprets the string in the given base (0, 2 to 36) and bit size (0 to 64) and returns the corresponding i. If a base argument is 0, the true base is implied by a string’s prefix: 2 for “0b”, 8 for “0” or “0o”, 16 for “0x”, and 10 otherwise.

Also, for argument base 0 only, underscore characters are permitted as defined by the Golang syntax for integer literals.

The bitSize parameter specifies an integer type that the result must fit into. For example, bit sizes 0, 8, 16, 32, and 64 correspond to int, int8, int16, int32, and int64. An error is returned if the bitSize is below 0 or above 64.

Let’s use the Golang strconv.ParseInt() function to convert string to int64 in Golang.

```// hello.go

package main

import (
"fmt"
"strconv"
)

func main() {
str := "101"
n, err := strconv.ParseInt(str, 10, 64)
if err == nil {
fmt.Printf("%d of type %T", n, n)
}
}
```

#### Output

```go run hello.go
101 of type int64```

The two numeric arguments represent the base (0, 2 to 36) and a bit size (0 to 64).

If the first argument is 0, the base is implied by a string’s prefix: base 16 for “0x”, base 8 for “0”, and base 10 otherwise.

The second argument describes an integer type that a result must fit into. For example, bit sizes 0, 8, 16, 32, and 64 correspond to int, int8, int16, int32, and int64.

### Example 2: Convert Golang string to int

See the following code.

```// hello.go

package main

import (
"fmt"
"strconv"
)

func main() {
v32 := "-354634382"
if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseInt(v32, 16, 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}

v64 := "-3546343826724305832"
if s, err := strconv.ParseInt(v64, 10, 64); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseInt(v64, 16, 64); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
}
```

#### Output

```go run hello.go
int64, -354634382
int64, -3546343826724305832```

## Parsing string into int64

See the following code.

```// hello.go

package main

import (
"fmt"
"reflect"
"strconv"
)

func main() {
var s string = "112119462926854775"
i, err := strconv.ParseInt(s, 10, 64)
if err != nil {
panic(err)
}
fmt.Printf("Bonjour, %v with type %s!\n", i, reflect.TypeOf(i))
}```

#### Output

```go run hello.go
Bonjour, 112119462926854775 with type int64!```

## Conclusion

If you want to convert the Golang string to int64, you should also pass in the 64 as the last argument to ParseInt(), or it might not produce the expected value on the 32-bit system.