在 Go 語言中， 常量 表示的是固定的值，常量表達式的值在編譯期進行計算，常量的值不可以修改。例如：3 、 Let's go 、 3.14 等等。常量中的數(shù)據(jù)類型只可以是 布爾型 、 數(shù)字型 （整數(shù)型、浮點型和復數(shù)）和 字符串型 。

常量的聲明

常量的聲明使用關(guān)鍵字 const ：

const < name > < type > = < expression >
const < name > = < expression >

多個相同類型的聲明可以寫成：

const < name1 >, < name2 > = < expression1 >, < expression2 >

下面是一個聲明常量的例子：

package main

import "fmt"

func main() {
 const a int = 10
 const b = "Let's go"
 fmt.Println("a = ", a)
 fmt.Println("b = ", b)
 // a = 12 // error
}

運行該程序輸出如下：

a =  10
b =  Let's go

因為常量不能修改，如果把最后一行的注釋去掉，編譯會出錯。

下面的例子，因為函數(shù)調(diào)用發(fā)生在運行時，所以不能將函數(shù)的返回值賦值給常量。

package main

import (
 "fmt"
 "math"
)

func main() {
 var a = math.Abs(-1.2)
 // const b = math.Abs(-3.1) // error
 fmt.Println(a)
}

當然，和變量聲明一樣，常量也可以一組一起聲明，這比較適合聲明一組相關(guān)的常量：

const (
    e  = 2.71828182845904523536028747135266249775724709369995957496696763
    pi = 3.14159265358979323846264338327950288419716939937510582097494459
)

如果是一次聲明一組常量，除了第一個外，其它常量右邊的初始化表達式都可以省略，如果省略初始化表達式則表示使用前面常量的初始化表達式寫法，對應的常量類型也一樣的。例如：

package main

import (
 "fmt"
)

const (
 num1 = 1
 num2
 num3 = 2
 num4
)

func main() {
 fmt.Println("num1 = ", num1)
 fmt.Println("num2 = ", num2)
 fmt.Println("num3 = ", num3)
 fmt.Println("num4 = ", num4)
}

上面的程序輸出為：

num1 =  1
num2 =  1
num3 =  2
num4 =  2

同樣的，一組常量一起聲明可以用作枚舉：

const (
    Monday = 1
    Tuesday = 2
    Wednesday = 3
    Thursday = 4
    Friday = 5
    Saturday = 6
    Sunday = 7
)

當然，后面還有更好的枚舉寫法。

常量間的所有算術(shù)運算、邏輯運算和比較運算的結(jié)果也是常量，對常量的類型轉(zhuǎn)換操作或以下函數(shù)調(diào)用都是返回常量結(jié)果：len() 、 cap() 、 real() 、 imag() 、 complex() 和 unsafe.Sizeof() 。注意在常量表達式中，函數(shù)必須是內(nèi)置函數(shù)，否則編譯不通過。

package main

import (
 "fmt"
 "unsafe"
)

func main() {
 const (
  a = "Let's go"
  length = len(a)
  size = unsafe.Sizeof(a)
 )

 fmt.Println("a = ", a)
 fmt.Println("length = ", length)
 fmt.Println("size = ", size)
}

上面程序的輸出結(jié)果如下：

a =  Let's go
length =  8
size =  16

當然，你可能對最后一行的輸出有些疑惑，為什么 size 大小是 16 ，這里解釋一下， size 指的是類型的大小，此處為字符串類型大小，字符串類型在 Go 中是一個結(jié)構(gòu)，包含指向底層數(shù)組的指針和長度，這兩部分每部分都是 8 個字節(jié)，所以字符串類型大小為 16 個字節(jié)，所以輸出為 16 。

無類型常量

Go 中的常量有個不同尋常之處。雖然一個常量可以有任意一個確定的基礎類型，但是許多常量并沒有一個明確的基礎類型。這里有六種未明確類型的常量類型，分別是 無類型的布爾型 、 無類型的整數(shù) 、 無類型的字符 、 無類型的浮點數(shù) 、 無類型的復數(shù) 、 無類型的字符串 。

iota 常量生成器

iota 特殊常量，可以認為是一個可以被編譯器修改的常量。常量聲明可以使用 iota 常量生成器初始化，它用于生成一組以相似規(guī)則初始化的常量，但是不用每行都寫一遍初始化表達式。在一個 const 聲明語句中，在第一個聲明的常量所在的行， iota 將會被置為 0 ，然后在每一個有常量聲明的行加一。iota 可以被用作枚舉值：

package main

import (
 "fmt"
)

const (
 Sunday int = iota
 Monday
 Tuesday
)

func main() {
 fmt.Println("Sunday = ", Sunday)
 fmt.Println("Monday = ", Monday)
 fmt.Println("Tuesday = ", Tuesday)
}

上面的程序輸出為：

Sunday =  0
Monday =  1
Tuesday =  2

如果出現(xiàn)另一個 const 聲明語句， iota 將會重新置為 0 ：

package main

import (
 "fmt"
)

const (
 a = iota    // iota = 0
 b           // iota = 1
 c           // iota = 2
 d = "go"    // go, iota = 3
 e           // 和上一行一樣為 go, iota = 4
 f = 100     // 100, iota = 5
 g           // 和上一行一樣為 100, iota = 6
 h = iota    // iota = 7
 i           // iota = 8
)

const (
 j = iota    // iota 重新計數(shù), iota = 0
 k           // iota = 1
)

func main() {
 fmt.Println("a = ", a)
 fmt.Println("b = ", b)
 fmt.Println("c = ", c)
 fmt.Println("d = ", d)
 fmt.Println("e = ", e)
 fmt.Println("f = ", f)
 fmt.Println("g = ", g)
 fmt.Println("h = ", h)
 fmt.Println("i = ", i)
 fmt.Println("j = ", j)
 fmt.Println("k = ", k)
}

程序輸出如下：

a =  0
b =  1
c =  2
d =  go
e =  go
f =  100
g =  100
h =  7
i =  8
j =  0
k =  1