package main

import "fmt"

func main() {

	/*

	常量：

	1.概念：同变量类似，程序执行过程中数值不能改变

	2.语法：

		显式类型定义： const b string = "abc"

		隐式类型定义： const b = "abc"

	3.常数：

		固定的数值：100，"abc"

	 */

	fmt.Println(100)

	fmt.Println("hello")

	//1.定义常量

	const PATH string = "http:www.baidu.com"

	const PI = 3.14

	fmt.Println(PATH)

	//fmt.Println(PI)

	//2.尝试修改常量的数值

	//PATH = "http://www.sina.com" //cannot assign to PATH

	//3.定义一组常量

	const C1, C2, C3 = 100, 3.14, "haha"

	const (

		MALE   = 0

		FEMALE = 1

		UNKNOW = 3

	)

	//4.一组常量中，如果某个常量没有初始值，默认和上一行一致

	const (

		a int = 100

		b

		c string = "ruby"

		d

		e

	)

	fmt.Printf("%T,%d\n", a, a)

	fmt.Printf("%T,%d\n", b, b)

	fmt.Printf("%T,%s\n", c, c)

	fmt.Printf("%T,%s\n", d, d)

	fmt.Printf("%T,%s\n", e, e)

	//5. 枚举类型：使用常量组作为枚举类型。一组相关数值的数据

	const (

		SPRING = 0

		SUMMER = 1

		AUTUMN = 2

		WINTER = 3

	)

	// 注意：

	// 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型

	// 不曾使用的常量，在编译的时候，是不会报错的

	// 显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量是可以是不同的类型值

}

package main

import (

	"fmt"

)

func main() {

	/*

	iota：特殊的常量，可以被编译器自动修改的常量

		每当定义一个const，iota的初始值为0

		每当定义一个常量，就会自动累加1

		直到下一个const出现，清零

	 */

	const (

		a = iota // 0

		b = iota // 1

		c = iota //2

	)

	fmt.Println(a)

	fmt.Println(b)

	fmt.Println(c)

	const (

		d = iota // 0

		e        // 1

	)

	fmt.Println(d)

	fmt.Println(e)

	//枚举中

	const (

		MALE   = iota // 0

		FEMALE  // 1

		UNKNOW  // 2

	)

	fmt.Println(MALE, FEMALE, UNKNOW)

}

package main

import "fmt"

func main() {

	const (

		A = iota // 0

		B // 1

		C // 2

		D = "haha" // iota = 3

		E // haha iota = 4

		F = 100 //iota =5

		G //100 iota = 6

		H = iota // 7

		I //iota 8

	)

	const (

		J = iota // 0

	)

	fmt.Println(A)

	fmt.Println(B)

	fmt.Println(C)

	fmt.Println(D)

	fmt.Println(E)

	fmt.Println(F)

	fmt.Println(G)

	fmt.Println(H)

	fmt.Println(I)

	fmt.Println(J)

}