类型转换

同类型之间的转换

Go
    import "fmt"

    func main() {
        var i int = 33
        var i64 int64
        i64 = int64(i)
        fmt.Println(i, i64)
    }

在同类型之间，精度高的类型可以向精度低的类型转换，但是可能会造成精度损失，低类型转换到高类型就没有这个问题了。
并且高精度类型向低精度类型转换的时候，还需要注意低精度类型的容量是否足够大。

不同类型之间的转换

bool -> int & int -> bool

Go01 
// 布尔类型转换为0或者1
func btoi(b bool) int {
    if b {
        return 1
    }
    return 0
}

// 数字转换为布尔类型
func itob(i int) bool { 
  	return i != 0 
}

stringstring

string -> int & int -> string

    import "strconv"

    func main() {
        str := "10"
        // string -> int
        i, err := strconv.Atoi(str)
    }

    import "strconv"

    func main() {
        i := 10
        // int -> string
        str := strconv.Itoa(i)
      	// OR 
        str2 := fmt.Sprintf("%d",i)
    }

string -> float & float -> string

    import "strconv"

    func main() {
        str := "3.2222"
        // string -> float
        fl64, err := strconv.ParseFloat(str,64)
        fl32, err := strconv.ParseFloat(str,32)
    }

    import (
        "fmt"
        "strconv"
    )

    func main() {
        fl64 := 3.1415926
        // float -> string
        str := strconv.FormatFloat(fl64,'f',-1,64)
        str = fmt.Sprintf("%.3f",fl64)
    }

floatstring

第一种方法，可以获得更高精度的浮点数
第二种方法，可以更方便我们的使用，我自己日常使用的时候，都是使用第二种

string -> bool & bool -> string

    import "strconv"

    func main() {
        b := true
        // bool -> string
        str: = strconv.FormatBool(b)
    }

    import "strconv"

    func main() {
        str := "true"
        //  string -> bool
        b, err := strconv.ParseBool(str)
    }
类型别名

当你在使用某个类型时，你可以给它起另一个名字，然后你就可以在你的代码中使用新的名字（用于简化名称或解决名称冲突），例如：

    import "fmt"

    type short int32
    type long int64

    func main() {
        var sh short = 22
        var lo long = 66
        fmt.Println(sh)
        fmt.Println(lo)
    }

第三行和第四行，就是新定义的类型，它拥有原类型的所有特性，可以代替原类型来使用，但是不可以使用原来类型的方法，可以根据新的类型定义新的方法。
不光是语言自带的类型可以定义别名，我们自己定义的结构体，接口，函数，都可以定义别名。

我的公众号

细节决定成败!
个人愚见，如有不对，恳请斧正!