golang variable type conversion

The Go language is a statically typed language, which means that the types of variables must be defined before using them. Sometimes we need to convert an existing variable type to another type. This article will introduce the relevant knowledge of golang variable type conversion.

In golang, type conversion is implemented through explicit conversion, which means that developers need to explicitly tell the compiler which type we want to convert to which type, thereby avoiding some potential type safety question.

Golang variable type conversion mainly includes the following two types:

1. Basic type conversion
2. Customized type conversion

1. Basic type conversion

In golang, basic types including int, float, string, etc. all support type conversion. Developers can use built-in conversion functions to convert one basic type into another basic type.

1. Integer type conversion

In golang, integer types include int8, int16, int32, int64, uint8, uint16, uint32, uint64, etc. When we need to convert an integer variable from one type to another, we can use the built-in conversion function.

The following is an example of converting int32 type to int64 type:

var a int32 = 100
var b int64
b = int64(a)

Here, int32 type variable a is converted into int64 type variable b. It should be noted that from small range type to large range Type conversion can be performed automatically, but conversion from a large range type to a small range type requires an explicit call to the conversion function.

2. Floating point type conversion

In golang, floating point types include float32 and float64. When converting a floating point variable from one type to another type, you can also Use built-in conversion functions.

The following is an example of converting float32 type to float64 type:

var a float32 = 3.14159
var b float64
b = float64(a)

Here, float32 type variable a is converted into float64 type variable b. It is also necessary to pay attention to the small range type to the large range type. Conversion can be performed automatically, but conversion from a large range type to a small range type requires an explicit call to the conversion function.

3. String type conversion

It is also common to convert a string into other types of variables. Golang provides built-in conversion functions, as follows:

a := "1234"
b, err := strconv.Atoi(a)   //将字符串转换成int类型的变量
c, err := strconv.ParseFloat(a, 64)  //将字符串转换成float64类型的变量
d := strconv.Itoa(1234)   //将int类型的变量转换成字符串
e := strconv.FormatFloat(3.14159, 'E', -1, 64)  //将float64类型的变量转换成字符串

Required Note that when converting a string to a numeric variable, you must ensure that the string can be correctly converted to a number, otherwise a runtime error will result.

2. Custom type conversion

In golang, custom types can also be type converted, and you only need to implement the corresponding type conversion function.

Type conversion on a custom type needs to meet certain conditions, as follows:

1. Custom type T must be a type

2. Type T has An underlying type, and the underlying type cannot be a pointer or interface type

3. The underlying type and T can be converted to each other

The following is an example of custom type conversion:

type Celsius float32
type Fahrenheit float32

func CToF(c Celsius) Fahrenheit {
    return Fahrenheit(c*9/5 + 32)
}

func FToC(f Fahrenheit) Celsius {
    return Celsius((f - 32) * 5 / 9)
}

func main() {
    c := Celsius(28.0)
    f := Fahrenheit(82.4)
    fmt.Printf("%g°F = %g°C
", f, FToC(f))
    fmt.Printf("%g°C = %g°F
", c, CToF(c))
}

In this example, we define two types Celsius and Fahrenheit, and define two type conversion functions CToF and FtoC. In the main function, we use these two type conversion functions to convert the Celsius type to the Fahrenheit type, and to convert the Fahrenheit type to the Celsius type.

It should be noted that type safety issues need to be paid attention to when performing type conversion in custom types to ensure that data will not be lost or damaged during type conversion.

Summary

In golang, type conversion is mainly achieved through explicit conversion. You can convert one basic type into another basic type, or you can convert a custom type into another A custom type. When performing type conversion, you need to pay attention to type safety issues to ensure that data will not be lost or damaged during the conversion process, and to avoid some potential type safety issues.

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