1.变量的创建方法

Go 语言是静态类型语言，由于编译时，编译器会检查变量的类型，所以要求所有的变量都要有明确的类型。

Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号

Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字

变量在使用前，需要先声明。声明类型，就约定了你这个变量只能赋该类型的值。

声明一般有以下四种方法，其中前面两种同样也可用于定义常量，只需把关键字 var 变成 const 即可

1.1 一行声明一个变量

var <name> <type> //如果没有初始化，默认是零值

其中var是关键字，name是变量名，type是类型

var name string = "编程时光"

在 Python 双引号与单引号等价，但在 Go 中双引号和单引号是不一样的，这里要一定要使用双引号，表示字符串，而在单引号表示rune 类型的字符

若你的右值带有小数点，在不指定类型的情况下，编译器会将你的这个变量声明为 float64，但是很多情况下，我们并不需要这么高的精度,这种情况下，推荐指定类型

var rate float32 = 0.89

1.2 多个变量一起声明

1.3 声明和初始化单个变量

此方法声明变量只能用于函数内部

1.4 声明和初始化多个变量

name, age := "wangbm", 28 //:=的左侧必须是新的变量，如果没有声明新的变量，就产生编译错误

1.5 new函数声明一个指针变量

变量分为两种 普通变量 和 指针变量
普通变量，存放的是数据本身，而指针变量存放的是数据的地址。

package main

import "fmt"

func main()  {
    var age int = 28  //age是普通变量，存放的是内容28
    var ptr = &age  // &后面接变量名，表示取出该变量的内存地址，ptr是指针变量，存放变量age值的内存地址
    fmt.Println("age: ", age)
    fmt.Println("ptr: ", ptr)
}

使用表达式 new(Type) 将创建一个Type类型的匿名变量，初始化为Type类型的零值，然后返回变量地址，返回的指针类型为*Type。

如下两种写法，可以说是等价的：

// 使用 new
func newInt() *int {
    return new(int)
}

// 使用传统的方式
func newInt() *int {
    var dummy int
    return &dummy
}

以上不管哪种方法，变量/常量都只能声明一次，声明多次，编译就会报错。
但也有例外，这就要说到一个特殊变量：匿名变量，也称作占位符，或者空白标识符，用下划线表示
匿名变量，优点有三：
1、不分配内存，不占用内存空间
2、不需要你为命名无用的变量名而纠结
3、多次声明不会有任何问题

通常我们用匿名接收必须接收，但是又不会用到的值。

2、常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

const identifier [type] = value
const c_name1, c_name2 = value1, value2
const (
    Unknown = 0
    Female = 1
    Male = 2
)

常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：

package main

import "unsafe"
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

func main(){
    println(a, b, c)
}

iota常量
这是特殊常量，是可以被编译器修改的常量
iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)
iota 可以被用作枚举值：

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

实例：

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}
//output
0 1 2 ha ha 100 100 7 8

package main

import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}
//output
i= 1
j= 6
k= 12
l= 24