相对于变量, 常量是恒定不变的值, 经常用于定义程序运行期间不会改变的那些值.
常量的定义使用
常量的声明与变量的声明很相似, 只是把 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