In-depth Analysis of String to int64 Conversion in Go

Core Method for String to int64 Conversion

In Go, converting a string to an int64 requires using the ParseInt function provided by the strconv package. Unlike the Atoi function, ParseInt directly returns an int64 value, avoiding additional type conversion steps.

Detailed Analysis of the ParseInt Function

The signature of strconv.ParseInt is as follows:

func ParseInt(s string, base int, bitSize int) (i int64, err error)

This function takes three parameters: the string to parse s, the base base, and the bit size bitSize. It returns the parsed int64 value and a possible error.

Practical Application Example

Here is a complete conversion example:

var s string = "9223372036854775807"
i, err := strconv.ParseInt(s, 10, 64)
if err != nil {
    panic(err)
}
fmt.Printf("val: %v ; type: %[1]T\n", i)

This code converts the string "9223372036854775807" to int64 and outputs the result. Using the %[1]T format specifier verifies that the converted type is indeed int64.

Considerations for Parameter Selection

The base parameter base can be an integer between 0 and 36. When base is 0, the function automatically determines the base from the string prefix: "0x" for hexadecimal, "0" for octal, and decimal otherwise.

The bit size parameter bitSize is crucial as it specifies the integer type size the result should fit into. For int64 conversion, 64 must be explicitly specified as the bit size to ensure correct parsing of 64-bit integers on 32-bit systems.

Error Handling Strategies

In practical applications, errors returned by ParseInt should be properly handled:

s := "97"
n, err := strconv.ParseInt(s, 10, 64)
if err != nil {
    fmt.Println(s, "is not a valid integer")
} else {
    fmt.Printf("%d of type %T", n, n)
}

This error handling approach captures invalid inputs, out-of-range values, or other parsing issues.

Comparison with Other Conversion Methods

Although the strconv.Atoi function can also convert strings to integers, it returns an int type, which is equivalent to int64 on 64-bit systems but only 32 bits on 32-bit systems. Therefore, when an int64 type is explicitly needed, using ParseInt directly is a safer choice.

Related Concepts in Type Conversion

In Go, converting from int to int64 is safe because int64 can accommodate all possible int values. However, converting from int64 to int may cause truncation on 32-bit systems:

var m int64 = 2 << 32
n := int(m) // Truncated on systems with 32-bit ints

Understanding these underlying details helps in writing more robust cross-platform code.