零值

变量声明时没有初始化会默认赋值为零值 。
零值是：

数值类型为 0 
布尔类型为 false 
字符串为 "" （空字符串）

基本类型的类型转换

C语言转换

先看一下，在C语言中的类型转换，
隐式转换

int a = 10;
int b = 3.0
int num = 3.14;  
double res = a/b;

显示转换

int a = 10;
int b = 3.0
double res = (double)a/b;

Golang基本类型间只能进行显示转换

但是，Golang基本类型间只能进行显示转换，
转换形式如下：

Type(value)

其中value是要转换的值（包括变量、复杂算子和函数返回值），Type是要转换成的类型。
在类型转换时，要考虑它们之间的关系和范围，以免精度丢失或数值截断。

特别注意:
byte --> uint8 和 rune --> int32 是能够直接赋值的特殊情况(byte就是unit8的别名，rune就是int32的别名)

看一些例子：

    // 输出各数值范围
    fmt.Println("int8 range:", math.MinInt8, math.MaxInt8)
    fmt.Println("int16 range:", math.MinInt16, math.MaxInt16)
    fmt.Println("int32 range:", math.MinInt32, math.MaxInt32)
    fmt.Println("int64 range:", math.MinInt64, math.MaxInt64)

    // 初始化一个32位整型值
    var a int32 = 1047483647
    // 输出变量的十六进制形式和十进制值
    fmt.Printf("int32: 0x%x %d\n", a, a)

    // 将a变量数值转换为十六进制, 发生数值截断
    b := int16(a)
    // 输出变量的十六进制形式和十进制值
    fmt.Printf("int16: 0x%x %d\n", b, b)

    // 将常量保存为float32类型
    var c float32 = math.Pi
    // 转换为int类型, 浮点发生精度丢失
    fmt.Println(int(c))

bool不能直接转换成整型

