2-3 Go --- 常量
2021-07-03 本文已影响0人
捌千里路雲和月
一、什么是常量
常量通常指常规的固定值。如：一天24小时、一年有12个月、平年一年是365天、闰年一年是366天、班级里有50名学生......
二、什么使用常量
因为程序的运行，有时需要一个固定的值作为一个定值，如圆周率作为一个固定不变的值 3.1415926，防止在程序中改变这个值所以设置为常量。
三、如何使用常量
1、常量的定义和变量的定义相似，只是把 var 换成了const 关键字。
2、常量在定义的时候必须赋值，随后不能再被赋值，否则编译出错。
3、常量可以只定义不使用。
1）、只初始化常量不使用。
package main
func main() {
//定义常量关键字 const
const month int = 12 // 初始化一个名为month常量
/*常量可以只初始化不使用，没有执行打印输出也不会报错。
变量只要初始化了就要使用。*/
}
2）、常量定义一定要赋值，不然会报错。
3）、批量初始化常量
（1）、完整式 —— 批量初始化同类型常量。
package main
import "fmt"
func main() {
// 完整式 —— 批量初始化同类型常量。
const n1, n2 int = 100, 200 //初始化n1、n2。值为100，200
fmt.Println(n1,n2)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
100 200
（2）、类型推导式 —— 批量初始化同类型常量 。类型推导定义常量（变量）不用写类型。go 会判断值的的类型来设置常量（变量）的类型。
package main
import "fmt"
func main() {
// 类型推导式 —— 批量初始化同类型常量。
const n3, n4 = 300, 400 //初始化n3、n4。值为300，400
fmt.Println(n3, n4)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
300 400
（3）、类型推导式 —— 批量分段初始化多类型常量 。
package main
import "fmt"
func main() {
// 类型推导式 —— 批量分段初始化多类型常量。
const (
n5, n6 = 500, 600 //初始化n5、n6。值为500，600
s1, n7 = "s1是字符串", 700 //初始化s1、n7。值为"s1是字符串"，700
s2 = "s2也是字符串" //初始化s2。值为"s2也是字符串"
)
fmt.Println(n5, n6, s1, n7, s2)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
500 600 s1是字符串 700 s2也是字符串
也可以把分段的初始化内容写成一段：
package main
import "fmt"
func main() {
// 类型推导式 —— 批量初始化多类型常量。
//初始化n5，n6，s1，n7，s2。值为500，600，"s1是字符串"，700，"s2也是字符串"
const n5, n6, s1, n7, s2 = 500, 600, "s1是字符串", 700, "s2也是字符串"
fmt.Println(n5, n6, s1, n7, s2)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
500 600 s1是字符串 700 s2也是字符串
（4）、常量不能用简短式初始化。变量名 := 值 这种简短式只适用于初始化变量，常量的定义需要用到 const 关键字。n8 := 800 提示的报错 n8 declared but not used —— n8 已经定义，但没有使用。n8 := 800 这样的表达式被认为变量定义的报错。因为变量定义需要使用才有意义。go 不认为这是初始化常量。
（5）、const 同时定义很多个常量的时候，如果省略赋值则默认和上一行的值一样。
package main
import "fmt"
func main() {
//批量初始化常量时，如果省略了值则跟上一行的值一样。
const (
n8 = 800 // n8的值是800
n9 // n9不赋值，默认跟n8的值800
n10 //n10不赋值，默认跟n9的值800
)
fmt.Println(n8, n9, n10)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
800 800 800
当有新的常量赋值出现时，下一行不赋值的常量就会跟上一行的常量值。好像 n11赋值1100，n12不赋值，它不会跟之前一样输出800，而是跟n11的值1100。n13赋值1300，n14，n15不赋值也不跟n12一样输出1100，而是跟n13一样输出1300。
package main
import "fmt"
func main() {
//批量初始化常量时，如果省略了值则跟上一行的值一样。
const (
n8 = 800 // n8的值是800，输出800
n9 // n9不赋值，默认跟n8的值800
n10 //n10不赋值，默认跟n9的值800
n11 = 1100 //n11赋值1100，输出1100
n12 //n12不赋值，默认跟上一行n11的值1100
n13 = 1300 //n13赋值1300，输出1300
n14 //n14不赋值，默认跟上一行n13的值1300
n15 //n15不赋值，默认跟上一行n14的值1300
)
fmt.Println(n8, n9, n10)
fmt.Println(n11, n12, n13, n14, n15)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
800 800 800
1100 1100 1300 1300 1300
总之，记住批量赋值的时候，不赋值的常量就是跟上一行的值。
另外，用这种方式去初始化常量只适用于这种分段式，不能用在单行的初始化形式，因为单行的初始化形式需要左右的数目一致。左边有多少常量，右边就要对应多少值。不然会报错。
四、iota 常量累计器
1）、iota 只能在常量表达式种使用，变量表达式用 iota 会报错。
2）、const 关键字第一个常量是 iota 时值将被置为数字0。
package main
import "fmt"
func main() {
//const第一个常量是iota时，值为0。
const (
n0 = iota
)
fmt.Println(n0)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
0
3）、const 中每新增一行常量声明将使 iota 值加1。
package main
import "fmt"
func main() {
//const中每增加一行常量声明，iota自增1。
const (
n0 = iota //iota=0，n0=0
n1 /*n1不赋值，默认上一行iota，由于const新增一行常量声明iota自增 1
所以iota=1，n1=1。*/
n2 //同理，新增一行常量声明 iota 就自增1，此时iota=2，n2=2
n3 //iota=3，n3=3
)
fmt.Println(n0, n1, n2, n3)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
0 1 2 3
4）、iota作为累计器
package main
import "fmt"
func main() {
//根据const中每增加一行常量声明，iota自增1的特性。
const (
n1 = iota + 1 //iota=0,+1=1赋值给n1
n2 //通过iota自增1，+1的表达式赋值到常量，完成累加。
n3
n4
n5
n6
n7
n8
n9
n10
)
fmt.Println(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
1 2 3 4 5 6 7 8 9 10
5）、iota累减
package main
import "fmt"
func main() {
//根据const中每增加一行常量声明，iota自增1的特性。
const (
n1 = 10 - iota //iota=0，10-0赋值给n1，n1=10
n2 //iota自增1，10-1赋值给n2，n2=9
n3 //iota自增1，10-2赋值给n3，n3=8
n4 //iota自增1，10-3赋值给n4，n4=7
n5 //iota自增1，10-4赋值给n5，n5=6
n6 //iota自增1，10-5赋值给n6，n6=5
n7 //iota自增1，10-6赋值给n7，n7=4
n8 //iota自增1，10-7赋值给n8，n8=3
n9 //iota自增1，10-8赋值给n9，n9=2
n10 //iota自增1，10-9赋值给n10，n10=1
)
fmt.Println(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
10 9 8 7 6 5 4 3 2 1
6）、中间插队为常量赋值，iota仍会继续执行。
package main
import "fmt"
func main() {
//给常量赋值，只要新增常量，iota仍会执行自增。
const (
n1 = iota //iota=0赋值给n1，n1=0
n2 //iota自增1赋值给n2，n2=1
n3 //iota自增1赋值给n3，n3=2
n4 = 400 //n4赋值400，n4=400。iota自增1，iota=3
n5 //n5没有赋值，跟上一行n4的值。n5=400，iota自增1，iota=4
n6 //n6没有赋值，跟上一行n5的值。n6=400，iota自增1，iota=5
n7 = 700 //n7赋值700，n7=700。iota自增1，iota=6
n8 //n8没有赋值，跟上一行n7的值。n8=700，iota自增1，iota=7
n9 = iota //iota自增1赋值给n9，n9=8
n10 //n10没有赋值，跟上一行n9的值。n9=8，iota自增1，iota=9
)
fmt.Println(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
0 1 2 400 400 400 700 700 8 9
7）、const创建常量的时候就可以用 iota。每次 const 出现时，都会让 iota 初始化为0。
package main
import "fmt"
func main() {
const (
a = iota // const 后跟的是 iota，iota 初始化为0
)
fmt.Println(a)
const (
b = iota // 另一个 const 出现，后面跟的也是 iota。iota 初始化为0
c
)
fmt.Println(b, c)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
0
0 1
8）、const（）括号批量创建常量的时候，每创建一个常量，iota就会自增1，也就是累加。所以，随时把常量赋值为iota，iota都能显示出当前的累计数。如下面的例子最后一个常量n10赋值 iota，iota显示出当前累加值。也可以证明批量创建常量的时候，iota已经根据常量的数量进行累加计算。
package main
import "fmt"
func main() {
//给常量赋值，只要新增常量，iota仍会执行自增。
const (
n1 = 100 //n1=100,ioto=0
n2 = 200 //n2=200,ioto=1
n3 = 300 //n3=300,ioto=2
n4 = 400 //n4=400,ioto=3
n5 = 500 //n5=500,ioto=4
n6 = 600 //n6=600,ioto=5
n7 = 700 //n7=700,ioto=6
n8 = 800 //n8=800,ioto=7
n9 = 900 //n9=900,ioto=8
n10 = iota //iota自增1，iota=9
)
fmt.Println(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
100 200 300 400 500 600 700 800 900 9
赋值 和 iota的关系：
1、常量指定赋值，显示赋值。iota 也会累加。
2、常量指定iota，显示iota值。
3、常量不赋值，上一层有赋值则跟上一层赋值。上一层是iota则显示本层累加的iota值。
9）、有时不想要的 iota 值，可以用 _ 下划线进行跳过。
package main
import "fmt"
func main() {
//跳过iota。
const (
n0 = iota //ioto=0
n2 //ioto=1
_ //跳过
n4 //ioto=3
_ //跳过
n6 //ioto=5
_ //跳过
n8 //ioto=7
_ //跳过
n10 //ioto=9
)
fmt.Println("单号:", n2, n4, n6, n8, n10)
const (
n1 = iota //ioto=0
_ //跳过
n3 //ioto=2
_ //跳过
n5 //ioto=4
_ //跳过
n7 //ioto=6
_ //跳过
n9 //ioto=8
_ //跳过
)
fmt.Println("双号:", n1, n3, n5, n7, n9)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.3> go run .\main.go
单号: 1 3 5 7 9
双号: 0 2 4 6 8
