golang number type conversion

Golang is a programming language that supports multiple data types. The same is true for numeric types, including integers and floating point numbers, etc. In programming, we often need to convert numeric types. This article will introduce the conversion operations of numeric types in Golang.

Integer type conversion

In Golang, integers default to int type. When you need to convert one integer type to another integer type, you can use type conversion.

For example, we can convert a variable x of type int to type int64, as shown below:

var x int = 1
var y int64
y = int64(x)
fmt.Println(y)

Of course, other integer types can also be converted to type int, as shown below:

var z uint32 = 10
var w int
w = int(z)
fmt.Println(w)

It should be noted that conversion of integer types may cause problems such as loss of precision and overflow. Therefore, when performing type conversion, pay attention to the compatibility between types and the scope of the data.

Floating point type conversion

Golang supports two floating point types: float32 and float64. Type conversion operations are also used when converting floating point types.

For example, we can convert a float32 type variable x to float64 type, as shown below:

var x float32 = 1.23
var y float64
y = float64(x)
fmt.Println(y)

Conversely, we can also convert a float64 type variable to float32 type, as shown below ：

var z float64 = 3.45
var w float32
w = float32(z)
fmt.Println(w)

Similarly, when converting floating point number types, you must also pay attention to the compatibility between types and the accuracy of the data.

Conversion from string to numeric type

In Golang, conversion between string and numeric types is also a common operation. For example, to convert a string type to int type, you can use the strconv.Atoi() function, as shown below:

import "strconv"
str := "123"
num, _ := strconv.Atoi(str)
fmt.Println(num)

Similarly, you can also convert a string type to int64 type, as shown below :

str := "123"
num, _ := strconv.ParseInt(str, 10, 64)
fmt.Println(num)

Among them, 10 means using decimal analysis, and 64 means the number of bits in the conversion result.

It should be noted that when converting string and numeric types, make sure that the content expressed by the string can be converted to numeric types. Otherwise, conversion failure will occur.

Numeric type to string conversion

In contrast to converting the string type to the numeric type, converting the numeric type to the string type is also a common operation. For example, to convert an int type variable to a string type, you can use the strconv.Itoa() function, as shown below:

import "strconv"
num := 123
str := strconv.Itoa(num)
fmt.Println(str)

Similarly, you can also convert an int64 type variable to a string type. , as shown below:

num := int64(123)
str := strconv.FormatInt(num, 10)
fmt.Println(str)

Among them, 10 means output in decimal format.

It should be noted that when converting between numeric types and string types, make sure that the range of numeric types can be expressed as string types. Otherwise, conversion failure or loss of accuracy may occur.

Summary

This article introduces the conversion operations of numeric types in Golang, including integer type conversion, floating point type conversion, string to numeric type conversion and numeric type to string conversion. When performing type conversion, special attention should be paid to compatibility between types and the range or precision of data.

The above is the detailed content of golang number type conversion. For more information, please follow other related articles on the PHP Chinese website!