继续顺序编程2

2 常量
在Go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值类型（包括整型、浮点型和复数类型）、布尔类型、字符串类型等。
2.1 字面常量

所谓字面常量（literal），是指程序中硬编码的常量，如：

                  -12

                   3.14159265358979323846  // 浮点类型的常量
                   3.2+12i // 复数类型的常量
                   true // 布尔类型的常量
                  "foo"  // 字符串常量
在其他语言中，常量通常有特定的类型，比如-12在C语言中会认为是一个 int 类型的常量。
如果要指定一个值为-12的 long 类型常量，需要写成-12l，这有点违反人们的直观感觉。Go语言
的字面常量更接近我们自然语言中的常量概念，它是无类型的。只要这个常量在相应类型的值域
范围内，就可以作为该类型的常量，比如上面的常量-12，它可以赋值给 int 、 uint 、 int32 、

int64 、 float32 、 float64 、 complex64 、 complex128 等类型的变量。

   2.2 常量定义
          通过 const 关键字，你可以给字面常量指定一个友好的名字：
          const Pi float64 = 3.14159265358979323846
          const zero = 0.0 // 无类型浮点常量
         const (
               size int64 = 1024
                 eof = -1 // 无类型整型常量
                  )
           const u, v float32 = 0, 3 // u = 0.0, v = 3.0，常量的多重赋值
           const a, b, c = 3, 4, "foo"
             // a = 3, b = 4, c = "foo", 无类型整型和字符串常量
Go的常量定义可以限定常量类型，但不是必需的。如果定义常量时没有指定类型，那么它与字面常量一样，是无类型常量。常量定义的右值也可以是一个在编译期运算的常量表达式，比如
                     const mask = 1 << 3
由于常量的赋值是一个编译期行为，所以右值不能出现任何需要运行期才能得出结果的表达
式，比如试图以如下方式定义常量就会导致编译错误：
const Home = os.GetEnv("HOME")
原因很简单， os.GetEnv() 只有在运行期才能知道返回结果，在编译期并不能确定，所以
无法作为常量定义的右值。

2.3 预定义常量
       Go语言预定义了这些常量： true 、 false 和 iota 。
       iota 比较特殊，可以被认为是一个可被编译器修改的常量，在每一个 const 关键字出现时被
        重置为0，然后在下一个 const 出现之前，每出现一次 iota ，其所代表的数字会自动增1。
         从以下的例子可以基本理解 iota 的用法：
                 const (
                 c0 = iota  // c0 == 0  // iota被重设为0
                 c1 = iota  // c1 == 1

                 c2 = iota  // c2 == 2
                    )
                const (
                a = 1 << iota  // a == 1 (iota在每个const开头被重设为0)
                b = 1 << iota  // b == 2 （0001->0010 ,iota=1）

                c = 1 << iota  // c == 4  （0010->0100，iota=2）
                        )
                 const (
                 u = iota * 42             // u == 0，iota=0
                 v float64 = iota * 42 // v == 42.0,iota=1

                 w = iota * 42 // w == 84  ,iota=2
                             )
const x = iota  // x == 0 (因为iota又被重设为0了)
const y = iota  // y == 0 (同上)
如果两个 const 的赋值语句的表达式是一样的，那么可以省略后一个赋值表达式。因此，上
面的前两个 const 语句可简写为：
const ( // iota被重设为0
c0 = iota     // c0 == 0
c1              // c1 == 1
c2              // c2 == 2
)
          const (
            a = 1 <<iota     // a == 1 (iota在每个const开头被重设为0)
            b                      // b == 2
            c                      // c == 4
                  )

2.4 枚举
      枚举指一系列相关的常量，比如下面关于一个星期中每天的定义。通过上一节的例子，我们
看到可以用在 const 后跟一对圆括号的方式定义一组常量，这种定义法在Go语言中通常用于定义
枚举值。Go语言并不支持众多其他语言明确支持的 enum 关键字。
下面是一个常规的枚举表示法，其中定义了一系列整型常量：
                       const (
                                Sunday = iota
                                Monday
                                Tuesday
                                Wednesday
                                 Thursday
                                 Friday
                                Saturday
                                 numberOfDays // 这个常量没有导出
                                   )
同Go语言的其他符号（symbol）一样，以大写字母开头的常量在包外可见。
以上例子中 numberOfDays 为包内私有，其他符号则可被其他包访问。终于有时间来写go语言的笔记了，接下来开始学习go语言中的类型。