go语言基本动作练习＜三＞

package main

import "fmt"

const c1 string = "2021年4月9日"
const c2 = "2021年4月9日" //和变量一样，常量也可以不使用数据类型直接赋值，其类型和值一致

const c3, c4 = "2021年4月9日", "2021年4月9日"

const (
	c5 = "2021年4月9日"
	c6 = "2021年4月9日"
)

type Weekday int //自定义一个星期类型，作为枚举类型

const (
	Sun Weekday = iota
	Mon
	Tues
	Wed
	Thur
	Fri
	Sat
)

func main() {
	test27()
}


//1. 单常量定义
//常量定义的形式为 const 常量名 常量类型 = 常量值
func test18()  {
	fmt.Println(c1)
	fmt.Println(c2)
}

//2. 多常量定义
//2.1 普通方式
//和 Go 语言的变量一样，常量也可以进行多常量定义。定义形式为const 常量名,常量名= 常量值,常量值。
func test19()  {
	fmt.Println(c3)
	fmt.Println(c4)
}

//2.2 特殊方式
//在常量的使用中，Go 语言还提供了一种特殊的多常量定义方式——const()。这种定义方式也是比较推荐的常量使用方式。
func test20()  {
	fmt.Println(c5)
	fmt.Println(c6)
}

//枚举类型用于声明一组命名的常量，当一个变量有几种可能的取值时，可以将它定义为枚举类型。在 Go 语言中，并没有提供枚举类型，但是枚举类型又是开发过程中非常重要的数据类型。因为它可以事先定义一组有效的值，可以有效地防止用户提交无效数据，抽象到业务场景中就是我们平时网页上遇到的下拉框，或者我们选择快递地址时的省市信息，均为枚举类型的用武之地。所以在 Go 语言中对常量进行了一定的扩展，使其可以完美地替代枚举类型
//1.常量中的iota
//为了使常量可以更好地替代枚举类型，Go 语言提供了一个iota关键字。使用iota初始化常量，可以生成一组规则类似的常量，但是不用每个常量都写一遍表达式。在一个const()表达式中，从iota开始的常量会被置为0，向后每个常量的值为前一个常量的值加一。
func test21()  {
	fmt.Println("Sun :", Sun)
	fmt.Println("Mon :", Mon)
	fmt.Println("Tues:", Tues)
	fmt.Println("Wed :", Wed)
	fmt.Println("Thur:", Thur)
	fmt.Println("Fri :", Fri)
	fmt.Println("Sat :", Sat)
}

//1. Go 语言的算数运算符
//Go语言中的算数运算符如表所示：
//
//运算符	结合性	描述
//+	从左到右	运算符左边的实体加上右边的实体
//-	从左到右	运算符左边的实体减去右边的实体
//*	从左到右	运算符左边的实体乘以右边的实体
///	从左到右	运算符左边的实体除以右边的实体
//%	从左到右	运算符左边的实体对右边的实体取余
//++	从右到左	左边的变量使用后自加一
//–	从右到左	左边的变量使用后自减一
func test22()  {
	var a = -7
	var b = 4

	fmt.Println("a + b =", a+b)
	fmt.Println("a - b =", a-b)
	fmt.Println("a * b =", a*b)
	fmt.Println("a / b =", a/b)
	fmt.Println("a % b =", a%b)

	//++和--只能独立为一条语句使用
	a++
	fmt.Println("a++:", a)
	b--
	fmt.Println("b--:", b)
}

//2. Go 语言的关系运算符
//Go语言中的关系运算符如表所示：
//
//运算符	结合性	描述
//==	从左到右	左右两边实体相等运算结果为true,否则为false
//!=	从左到右	左右两边实体不等运算结果为true,否则为false
//>=	从左到右	左边的实体大于或等于右边运算结果为true,否则为false
//>	从左到右	左边的实体大于右边运算结果为true,否则为false
//<=	从左到右	左边的实体小****于或等于右边运算结果为true,否则为false
//<	从左到右	左边的实体小于右边运算结果为true,否则为false
func test23()  {
	var a = -7
	var b = 4

	fmt.Println("a == b :", a == b)
	fmt.Println("a != b :", a != b)
	fmt.Println("a >= b :", a >= b)
	fmt.Println(" a > b :", a > b)
	fmt.Println("a <= b :", a <= b)
	fmt.Println(" a < b :", a < b)
}

