3、常量

1.概念:

同变量类似，程序执行过程中数值不能改变

2.语法:

• 显式类型定义
• 隐式类型定义

/**
 * @author ly (个人博客:https://www.cnblogs.com/qbbit)
 * @date 2023/9/4  20:58
 * @tags 喜欢就去努力的争取
 */
package main

import (
	"fmt"
	"unsafe"
)

// 当然，常量也是可以定义到全局位置的
const (
	S1 = "Spring"
	S2 = "SpringMVC"
	M  = "Mybatis"
)
const (
	NO_USE = "未使用的常量"
)
func main() {
/**
常量是一个简单值的标识符，在程序运行时，不会被修改的量。
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
*/

// 常量的定义格式
// const identifier [type] = value

// 注意:常量名一般使用大写
const LENGTH int = 20
const WIDTH int = 10
var area int
const a, b, c = 1, false, "str" // 多重赋值

area = LENGTH * WIDTH

fmt.Printf("面积s为：%d \n", area)
fmt.Printf("a:%d \t b:%t \t c:%s \n", a, b, c)

// LENGTH = 30 // 当我们重复定义LENGTH 就会出现：Cannot assign to LENGTH

// 定义一组常量
const (
	MALE    = 0
	FEMALE  = 1
	UNKNOWN = 3
)
// 上面的这种定义有点类似Java里面的枚举
fmt.Printf("MALE:%d \t FEMALE:%d \t UNKNOWN:%d \n", MALE, FEMALE, UNKNOWN)

const (
	SPRING = 0
	SUMMER = 1
	AUTUMN = 2
	WINTER = 3
)
fmt.Printf("SPRING类型为：%T , 值为：%d \n", SPRING, SPRING)
fmt.Printf("SUMMER类型为：%T , 值为：%d \n", SUMMER, SUMMER)
fmt.Printf("AUTUMN类型为：%T , 值为：%d \n", AUTUMN, AUTUMN)
fmt.Printf("WINTER类型为：%T , 值为：%d \n", WINTER, WINTER)

// 一组常量中如果一个常量没有初始值，默认和上一行一致
const (
	a1 int = 20
	b1
	c1 string = "ly"
	d
	e float32 = 2.3
	f
	g bool = true
	h
	i bool = false
	j
)
fmt.Printf("a1类型为：%T , 值为：%d \n", a1, a1)
fmt.Printf("b1类型为：%T , 值为：%d \n", b1, b1)
fmt.Printf("c1类型为：%T , 值为：%s \n", c1, c1)
fmt.Printf("d类型为：%T , 值为：%s \n", d, d)
fmt.Printf("e类型为：%T , 值为：%f \n", e, e)
fmt.Printf("f类型为：%T , 值为：%f \n", f, f)
fmt.Printf("g类型为：%T , 值为：%t \n", g, g)
fmt.Printf("h类型为：%T , 值为：%t \n", h, h)
fmt.Printf("i类型为：%T , 值为：%t \n", i, i)
fmt.Printf("j类型为：%T , 值为：%t \n", j, j)

// 常量可以用len(), cap(), unsafe.Sizeof()常量计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不通过
const (
	X = "hello go"
	Y = len(X)
	Z = unsafe.Sizeof(a)
)
println(X, Y, Z)
fmt.Printf("X:%d \t Y:%d \t Z:%d \n", X, Y, Z)

// 输出全局常量
fmt.Printf("S1:%s \t S2:%s \t M:%s \n", S1, S2, M)
}

3.常量的注意事项:

• 常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型
• 不曾使用的常量，在编译的时候，是不会报错的
• 显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量是可以是不同的类型值

4.iota

/*
	iota，特殊的常量，可以认为是一个可以被编译器修改的常量
		每定义一个常量const iota的初始值为0
		接下来再定义一个常量，就会自动累加1
		直到下一个const iota出现，清零
*/
const (
		x1 = iota
		y1 = iota
		z1 = iota
	)
	fmt.Println(x1, y1, z1) // 0 1 2

	// 上面的写法等价于下面的写法
	const (
		x2 = iota
		y2
		z2
	)
	fmt.Println(x1, y1, z1) // 0 1 2

	const (
		l = iota
		m
		n = "ly"
		o
		p = 100
		q
		r = iota
		s
		t = iota
	)
	const (
		// 清零
		u = iota
	)
	fmt.Printf("l类型为：%T , 值为：%d \n", l, l)
	fmt.Printf("m类型为：%T , 值为：%d \n", m, m)
	fmt.Printf("n类型为：%T , 值为：%s \n", n, n)
	fmt.Printf("o类型为：%T , 值为：%s \n", o, o)
	fmt.Printf("p类型为：%T , 值为：%d \n", p, p)
	fmt.Printf("q类型为：%T , 值为：%d \n", q, q)
	fmt.Printf("r类型为：%T , 值为：%d \n", r, r)
	fmt.Printf("s类型为：%T , 值为：%d \n", s, s)
	fmt.Printf("t类型为：%T , 值为：%d \n", t, t)
	fmt.Printf("u类型为：%T , 值为：%d \n", u, u)

	// 枚举值
	const (
		MALE1 = iota
		FEMALE1
		UNKNOWN1
	)
	fmt.Printf("MALE1类型为：%T , 值为：%d \n", MALE1, MALE1)
	fmt.Printf("FEMALE1类型为：%T , 值为：%d \n", FEMALE1, FEMALE1)
	fmt.Printf("UNKNOWN1类型为：%T , 值为：%d \n", UNKNOWN1, UNKNOWN1)

	// 玩一个iota的小例子
	const (
		n1 = 1 << iota
		n2 = 3 << iota
		n3
		n4
	)
	fmt.Println("n1:", n1) // n1: 1
	fmt.Println("n2:", n2) // n2: 6
	fmt.Println("n3:", n3) // n3: 12
	fmt.Println("n4:", n4) // n4: 24

	/*
		iota表示从0开始自动加1，所以i=1<<0,j=3<<1（<<表示左移的意思），即：i=1,j=6，这没问题，关键在k和l，从输出结果看，k=3<<2，l=3<<3。
		简单表述:
		i=1：左移 0 位，不变仍为 1。
		j=3：左移 1 位，变为二进制 110，即 6。
		k=3：左移 2 位，变为二进制 1100，即 12。
		l=3：左移 3 位，变为二进制 11000，即 24。
		注：<<n==*(2^n)。
	*/