2-2 Go --- 变量的初始化

变量的初始化:在定义变量的同时给变量赋值。相当变量的定义 和 变量赋值二合为一。初始化变量的几种方法:

一、完整的方法，变量定义和变量赋值分开写：
优点：结构清晰。

package main

import "fmt"

func main() {
    //  1、定义和赋值分开写
    var n1 int // 定义变量
    n1 = 100   // 变量赋值

    //  打印 n1 值
    fmt.Println("1、定义和赋值分开写 n1= ", n1)
}


//输出结果：
PS C:\Users\86186\go\src\chapter2\2.2> go run .\main.go
1、定义和赋值分开写 n1=  100

---

二、类型推导：根据值的类型自动推导出变量类型。
优点：定义变量不用写类型 并且 直接赋值，格式简化。

package main

import "fmt"

func main() {

    /*n2没有指定什么类型，右边的值200是 int类型。
    根据值的类型推导变量 n2定义为 int类型。*/
    var n2 = 200

    /*s1没有指定什么类型，右边的值"这是类型推导的例子"是 string类型。
    根据值的类型推导变量s1定义为 string类型。*/
    var s1 = "这是类型推导的例子"

    //  打印 n2 值
    fmt.Println("2、类型推导 n2= ", n2, ",s1= ", s1)
}

//输出结果：
PS C:\Users\86186\go\src\chapter2\2.2> go run .\main.go
2、类型推导 n2=  200 ,s1=  这是类型推导的例子

---

三、简短式：类型推导的升级版。把变量 var关键字也省去，但要用 := 进行赋值。
优点：格式更加简化。

package main

import "fmt"

func main() {
    // 简短式不用写变量 var关键字，但要用英文符号 := 赋值。
    n3 := 300

    //  打印 n3 值
    fmt.Println("3、简短式 n3=", n3)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.2> go run .\main.go
3、简短式 n3= 300

---

以上是单个变量的初始化，下面是批量初始化变量。

四、完整方法的批量变量初始化。
缺点：仅支持同类型变量。

package main

import "fmt"

func main() {
    //完整方法的批量变量初始化
    var n4, n5, n6 int = 400, 500, 600 // 定义多个变量 并 赋值

    //  打印 n4,n5,n6 值
    fmt.Println("n4=", n4, ",n5=", n5, ",n6=", n6)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.2> go run .\main.go
n4= 400 ,n5= 500 ,n6= 600

---

五、稍作改变，var（）括号内范围可以批量初始化多种类型的变量。既可以批量初始化多个变量，也支持多个类型。多变量和多数值之间用，逗号隔开。

package main

import "fmt"

func main() {
    //var()括号内范围可以批量初始化多种类型的变量。
    var (
        n7, n8 int    = 700, 800 // 定义多个变量 并 赋值
        s1     string = "s1是字符串"
    )

    //  打印 n7,n8,s1 值
    fmt.Println("n7=", n7, ",n8=", n8, ",s1=", s1)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.2> go run .\main.go
n7= 700 ,n8= 800 ,s1= s1是字符串

---

六、类型推导批量初始化多种类型的变量。
优点：定义多个变量不用一个一个写类型， go 根据值的类型自动推导出变量类型。并且可以 直接赋值，格式简化。（注意：左边变量数目和右边数值的数目要一致）

package main

import "fmt"

func main() {
    //左边 var跟变量名，右边是对应变量的值。
    var n9, n10, s2 = 900, 1000, "s2是字符串"// 定义多个变量 并 赋值

    //  打印 n9,n10,s2 值
    fmt.Println("n9=", n9, ",n10=", n10, ",s2=", s2)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.2> go run .\main.go
n9= 900 ,n10= 1000 ,s2= s2是字符串

---

七、简短式批量初始化多种类型的变量，类型推导的升级版。var 关键字也不用写，变量 := 值 就可以完成初始化，更加简约。

package main

import "fmt"

func main() {
    //简短式批量初始化多种类型的变量，不用写 var关键字，赋值用 :=
    n11, n12, s3 := 1100, 1200, "s3也是字符串" // 定义多个变量 并 赋值

    //  打印 n9,n10,s2 值
    fmt.Println("n11=", n11, ",n12=", n12, ",s3=", s3)
}
PS C:\Users\86186\go\src\chapter2\2.2> go run .\main.go
n11= 1100 ,n12= 1200 ,s3= s3也是字符串

---

tips:
1、简短式的变量赋值，无论是单个变量初始化还是批量初始化。只支持函数体内部，不支持函数体外部。因为这种形式并没有 var 作为创建变量的关键字。函数体外用简短式会报 expected declaration 等待声明变量的错误。

完整式和类型推导有 var 关键字开头定义变量的，可以在函数体外定义变量、赋值。

package main

import "fmt"

// 函数体外用类型推导方式进行变量的批量初始化
var n11, n12, s3 = 1100, 1200, "函数体外初始化"

func main() {

    //  打印 n9,n10,s2 值
    fmt.Println("n11=", n11, ",n12=", n12, ",s3=", s3)
}

//输出结果：
PS C:\Users\86186\go\src\chapter2\2.2> go run .\main.go
n11= 1100 ,n12= 1200 ,s3= 函数体外初始化

2、整个过程下来应该很多情况下都会选择简约方便的简短式变量赋值或初始化。从最完整的格式开始过度到简短式可以了解其中的变化和要点。对于不同场景和不同人的理解都是一个支撑点，找到对自己最容易理解内容的学习方式最重要。