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

常量的聲明

常量的聲明使用關鍵字 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

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

下面的例子，因為函數調用發生在運行時，所以不能將函數的返回值賦值給常量。

package main

import (
 "fmt"
 "math"
)

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

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

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
)

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

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

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)
}

上面程序的輸出結果如下：

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

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

無類型常量

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

iota 常量生成器

iota 特殊常量，可以認為是一個可以被編譯器修改的常量。常量聲明可以使用 iota 常量生成器初始化，它用于生成一組以相似規則初始化的常量，但是不用每行都寫一遍初始化表達式。在一個 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

如果出現另一個 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 重新計數, 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