String to Integer Conversion in Go

In Go, converting a string to an integer is a common operation that can be achieved using various methods. This tutorial will cover the most idiomatic ways to perform this conversion, including error handling and best practices.

Introduction to strconv Package

The strconv package provides several functions for converting between strings and integers. The two most commonly used functions are Atoi() and ParseInt().

• Atoi(s string) (int, error): This function converts a string to an integer. It returns the converted integer and an error if the conversion fails.
• ParseInt(s string, base int, bitSize int) (i int64, err error): This function parses a string as an integer with a specified base and bit size.

Converting Strings to Integers

To convert a string to an integer using Atoi(), follow these steps:

package main

import (
    "fmt"
    "strconv"
)

func main() {
    s := "123"

    // Convert string to int
    i, err := strconv.Atoi(s)
    if err != nil {
        // Handle error
        panic(err)
    }

    fmt.Println(s, i)
}

Alternatively, you can use ParseInt() for more flexibility:

package main

import (
    "fmt"
    "strconv"
)

func main() {
    s := "123"

    // Convert string to int64 with base 10 and bit size 0 (default)
    i, err := strconv.ParseInt(s, 10, 0)
    if err != nil {
        // Handle error
        panic(err)
    }

    fmt.Println(s, i)
}

Using fmt.Sscan() for Custom String Parsing

When dealing with custom string formats, fmt.Sscan() can be used to parse the string and extract the integer value:

package main

import (
    "fmt"
)

func main() {
    s := "id:00123"

    var i int
    if _, err := fmt.Sscanf(s, "id:%5d", &i); err != nil {
        // Handle error
        panic(err)
    }

    fmt.Println(i)  // Outputs 123
}

Performance Comparison

The performance of these conversion methods can vary. In general, strconv.Atoi() and strconv.ParseInt() are faster than fmt.Sscan(). However, the actual performance difference may depend on your specific use case.

To give you a rough idea, here’s a simple benchmark:

package main

import (
    "testing"
    "strconv"
    "fmt"
)

var num = 123456
var numstr = "123456"

func BenchmarkStrconvAtoi(b *testing.B) {
    for i := 0; i < b.N; i++ {
        x, err := strconv.Atoi(numstr)
        if x != num || err != nil {
            b.Error(err)
        }
    }
}

func BenchmarkStrconvParseInt(b *testing.B) {
    for i := 0; i < b.N; i++ {
        x, err := strconv.ParseInt(numstr, 10, 64)
        if x != int64(num) || err != nil {
            b.Error(err)
        }
    }
}

func BenchmarkFmtSscan(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var x int
        n, err := fmt.Sscanf(numstr, "%d", &x)
        if n != 1 || x != num || err != nil {
            b.Error(err)
        }
    }
}

Running this benchmark will give you an idea of the relative performance of each method.

Best Practices and Error Handling

When converting strings to integers in Go, it’s essential to handle potential errors. Always check the error return value from Atoi() or ParseInt(), and handle any errors accordingly.

Additionally, consider using fmt.Sscan() for custom string parsing when dealing with complex formats.

By following these guidelines and best practices, you can ensure robust and efficient string-to-integer conversions in your Go applications.