golang type conversion

Golang is a high-performance, simple, safe and easy-to-learn programming language. In Golang, type conversion is the process of converting one data type to another data type. In this article, we will explore type conversion in Golang, including basic type conversion, custom type conversion, and interface conversion.

Basic type conversion

In Golang, basic types include int, float, bool, string, etc. When we need to convert one of the types to another type, we can use cast to convert. For example, convert int type to string type:

var num int = 42
var str string = strconv.Itoa(num)

In the above code, the Itoa function in the strconv package is used to convert the int type variable Convert num to string type variable str.

Another common basic type conversion is to convert string type to int type. In Golang, this task can be accomplished using the Atoi function of the strconv package. For example:

var str string = "42"
num, err := strconv.Atoi(str)
if err != nil {
    // 处理错误
}

In the above code, use the Atoi function to convert the string type variable str to the int type variable num. If an error occurs during conversion, you can handle the error with err.

Custom type conversion

In addition to basic type conversion, custom type conversion can also be performed in Golang. Custom types are defined through structures or interfaces. For example, we can define a structure:

type MyInt int

In the above code, we define a structure named MyInt, whose underlying type is int. We can also add methods to the structure.

Now, we want to convert a MyInt type variable into a int type variable. In Golang, you can use the type conversion operator () for conversion. For example:

var num MyInt = 42
var i int = int(num)

In the above code, use int() to convert the MyInt type variable num to intType variablei.

Interface conversion

In Golang, an interface defines a set of methods rather than a specific type. Therefore, when we need to convert one interface type to another interface type, we need to first determine whether the interface type at this time can be converted to the target interface type.

In Golang, you can use type assertions and type conversion operators () to complete interface conversion. For example:

type Animal interface {
    Move() string
}

type Dog struct {
    Name string
}

func (d *Dog) Move() string {
    return "Move like a dog"
}

func main() {
    var a Animal
    a = &Dog{"Fido"}

    // 将a转换为*Dog类型
    d, ok := a.(*Dog)
    if ok {
        fmt.Printf("Name: %s
", d.Name)
        fmt.Println(d.Move())
    }
}

In the above code, we define an interface named Animal and a structure named Dog, and The Dog structure pointer is assigned to the Animal interface variable a. Then, we use type assertions and type conversion operators () to convert the Animal interface to the *Dog type, and print out the Dog structure The name and movement method of the bodyd.

Summary

In Golang, type conversion is the process of converting one data type to another data type. Basic type conversion can be done using forced type conversion, custom type conversion can be done using type conversion operator (), and interface conversion can be done using type assertion and type conversion operator (). . When performing type conversion, be sure to pay attention to type compatibility to avoid errors.

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