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