关键字和保留字

GO语言中一共有25个关键字：
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
GO语言中还有37个保留字：

Constants:    true  false  iota  nil
    Types:    int  int8  int16  int32  int64  
              uint  uint8  uint16  uint32  uint64  uintptr
              float32  float64  complex128  complex64
              bool  byte  rune  string  error
Functions:   make  len  cap  new  append  copy  close  delete
             complex  real  imag
             panic  recover

变量的声明方式

GO语言中声明变量的方式其关键字为 var，

var name string

name为变量名，而string为GO语言中事先被定义好的变量类型，其还有int类型和bool类型等。
看到这，作为一名前端的我，倍感熟悉，这不是JavaScript中声明变量的方式吗，没想到在GO语言中也被这样定义了，我怀疑GO语言开发团队中是不是有前端大佬，才会这样定义。

标准声明

var name string
var age int
var top bool

在GO语言中可以这样单个声明变量，但是在需求很多时，这样就会很繁琐，于是就有了下面的声明方式。

批量声明

var （
  name string
  age int
  top bool
）

在GO语言中支持这样批量的声明变量，var关键字配合小括号即可。内部就是变量名 跟其变量的类型。

变量的初始化

GO语言在声明变量的时候，会自动对变量对应的内存区进行初始化操作，每个变量会被初始化成其类型所自带的默认值。比如整数和浮点数类型的变量他们的默认值就是0。字符串类型的默认值是""。布尔类型的默认值是false。

直接声明并赋值

GO语言中可以在声明变量的同时直接把值赋给这个变量，也可以同时声明多个变量赋值多个值，格式规范一一对应。

var name string = "泰戈尔"
var age int = 22
var name, age = "泰戈尔", 22

通过这种直接声明并赋值或者同时声明多个变量并且赋予多个值的方式，可以提高开发的效率。

类型推导

var s2 = "20"

类型推导，根据变量的值去反向推导其变量所属的类型。

简短变量声明

s3 := "ed"
age := 22
name := "泰戈尔"

简短变量声明，在go语言中，只要是在函数内，我们就可以使用这种方式去声明变量并赋值。(不能在函数外使用)。

匿名变量

func fun()(string, int, string){
    return "han", 22, "fmale"
}

func main(){
    var person, _, _ = fun()
    fmt.Println(person)

    var _, iAge, _ = fun()
    fmt.Println(iAge)

    var _, _, ssex = fun()
    fmt.Println(ssex)
}

上面的函数传入了三个不同类型的变量类型作为参数，return了三个对应类型的值，
接着下面的main函数内分别声明了三个变量名并且调用了上面的函数，这里相当于将上面的fun函数的返回值赋值给了main函数内部的三个对应着的变量。
第一个只有person被正常声明，其余两个都使用匿名声明的方式选择忽略了对应的值，下面同理。_表示占位符，即忽略某个值。所以其运行结果都是每次声明赋值后只打印了被正常声明并赋值的变量的值。
运行结果：

han
22
fmale

常量的声明方式

GO语言中不仅可以声明变量还可以声明常量，常量就是被声明后无法改变的值。声明常量的关键字是const。

标准声明常量

const name = "泰戈尔"
const age = 22

批量声明常量

const (
   name = "泰戈尔"
   age = 22
)

批量声明常量的继承

const (
   name = "泰戈尔"
   name1
   name2
)

在批量声明常量时，如果只有一个常量被正常赋值，那么其他的未正常声明的常量将会继承正常声明的常量的值。所以这里name1和name2的值都是"泰戈尔"。如下图。

iota

iota是GO语言中的常量计数器，只能在常量的表达式中使用。
iota在const关键字出现时被重置为0，const中每新增一行常量的声明将使iota计数一次，也可以将他理解为const语句块中的行索引。

const (
   n1 = iota
   n2
   n3
   n4
)

上述结果为：0，1，2，3

还有几个常见的iota的示例

使用_跳过某些值

const (
    n1 = iota //0
    n2        //1
    _
    n4        //3
)

iota声明中间插队

const (
    n1 = iota //0
    n2 = 100  //100
    n3 = iota //2
    n4        //3
)
const n5 = iota //0

多个iota被定义在同一行

const (
    a, b = iota + 1, iota + 2 //1,2
    c, d                      //2,3
    e, f                      //3,4
)

END

GO语言的变量和常量就总结到这里了。