常量

常量由关键字const定义，用于存储不会改变的数据，形式如下：

  1. const identifier [type] = value
  2. //    常量的定义形式

Go语言中可以省略说明符【type】，因为编译器可以根据变量的值来判断类型：

  • 显式类型定义： const b string = “abc”
  • 隐式类型定义： const b = “abc”

常量的值必须是能够在编译时就能够确定的；你可以在其赋值表达式中涉及计算过程，但是所有用于计算的值必须在编译期间就能获得。

  • 正确的做法：const c1 = 2/3
  • 错误的做法：const c2 = getNumber() // 引发构建错误: getNumber() used as value

因为在编译期间自定义函数均属于未知，因此无法用于常量的赋值，但内置函数可以使用，如：len()。
反斜杠 \ 可以在常量表达式中作为多行的连接符使用。常量允许使用并行赋值方式：

  1. const beef, two, c = "eat", 2, "veg"
  2. const Monday, Tuesday, Wednesday, Thursday, Friday, Saturday = 1, 2, 3, 4, 5, 6
  3. const (
  4.     Monday, Tuesday, Wednesday = 1, 2, 3
  5.     Thursday, Friday, Saturday = 4, 5, 6
  6. )

常量还可用作枚举：

  1. const (
  2.     a = iota
  3.     b = iota
  4.     c = iota
  5. )
  6. //    第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1
  7. const (
  8.     a = iota
  9.     b = iota
  10.     c = iota
  11. )
  13. //    没有赋值的常量默认会应用上一行的赋值表达式
  14. // 赋值一个常量时，之后没赋值的常量都会应用上一行的赋值表达式
  15. const (
  16.     a = iota  // a = 0
  17.     b         // b = 1
  18.     c         // c = 2
  19.     d = 5     // d = 5   
  20.     e         // e = 5
  21. )
  23. // 赋值两个常量，iota 只会增长一次，而不会因为使用了两次就增长两次
  24. const (
  25.     Apple, Banana = iota + 1, iota + 2 // Apple=1 Banana=2
  26.     Cherimoya, Durian                  // Cherimoya=2 Durian=3
  27.     Elderberry, Fig                    // Elderberry=3, Fig=4
  29. )
  31. // 使用 iota 结合 位运算 表示资源状态的使用案例
  32. const (
  33.     Open = 1 << iota  // 0001
  34.     Close             // 0010
  35.     Pending           // 0100
  36. )
  38. const (
  39.     _           = iota             // 使用 _ 忽略不需要的 iota
  40.     KB = 1 << (10 * iota)          // 1 << (10*1)
  41.     MB                             // 1 << (10*2)
  42.     GB                             // 1 << (10*3)
  43.     TB                             // 1 << (10*4)
  44.     PB                             // 1 << (10*5)
  45.     EB                             // 1 << (10*6)
  46.     ZB                             // 1 << (10*7)
  47.     YB                             // 1 << (10*8)
  48. )
  49. /*
  50. iota 也可以用在表达式中，如：iota + 50。在每遇到一个新的常量块或单个常量声明时， 
  51. iota 都会重置为 0（ 简单地讲，每遇到一次 const 关键字，iota 就重置为 0 ）。
  52. */

变量

声明变量的一般形式是使用var关键字：var identifier type
Go声明变量时将变量的类型放在名称之后，这是为了避免C语言那种容易被误解的声明形式：int* a, b;
而如果想把a和b都声明为指针类型：

  1. var a, b *int // 这种语法能够按照从左至右的顺序阅读，使得代码更加容易理解
  2. //
  3. var a int
  4. var b bool
  5. var str string
  6. //    也可以写成如下形式
  7. var (
  8.     a int
  9.     b bool
  10.     str string
  11. )

Go语言中变量默认值如下：
int 为 0，float32(64) 为 0.0，bool 为 false，string 为空字符串，指针为 nil。记住，所有的内存在 Go 中都是经过初始化的。Go语言中变量被声明后，系统会赋值默认值。

Go语言的变量命名规则遵循驼峰命名法，即单个单词小写，每个新单词的首字母也大写：numShips，startDate。如果希望全局变量可以被外部包所使用，则需将首个单词的首字母也大写。

尽管变量的标识符必须是唯一的，但你可以在某个代码块的内层代码块中使用相同名称的变量，则此时外部的同名变量将会暂时隐藏（结束内部代码块的执行后隐藏的外部同名变量又会出现，而内部同名变量则被释放），你任何的操作都只会影响内部代码块的局部变量。

  1. /*
  2.  Go 编译器的智商已经高到可以根据变量的值来自动推断其类型，
  3.  这有点像 Ruby 和 Python 这类动态语言，只不过它们是在运行时进行推断，
  4.  而 Go 是在编译时就已经完成推断过程。
  5.  因此，你还可以使用下面的这些形式来声明及初始化变量
  6. */
  7. var a = 15
  8. var b = false
  9. var str = "Go says hello to the world!"

当在函数体内声明局部变量时，应使用简短声明语法 :=

  1. a := 1