Golang 常量

相對於變量, 常量是恆定不變的值, 常常用於定義程序運行期間不會改變的那些值.

常量的定義使用

常量的聲明與變量的聲明很類似, 只是把 var 換成了 const, 常量在定義的時候必須賦值.

在程序開發中, 咱們用常量存儲一直不會發生變化的數據. 例如: Π， 身份證號碼等. 像這類數據, 在整個程序運行中都是不容許發生改變的.

package main

import "fmt"

func main(){
    const pi float64 = 3.14159
    // pi = 4.56  // 報錯, 常量不容許修改
    fmt.Println(pi)

    // 自動推導類型
    const e = 2.7182  // 注意: 不是使用 :=
    fmt.Println("e =", e)
}

在聲明瞭 pi 和 e 這兩個變量以後, 在整個程序運行期間它們的值就都不能發生變化了.

多個常量同時聲明

const (
	pi = 3.14159
    e = 2.7182
)

const 同時聲明多個常量時, 若是省略了值則表示和上面一行的值是相同的.

const (
	n1 = 99
    n2  // n2 = 99
    n3  // n3 = 99
)

上面的示例中, 常量 n1、n2、n3 都是99.

字面常量

所謂字面常量, 是指程序中硬編碼的常量.

123  // 整數類型的常量
3.14159  // 浮點類型的常量
3.2+12i  // 複數類型的常量
true  // 布爾類型的常量
"foo"  // 字符串類型的常量

iota 枚舉

iota 是go語言的常量計數器, 只能在常量的表達式中使用. 它用於生成一組以類似規則初始化的常量, 可是不用每一行都寫一遍初始化表達式.

注意：在一個const聲明語句中, 在第一個聲明的常量所在的行, iota 將會被置爲0, 而後在每個有常量聲明的行加一.

iota 能夠理解爲const語句塊中的行索引, 使用iota能簡化定義, 在定義枚舉時頗有用.

看幾個例子:

能夠只寫一個iota

package main

import "fmt"

func main(){
	const (
		a = iota  // 0
		b  // 1
		c  // 2
		d  // 3
	)
	fmt.Println(a, b, c, d)
}

iota 遇到 const, 會重置爲 0

package main

import "fmt"

func main(){
	const (
		a = iota
		b
		c
		d
	)
	fmt.Println(a, b, c, d)
    // iota遇到const, 會重置爲0
	const e = iota  // 0
	fmt.Println(e)
}

使用 _ 跳過某些值

package main

import "fmt"

func main(){
	const (
		a = iota  // 0
		_
		c  // 2
		d  // 3
	)
	fmt.Println(a, c, d)
}

iota 聲明中間插隊

package main

import "fmt"

func main(){
	const (
		a = iota  // 0
		b = 100  // 100
		c = iota  // 2
		d  // 3
	)
	fmt.Println(a, b, c, d)
}

常量寫在同一行, 其值相同, 換一行值+1

package main

import "fmt"

func main() {
	// 常量寫在同一行, 其值相同, 換一行值+1
	const(
		a = iota  // 0
		b, c = iota, iota  // 1, 1
		d, e  // 2, 2
		f, g, h = iota, iota, iota  // 3, 3, 3
		i, j, k  // 4, 4, 4
	)
	fmt.Println(a)
	fmt.Println(b, c)
	fmt.Println(d, e)
	fmt.Println(f, g, h)
	fmt.Println(i, j, k)
}

能夠爲其賦初始值, 可是換行後不會根據值+1, 而是根據 行 +1.

package main

import "fmt"

func main(){
    const (
    	a = 6  // 6
        b, c = iota, iota  // 1 1
        d, e  // 2 2
        f, g, h = iota, iota, iota  // 3 3 3
        i, j, k  // 4 4 4
    )
	fmt.Println(a)
	fmt.Println(b, c)
	fmt.Println(d, e)
	fmt.Println(f, g, h)
	fmt.Println(i, j, k)
}

若是一行中賦值的初始值不同, 則下一行的值與上一行相等.

package main

import "fmt"

func main(){
    const (
    	a, b = 1, 6  // 1 6
        c, d  // 1 6
        e, f, g = 2, 8, 10  // 2 8 10
        h, i, j  // 2 8 10
    )
    fmt.Println(a, b)
    fmt.Println(c, d)
    fmt.Println(e, f, g)
    fmt.Println(h, i, j)
}

若是一行中既有賦初始值, 又有iota, 則下一行中對應初始值的位置的值不變, 對應 iota 位置的值+1.

package main

import "fmt"

func main(){
    const (
    	a, b, c = 3, iota, iota  // 3 0 0
        d, e, f  // 3 1 1
        g, h, i = iota, 16, iota  // 2 16 2
        j, k, l  // 3 16 3
    )
    fmt.Println(a, b, c)
    fmt.Println(d, e, f)
    fmt.Println(g, h, i)
    fmt.Println(j, k, l)
}

當對 iota 進行加減操做時, 下一行也進行一樣操做

package main

import "fmt"

func main(){
    const (
		a, b = iota+5, iota-2  // 5 -2
		c, d  // 6 -1
	)
	fmt.Println(a, b)
	fmt.Println(c, d)
}

定義數量級

package main

import "fmt"

func main(){
    const (
    	_ = iota
        KB = 1 << (10 * iota)  // 1024
        MB = 1 << (10 * iota)
        GB = 1 << (10 * iota)
        TB = 1 << (10 * iota)
        PB = 1 << (10 * iota)
    )
    fmt.Println(KB, MB, GB, TB, PB)
}

這裏的 << 表示左移操做, 1<<10 表示將1的二進制表示向左移10位, 也就是由1變成了10000000000, 也就是十進制的1024.

同理, 2<<3 表示將2的二進制表示向左移3位, 也就是由10變成了10000, 也就是十進制的16

李培冠博客

lpgit.com