ParseInt
A string
in Go can contain digit characters like "123." We can convert this string
to a number (an int
) with the strconv.ParseInt
method.
With Atoi
we have a simpler way to call ParseInt
. These methods return 2 values: the parsed integer itself, and an error code.
ParseInt
Let us begin with this simple example. We import the strconv
package at the top. We assign 2 values to the result of strconv.ParseInt
.
ParseInt
with 3 arguments—the first is the string
we want to get an integer from.string
being parsed. Most numbers we use are base 10.int
. 0 means int
, while 6 (for example) means int16
, with 16 bits.package main import ( "fmt" "strconv" ) func main() { value := "123" // Convert string to int. number, _ := strconv.ParseInt(value, 10, 0) // We now have an int. fmt.Println(number) if number == 123 { fmt.Println(true) } }123 true
Atoi
This function bears the same name as the one from the C standard library. In Go it invokes ParseInt
with a base of 10 and a bit size of 0.
Atoi
call here is simpler than ParseInt
. This gives it an advantage in readability in programs.package main import ( "fmt" "strconv" ) func main() { value := "456" // Use Atoi to parse string. number, _ := strconv.Atoi(value) fmt.Println(number) fmt.Println(number + 1) }456 457
FormatInt
With this method, we convert an int
to a string
. This is the opposite conversion as ParseInt
. With FormatInt
, we must pass an int64
value—we cast in this example.
package main import ( "fmt" "strconv" ) func main() { value := 1055 // Convert int to string with FormatInt. // ... First convert to int64. result := strconv.FormatInt(int64(value), 10) fmt.Println(result) if result == "1055" { fmt.Println(true) } }1055 true
Itoa
This method converts an int
into a string
. It calls FormatInt
with a base of 10. It also accepts a simple int
, not an int64
, so less casting may be required.
ParseInt
and Atoi
, FormatInt
and Itoa
do not return an error value. They succeed on all possible arguments.package main import ( "fmt" "strconv" ) func main() { value := 700 // Use Itoa on an int. result := strconv.Itoa(value) fmt.Println(result) // The string has 3 characters. fmt.Println(len(result)) }700 3
ParseInt
benchmarkOften we need to convert a string
into an integer. This benchmark compares ParseInt
and Atoi
. It converts "1234" into an integer with each method.
ParseInt
method. It repeatedly calls ParseInt
in a loop.Atoi
method, in a similar way as in version 1. We try to determine the time required per method call.ParseInt
method seems to be faster. It should be preferred when it can be used.package main import ( "fmt" "strconv" "time" ) func main() { t0 := time.Now() original := "1234"; // Version 1: use ParseInt. for i := 0; i < 1000000; i++ { result, _ := strconv.ParseInt(original, 10, 0) if result != 1234 { return } } t1 := time.Now() // Version 2: use Atoi. for i := 0; i < 1000000; i++ { result, _ := strconv.Atoi(original) if result != 1234 { return } } t2 := time.Now() // Results of benchmark. fmt.Println(t1.Sub(t0)) fmt.Println(t2.Sub(t1)) }14.023ms ParseInt 18.5125ms Atoi
We converted strings to integers in Go. With ParseInt
and the convenient method Atoi
that calls ParseInt
with common arguments, we perform this task with ease.