变量：

变量是计算机语言中能储存特定类型计算结果或能表示特定类型值的抽象概念

声明变量及变量赋值：

go语言中声明变量有多种方法，声明单个变量最基本语法如下：

var 变量名称 变量类型

例如：

var a int//声明一个int类型的变量

以上的代码声明了一个int类型的变量a，但是没有给变量a赋值，go会自动给变量初始化，会给变量a赋值int类型的零值0，使用=可以给变量赋值

package main
import "fmt"
func main() {
    var a int
    fmt.Println(a)//会输出0
}

在声明变量时也可以不指定变量类型，当声明变量时同时给变量初始化，go语言可以自动推断具有初始值的变量类型

var a = 12//自动推断出变量a的类型为int

go中声明变量还有一种简便写法，使用:=声明变量，该方式只能出现在函数体中，语法如下

变量名称:=变量值

该简便写法要求:=左边的变量必须有初始值，而且左边的变量必须有未声明的变量

package main
import "fmt"
func main() {
    var b
    a := 12//简便方式声明变量并进行初始化
    b := 1//变量b已经声明过，所以此处会报错 no new variables on left side of :=
    fmt.Println(a,b)
}

go语言中可以通过一条语句声明多个变量，语法如下：

var 变量1,变量2... 变量类型

通过这种方法声明的变量，指定了变量类型，所以声明的变量都是同一种类型。省略变量类型并给变量进行初始化，可以通过go的自动推断变量的类型

package main
import "fmt"
func main() {
    var a,b int = 1,2//同时声明了两个int类型的变量并进行初始化
    fmt.Println(a,b)
    var aa,bb = "12aaa",5//同时声明了两个变量，变量aa类型为string，变量bb类型为int
    fmt.Println(aa,bb)
}

使用:=的简便方法也可以一次声明多个变量，简便方法声明多个变量必须进行初始化，并且左边的变量至少有一个是未声明的变量

package main
import "fmt"
func main() {
    a,b := 1,"b"//同时声明了两个变量并进行初始化
    fmt.Println(a,b)//输出1 b
    
    //同时声明了三个个变量，变量cc未初始化会报错assignment mismatch: 3 variable but 2 values
    //aa,bb,cc := "12aaa",5
    
    a,b,c := 2,"bb",4//可以运行，虽然变量a和b是已经声明过的变量，但是变量c是未声明的变量，要注意已经声明过的变量类型不能改变
    fmt.Println(a,b,c)//输出2 bb 4
}

go中还有另一种一次声明多个变量的方法，并且可以声明不同类型的变量，这种方法多用于声明全局变量

package main
import "fmt"
//该方式中如果不给变量初始化需要指定变量类型，该方式中不能用简便写法:=
var(
    a = 1
    b string = "b"
    c int
    d = true
)

func main() {
    fmt.Println(a,b,c,d)
}

特殊变量"_"：
go语言中，下划线是一个特殊的变量也称作空白标识符(匿名变量)，代表忽略的变量。匿名变量不占用命名空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用

package main
import "fmt"
func main() {
    //调用test()函数，最后一个返回值忽略掉
    a,b,_ := test()
    fmt.Println(a,b)//输出1 true
}

//返回三个不同类型返回值的函数
func test()(int,bool,string){
    a,b,c := 1,true,"c"
    return a,b,c
}

变量的可见性规则：
大写字母开头的变量是公有变量；
小写字母开头的变量是私有变量；

常量：

常量一般用于表示固定的值，并且在程序运行时，是不会被修改的量
常量存储的位置在数据区，常量不能使用&获取地址访问；变量存储于栈区，栈区，系统为每一个应用程序分配1M空间存变量，程序运行结束后自动释放

声明常量及常量赋值：

go中常量的数据类型只能是布尔型、数字型（整数型、浮点型和复数）和字符串型，常量的声明格式如下

const 常量名 常量类型 = 常量值//该方式称为常量的显示定义
或
const 常量名 = 常量值//该方式称为常量的隐式定义

常量的声明也可以一行语句声明多个统一类型常量

const 常量1,常量2... 常量类型 = 常量1的值,常量2的值
或
const 常量1,常量2 = 常量1的值,常量2的值

