How to do integer conversion in Golang

When writing code, we often need to convert data types. These conversions are usually between different data types, such as converting a string to an integer or floating point number, or converting an integer to a string, etc. In Golang, integer conversion is particularly important. This article will introduce how to perform integer conversion in Golang and related precautions.

Golang supports converting integer types of different sizes to each other. For example, you can convert uint8 to int8, and int64 to uint8. However, it should be noted that type conversion can only be performed when the representation range of the target type can completely encompass the value range of the converted value.

For example, if you convert the maximum value of int16 (32767) to int8, it will cause data overflow and the result may become negative. Likewise, if you convert a floating-point numeric literal of 123.45 (which is interpreted as a float64 type) to a uint16, you lose the fractional part and get a truncated integer value.

The following are some examples that demonstrate how to perform integer conversion in Golang:

package main

import (
    "fmt"
    "math"
)

func main() {
    // 将int转换为float
    a := 10
    b := float64(a)
    fmt.Printf("a=%d, b=%f\n", a, b)

    // 将float转换为int
    c := 3.14159
    d := int(c)
    fmt.Printf("c=%f, d=%d\n", c, d)

    // 将uint64转换为int32
    const maxUint64 = math.MaxUint64
    var e uint64 = maxUint64
    f := int32(e)
    fmt.Printf("e=%d, f=%d\n", e, f)

    // 将int8转换为uint8
    var g int8 = -12
    h := uint8(g)
    fmt.Printf("g=%d, h=%d\n", g, h)
}

In the above example, we convert the int type variable a to float64 and float64 respectively. The variable c of type c is converted to type int, the variable e of type uint64 is converted to int32, and the variable g of type int8 is converted to uint8. In each case, we printed the initial value and the converted result. Note that the range of unsigned integer types (such as uint8, uint16, etc.) should be carefully considered before converting them to signed types. If the original value exceeds the target type's range of positive representation, the result will be negative.

In addition to explicit conversions, Golang also provides some implicit integer conversions. In some cases, doing implicit conversions can make your code cleaner, but in other cases, you need to be careful.

For example, when using a variable of signed integer type (such as int8) with a number of unsigned integer type (such as uint8) for addition, subtraction, multiplication or left shift operation, the latter will be converted to AND The same signed type as the former. This transformation can make the code more readable and also prevent overflows. However, when using any other operator, the conversion instruction must be issued explicitly.

In Golang, there are some "implicit rules" for integer conversion. For example, when using operators to add or subtract two integer types of different sizes, Golang will automatically convert them to the same type and sign-extend if necessary. However, when assigning an integer type to a variable of another type (such as to a string or interface type), it must be explicitly converted to the required type.

Summary:

• In Golang, integer values ​​can be converted to each other, but the range of the target type must be large enough to accommodate the range of the source value.
• Explicit or implicit integer conversions can be used, but the latter should be used with care to prevent unexpected conversion errors.
• When performing integer conversion, you need to have some basic mathematical knowledge, especially when considering the signed and unsigned nature of integer types.

The above is the detailed content of How to do integer conversion in Golang. For more information, please follow other related articles on the PHP Chinese website!