Detailed introduction to type conversion in Golang

Golang is a statically typed programming language, and type conversion plays an important role in daily programming. In Golang, type conversion can convert a value from one type to another type. This article will introduce type conversion in Golang in detail.

1. Basic type conversion

In Golang, both automatic type conversion and forced type conversion can be performed. Automatic type conversion means that the compiler automatically converts one type to another type when necessary. For example, when assigning a value of integer type to a variable of floating point type, type conversion is performed automatically. Casting is when the programmer explicitly converts a value from one type to another. In Golang, forced type conversion is written as: target type (converted value).

The following are some examples of basic type conversions:

var i int = 10
var f float64 = float64(i)   // int to float64
var u uint = uint(f)         // float64 to uint
var s string = string(i)     // int to string
var b []byte = []byte(s)     // string to []byte
var r rune = rune(i)         // int to rune, represents a Unicode code point

2. Interface type conversion

In Golang, interface type assertion refers to converting an interface type The value is converted to a value of another interface type. However, if it is unsafe to convert from one of the interface types to another, the compiler will fail to compile. Therefore, when performing interface type conversion, the initial type can be a superset of the target type, but it must be satisfied that the converted target type must be a subset of the original type.

The following is an example of interface type conversion:

package main
 
import "fmt"
 
type Animal interface {
    Speak() string
}
 
type Cat struct{}
 
func (c Cat) Speak() string {
    return "cat"
}
 
type Dog struct{}
 
func (d Dog) Speak() string {
    return "dog"
}
 
func main() {
    animals := []Animal{Cat{}, Dog{}, Cat{}, Dog{}}
    for _, animal := range animals {
        fmt.Println(animal.Speak())
        if v, ok := animal.(Dog); ok {
            fmt.Println(v, ok)
        }
    }
}

3. Custom type conversion

In Golang, in addition to the conversion of basic types and interface types, Custom type conversions are also possible. A conversion that defines a new type is very useful because it converts the new type to the old type and vice versa. If we didn't define it as a type using NewType, we wouldn't be able to use the conversion function.

The following is an example of custom type conversion:

type Celsius float64
type Fahrenheit float64

const (
    AbsoluteZeroC Celsius = -273.15
    FreezingC     Celsius = 0
    BoilingC      Celsius = 100
)

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

func main() {
    fmt.Printf("%g\n", BoilingC-FreezingC) // "100" °C
    boilingF := CToF(BoilingC)
    fmt.Printf("%g\n", boilingF-CToF(FreezingC)) // "180" °F
}

Summary

This article introduces type conversion in Golang, including conversion of basic types, interface types and custom types . When performing type conversion, we must comply with the safety specifications of type conversion to ensure that our program is correct. Type conversion is necessary in many scenarios. Good type conversion design can improve the performance of the program and is particularly important in actual programming.

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