一次性生成多个不同类型常量语法如下

const(
  常量1 常量类型 = 常量值
  常量2 常量类型 = 常量值
  ...
)

常量在声明后无法重新给常量赋值，会报错cannot assign to xxx

package main
import "fmt"
func main() {
    const a = 6
    a = 7//常量不能重新赋值，报错cannot assign to a
    fmt.Println(a)
}

特殊常量iota:

iota是一个特殊的常量，可以认为是一个可以被编译器修改的常量，只能在常量中使用，不能在函数体中使用；iota相当于枚举，多用于生成一组相似规则初始化的常量；iota在const关键字出现时将被重置为0(const内部的第一行之前)；const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)；

package main
import "fmt"
const (
    a = iota//此时a的值为iota的默认值0
    //每当iota在新的一行使用时，值都会加1
    b = iota
    c = iota
)
const d = iota//iota在const关键字出现时将被重置为0
func main() {
    fmt.Println(a,b,c,d)//输出0 1 2 0
    
}

在const总iota每增一行值就加1，不管两个iota中间是否有其他不是iota的常量

package main
import "fmt"
const (
    a = iota//此时a的值为iota的默认值0
    _//匿名变量,忽略该变量
    b = "bbb"
    c = iota//未有新的const关键字，iota在新的一行使用时，值都会加1，所以c的值为3
)
func main() {
    fmt.Println(a,b,c)//输出0 bbb 3
}

定义iota常量时，写在同一行的值相同，换行的值加一

package main
import "fmt"
func main(){
    const(
        a=iota
        b,c=iota,iota//定义iota常量时，写在同一行的值相同，换行的值加一
        d,e
    )
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
    fmt.Println(e)
}

iota常用法：
1.跳值使用法：

package main
import "fmt"
const (
    a = iota//此时a的值为iota的默认值0
    _//匿名变量,忽略该变量
    b = iota//未有新的const关键字，iota在新的一行使用时，值都会加1，所以b的值为2
)
func main() {
    fmt.Println(a,b)//输出0 2
}

2.插队使用法

package main
import "fmt"
const (
    a = iota//此时a的值为iota的默认值0
    //iota不管两个iota中间是否有其他不是iota的常量
    b = "bbb"
    c = iota//未有新的const关键字，iota在新的一行使用时，值都会加1，所以c的值为2
)
func main() {
    fmt.Println(a,b,c)//0 bbb 2
}

3.表达式隐式使用法
package main
import "fmt"
const (
a = iota//a=0
b//b=1
c//c=2
)
const (
aa = iota + 1//iota默认值为0，aa=0+1
bb//默认使用上一行表达式，并且iota遇到新的一行加1，bb=1+1
cc = iota//新的一行，iota加1，cc=2
dd
)
func main() {
fmt.Println(a,b,c)//输出0 1 2
fmt.Println(aa,bb,cc,dd)//1 2 2 3
}
4.单行使用法
使用默认上一行表达式，需要与上一行格式对应，例如上一行如果是声明两个常量，下一行也需要声明两个，这样才能默认使用上一行表达式，否则会报错extra expression in const declaration

package main
import "fmt"
const (
    a,b = iota,iota + 1//同属于一行，iota不增加，a=0，b=1
    c,d//默认使用上一行表达式，iota加1，c=1,d=1+1
    e = iota//e=2,前面都是多个常量，此时如果声明一个常量需要显式赋值，因为无法应用默认上一行表达式，会报错
)
func main() {
    fmt.Println(a,b,c,d,e)//输出0 1 1 2 2
}

5.生成枚举值
go语言中没有枚举，可以使用iota模拟枚举

package main
import "fmt"
//模拟枚举
const (
    turnRight = iota//生成枚举值，iota默认值为0
    turnLeft
    goStraight
)
func main() {
    fmt.Print("右转：")
    fmt.Println(turnRight)
    fmt.Print("左转：")
    fmt.Println(turnLeft)
    fmt.Print("直行：")
    fmt.Println(goStraight)
    /*
    输出
    右转：0
    左转：1
    直行：2
    */
}