Golang 常量

最新推荐文章于 2024-08-19 19:55:55 发布

李培冠

最新推荐文章于 2024-08-19 19:55:55 发布

阅读量8.4k

点赞数

分类专栏： Golang 文章标签：编程语言 go golang 后端

本文链接：https://blog.youkuaiyun.com/qq_33555334/article/details/107771566

版权

Golang 专栏收录该内容

32 篇文章

订阅专栏

本文介绍了Golang中的常量定义，包括通过`const`关键字声明常量，使用字面常量以及利用`iota`进行枚举。详细阐述了`iota`的工作原理，如何在常量声明中进行计数，并给出了多个示例来说明其用法。最后，提到了常量在程序开发中的应用场景，如存储固定不变的数据。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

相对于变量, 常量是恒定不变的值, 经常用于定义程序运行期间不会改变的那些值.

常量的定义使用

常量的声明与变量的声明很相似, 只是把 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)
}