一、变量

Go是静态类型，不能在运行期改变变量的类型。

面试题

关于全局变量的初始化，下面正确的使用方式是
A、var i int = 10
B、var i = 10
C、i := 10

这是一个关于Go语言全局变量声明和赋值的考察，Go语言中的变量声明使用关键字var，例如:

var str string    //声明变量
str = "test"      //给变量赋值

这边var是定义变量的关键字，str是变量名称，string是变量类型，=是赋值符号，”test”是值。上面的程序分两步，第一步声明变量，第二步给变量赋值。也可以将两步合到一起。

var str string = "test"

使用关键字 var 定义变量，自动初始化为零值。如果提供初始化值，可省略变量类型，由编译器自动推断:

var str = "test"

Go语言还提供了一种更简短的写法：

str := "test"

相当于先执行了var str string定义了str变量，再执行str = “test”的赋值操作。

Go语言全局变量不支持在函数外进行赋值，如:

var str string  //定义了一个全局变量str
str = "test"    //全局变量不支持这种操作

因此，全局变量不支持 str := “test”操作，此方法只支持局部变量操作。

func main() {
    x := 123 // 注意检查，是定义新局部变量，还是修改全局变量。该⽅  >方式容易造成错误。
 }

可一次定义多个变量：

var x, y, z int
var s, n = "abc", 123
var (
    a int
    b float32
)
func main() {
  i, s := 123, "Hello, World!"
  println(x, s, n)
}

多变量赋值时，先计算所有相关值，然后再从左到右依次赋值。

data, i := [3]int{0, 1, 2}, 0
i, data[i] = 2, 100 // (i = 0) -> (i = 2), (data[0] = 100)

全局变量还支持若某个变量需要依赖其它变量，则被依赖的变量先初始化

var test1 = test2
var test2 = "test2"

二、常量

常量值必须是编译期可确定的数字、字符串、布尔值。

const x, y int = 1, 2 // 多常量初始化
const s = "Hello, World!" // 类型推断
const ( // 常量组
  a, b = 10, 100
  c bool = false
)

Go语言中当定义一个局部变量未使用会编译错误，但是局部常量未使用不会引发编译错误。

在常量组中，如不提供类型和初始化值，那么视作与上一常量值相同。

const (
  s = "abc"
  x           // x = "abc"
)

常量值还可以是 len、cap、unsafe.Sizeof 等编译期可确定结果的函数返回值。

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

如果常量类型足以存储初始化值，那么不会引发溢出错误。

const (
  a byte = 100 // int to byte
  b int = 1e20 // float64 to int, overflows
)

面试题:

对于常量定义zero(const zero = 0.0)，zero是浮点型常量，这一说话时候正确。(false)

Go语言常量有个不同寻常的地方，虽然一个常量可以有任意一个确定的类型，例如int或float64，但是很多常量却并没有一个明确的基础类型，编译器为这些没有明确的基础类型的数字变量提供了比基础类型更高的算术运算。有六种未明确类型的变量类型，分别是无类型的布尔型，无类型的整数，无类型的字符，无类型的浮点数，无类型的复数，无类型的字符串。

枚举

关键字 iota 定义常量组中从 0 开始按行计数的自增枚举值。

const (
  Sunday = iota // 0
  Monday // 1，通常省略后续⾏行表达式。
  Tuesday // 2
  Wednesday // 3
  Thursday // 4
  Friday // 5
  Saturday // 6
)

const (
  _ = iota // iota = 0
  KB int64 = 1 << (10 * iota) // iota = 1
  MB // 与 KB 表达式相同，但 iota = 2
  GB
  TB
)
MB,GB,TB会表达式与KB相同，都为1<<(10 * _)，但是iota会自增

同样的道理:

const (
    i =1<<iota //
    j=3<<iota
    k
    l)

  i = 1,j=6,k=12,I=24。

iota每出现一次，自动加1；而前面的操作数如果不指定，默认使用上一个的，在这里是3。则k=3<<2，I=3<<3。

如果 iota ⾃自增被打断，须显式恢复。

const (
  A = iota // 0
  B // 1
  C = "c" // c
  D // c，与上⼀一⾏行相同。
  E = iota // 4，显式恢复。注意计数包含了 C、D 两⾏行。
  F // 5
)
需要注意的是E=4，显式恢复。