bool类型不能强制转换为整型(bool类型在底层是0和1，不能更改为整型变量）

//bool不能直接转换成int,编译器会报错
var flag bool = false
var num int = int(flag) //报错
fmt.Printf("%d\n", num)

string与基本数据类型转换

string-->基本数据类型

• strconv.ParseXxx()
• strconv.Atoi()

string-->整型

    /*------strconv.ParseInt------*/

    //十进制
    var str string = "4"
    //转换成int8,int8范围-128~127
    num, err := strconv.ParseInt(str, 10, 8)
    if err != nil {
        fmt.Printf("转换失败\n")
    } else {
        fmt.Printf("%d\n", num)
        fmt.Printf("%T\n", num)
    }

    //十进制
    var str1 string = "233"
    //转换成int8,int8范围-128~127
    num1, err1 := strconv.ParseInt(str1, 10, 8)
    //233超过8位的长度，转换失败
    if err1 != nil {
        fmt.Printf("转换失败\n")
    } else {
        fmt.Printf("%d\n", num1)
        fmt.Printf("%T\n", num1)
    }

    //二进制
    var str2 string = "1001"
    //转换成int32
    num2, err2 := strconv.ParseInt(str2, 2, 32)
    if err2 != nil {
        fmt.Printf("转换失败\n")
    } else {
        fmt.Printf("%d\n", num2)
        fmt.Printf("%T\n", num2)
    }

    /*------strconv.Atoi------*/

    //10进制
    var str3 string = "9" //会转换成功
    //var str string = "9a"   //会转换失败
    num3, err3 := strconv.Atoi(str3)
    if err3 != nil {
        fmt.Printf("转换失败\n")
    } else {
        fmt.Printf("%d\n", num3)
        fmt.Printf("%T\n", num3)
    }

string-->浮点型

    var str string = "3.1234567890123456789"
    num, err := strconv.ParseFloat(str, 32)
    if err != nil {
        fmt.Printf("转换失败\n")
    } else {
        fmt.Println(num)
        fmt.Printf("%T\n", num)
    }

string-->布尔型

    //str的值可以是1、t、T、TRUE、true、True，
    //也可以是0、f、F、FALSE、false、False
    var str string = "F"
    //直接传入字符串
    flag, err := strconv.ParseBool(str)
    if err != nil {
        fmt.Printf("转换失败\n")
    } else {
        // 注意点: 在Go语言中%t输出布尔类型
        fmt.Printf("%t\n", flag) //false
        fmt.Printf("%T\n", flag) //bool
    }

基本数据类型-->string

• strconv.FormatXxx()
• strconv.iota()

整型-->string

    /*------strconv.FormatInt------*/

    var num int = 724
    //转换为10进制格式
    str := strconv.FormatInt(int64(num), 10)
    fmt.Printf("十进制：%s\n", str) //输出：724
    //转换为2进制格式
    str2 := strconv.FormatInt(int64(num), 2)
    fmt.Printf("二进制：%s\n", str2) //输出：1011010100
    //转换为16进制格式
    str16 := strconv.FormatInt(int64(num), 16)
    fmt.Printf("十六进制：%s\n", str16) //输出：2d4

    /*------strconv.Itoa------*/

    var num4 int32 = 724
    var str7 string = strconv.Itoa(int(num4))
    fmt.Printf("十进制：%s\n", str7) //输出：724

浮点型-->string

    var num2 float32 = 3.1234567890123456789
    var str3 string = strconv.FormatFloat(float64(num2), 'f', -1, 32) // "3.1234567"
    var str4 string = strconv.FormatFloat(float64(num2), 'f', -1, 64) // "3.123456789012345" 
    var str5 string = strconv.FormatFloat(float64(num2), 'f', 2, 32)  // "3.12"
    fmt.Printf("%s\n%s\n%s\n", str3, str4, str5)

bool-->string

    var flag bool = false
    var str6 string = strconv.FormatBool(flag)
    fmt.Printf("%s\n", str6) //false

time转换

注意：time不是基本类型，但是为了方便整理也放于此处。

    //获取当前时间戳，纳秒
    nanoSeconds := time.Now().UnixNano()
    fmt.Printf("当前纳秒时间戳：%d\n", nanoSeconds)
    fmt.Printf("%T\n", nanoSeconds)
    //纳秒转毫秒
    fmt.Println(nanoSeconds / 1e6)
    //纳秒转秒
    fmt.Println(nanoSeconds / 1e9)

    //获取当前时间戳，秒
    seconds := time.Now().Unix()
    fmt.Printf("当前秒时间戳：%d\n", seconds)
    fmt.Printf("%T\n", seconds)

    //将纳秒时间戳转换成时间
    t := time.Unix(0, 1573541938000*1e6) //将纳秒转换为 time 类型
    fmt.Printf("时间戳转换成时间格式：%s\n", t.String())

    //时间格式化成string
    formatStr := time.Now().Format("2006-01-02 15:04:05.000")
    fmt.Printf("时间格式化成string：%s\n", formatStr)

    //将年月日转换成时间
    yearTime := time.Date(2014, 1, 7, 5, 50, 4, 123*1e6, time.Local)
    yearUnix := yearTime.UnixNano()
    fmt.Printf("年月日转换成时间秒时间戳：%d\n", yearUnix)
    yearFormat := yearTime.Format("2006-01-02 15:04:05.000")
    fmt.Printf("年月日转换成时间：%s\n", yearFormat)

interface{}类型转换和类型断言

• 类型转换在编译期完成，包括强制转换（类型间、接口向类型、类型向接口转换）和隐式转换（类型向接口转换）
• 类型断言在运行时确定，包括安全类型断言和非安全类型断言
  Go语言要求不同类型之间必须做显式的类型转换。但似乎涉及到接口类型时，就会有所不同。

类型断言

//animal 动物
type animal interface {
    //run 跑
    run()
}

//duck 鸭子
type duck struct {
    //name 名称
    name string
    //legNum 腿的数量
    legNum int
}

func newDuck() duck {
    return duck{
        name:   "duck",
        legNum: 2,
    }
}
func (d duck) run() {
    fmt.Printf("在%d,%s跑步用%d条腿\n", time.Now().Unix(), d.name, d.legNum)
}

//cat 猫
type cat struct {
    //name 名称
    name string
    //legNum 腿的数量
    legNum int
}

func newCat() cat {
    return cat{
        name:   "cat",
        legNum: 4,
    }
}
func (c cat) run() {
    fmt.Printf("在%d,%s跑步用%d条腿\n", time.Now().Unix(), c.name, c.legNum)
}

func runWithRecover(a animal) {
    defer func() {
        fmt.Println("end")
        if err := recover(); err != nil {
            fmt.Printf("received panic ,the error is %s\n", err) // 这里的err其实就是panic传入的内容
        }
    }()
    i1 := a.(cat)
    i1.run()
}

//类型断言的方式

//typeAssert 类型断言的方式
func typeAssert() {

    //第一种
    var d animal
    d = newDuck()
    //不安全的类型断言，如果系统检测到不匹配，会在运行时调用内置的panic，抛出异常
    i := d.(duck)
    i.run()
    //由于不安全断言会抛panic
    runWithRecover(d)

    //安全的类型断言。 其中ok为一个bool值， 表征类型转换是否成功; s为返回的int变量，如果失败返回该类型的零值
    if inst, ok := d.(duck); ok {
        inst.run()
    }
    if inst, ok := d.(cat); ok {
        inst.run()
    } else {
        fmt.Printf("assert error,the error is %t\n", ok)
    }

    //第二种，type是关键字 结合switch case使用
    switch inst := d.(type) {

    case duck:

        inst.run()
    case cat:
        inst.run()
    default:

        fmt.Println("unknow")

    }
}