//3. Go 语言的逻辑运算符
//Go语言中的逻辑运算符如表所示：
//
//运算符	结合性	描述
//&&	从左到右	左右实体均为 true 运算结果为 true ,否则为 false
//||	从左到右	左右实体均为 false 运算结果为 false ,否则为 true
//！	从右到左	右边实体为 false 运算结果为 true ，否则为 false
func test24()  {
	var a = true
	var b = false

	fmt.Println("a && b :", a && b)
	fmt.Println("a || b :", a || b)
	fmt.Println("    !a :", !a)
}

//Go 语言的位运算符如表所示：
//
//运算符	结合性	描述
//&	从左到右	按位与
//|	从左到右	按位或
//^	从左到右	按位异或
//<<	从左到右	左位移
//>>	从左到右	右位移
func test25()  {
	var a = 28 //0001 1100
	var b = 99 //0110 0011
	fmt.Println(" a & b :", a&b)  //0 : 0000 0000
	fmt.Println(" a | b :", a|b)  //127 : 0111 1111
	fmt.Println(" a ^ b :", a^b)  //127 : 0111 1111
	fmt.Println("a >> 2 :", a>>2) //7 : 0000 0111
	fmt.Println("b << 1 :", b<<1) //198 : 1100 0110
}

//5.Go 语言的赋值运算符
//Go语言赋值运算符如下表所示：
//
//运算符	结合性	描述
//=	从右到左	将左边的实体赋值给右边的变量
//+=	从右到左	将右边的变量与左边的实体进行加运算之后赋值给右边的变量
//-=	从右到左	将右边的变量与左边的实体进行减****运算之后赋值给右边的变量
//*=	从右到左	将右边的变量与左边的实体进行乘运算之后赋值给右边的变量
///=	从右到左	将右边的变量与左边的实体进行除运算之后赋值给右边的变量
//%=	从右到左	将右边的变量与左边的实体进行取余运算之后赋值给右边的变量
//>>=	从右到左	将右边的变量与左边的实体进行右位移运算之后赋值给右边的变量
//<<=	从右到左	将右边的变量与左边的实体进行左位移运算之后赋值给右边的变量
//&=	从右到左	将右边的变量与左边的实体进行与运算之后赋值给右边的变量
//|=	从右到左	将右边的变量与左边的实体进行或运算之后赋值给右边的变量
//^=	从右到左	将右边的变量与左边的实体进行异或运算之后赋值给右边的变量
func test26()  {
	var a = 28
	var b = 99
	a = b
	fmt.Println("  a = b :", a)
	a = 28
	a += b
	fmt.Println(" a += b :", a)
	a = 28
	a -= b
	fmt.Println(" a -= b :", a)
	a = 28
	a *= b
	fmt.Println(" a *= b :", a)
	a = 28
	a /= 2
	fmt.Println(" a /= 2 :", a)
	a = 28
	b %= 1
	fmt.Println(" b %= 1 :", a)
	a = 28
	a &= b
	fmt.Println(" a &= b :", a)
	a = 28
	a |= b
	fmt.Println(" a |= b :", a)
	a = 28
	a ^= b
	fmt.Println(" a ^= b :", a)
	a = 28
	a >>= 2
	fmt.Println("a >>= 2 :", a)
	a = 28
	b <<= 1
	fmt.Println("b <<= 1 :", a)
}


//6. 优先级
//下表为各运算符的优先级示图，优先级从高到低：
//
//优先级	类别	运算符
//1	括号运算符	()
//2	单目运算符	！、++、–
//3	算数运算符	*、/、%
//4	+、-
//5	位移运算符	>>、<<
//6	关系运算符	<、<=、>、>=
//7	==、!=
//8	按位与	&
//9	按位异或	^
//10	按位或	|
//11	逻辑与	&&
//12	逻辑或	||
//13	赋值运算符	=、+=、-=、*=、/=、 %=、 >=、 <<=、&=、^=、|=
func test27()  {
	var a = 28
	var b = 99
	fmt.Println("  a + b * 2 =", a+b*2)   //乘法优先级较高，先执行乘法
	fmt.Println("(a + b) * 2 =", (a+b)*2) //括号优先级最高，先执行括号中的运算
}```