go语言学习【三】

目录如下：
1. 标识符
2. 运算符
3. 键盘输入语句
4.if-else分支
5.switch分支

1.go语言中的标识符：

1. 只能由英文字母（a-z / A-Z）、数字（0-9）、下划线（_）组成。
2. 标识符严格区分英文大小写。
3. 标识符不能以数字开头
4. 标识符不能包含空格
5. 不能使用单个 下划线（_）作为标识符。
6. 不能使用系统关键字作为标识符，例如：if、int、break等等。

2.运算符（用以表示数据的运算、赋值和比较）：

1. 算数运算符
2. 赋值运算符
3. 关系运算符
4. 逻辑运算符
5. 位运算符
6. 其它运算符

1. 算数运算符
1） 对于除号（/）：整数之间做除法只保留整数部分，不存在四舍五入。例如：x：=23 / 6，结果是 3
2）取模运算 (%)：a % b 等价于 a - a / b * b
3）Golang的自增自减只能当作独立语言使用。不能使用：b := a++
4）Golang中只有 a++,没有 ++a。（++和–只能写在变量的后面）
简单题目：

//假设还有97天放假，输出还有xx个星期零几天
package main
import "fmt"
func main() {
	var dateTime int = 97
	var weekDay int
	var day int
	weekDay = dateTime/7  
	day = dateTime%7
	fmt.Printf("%v个星期零%v天",weekDay,day)
}

2. 赋值运算符
赋值运算符的运算是从右到左运算
交换 a,b 的值

//方法一：使用中间变量
t := a
a = b
b = t

//方法二：直接赋值运算
a = a + b
b = a - b // ==>这一步就是 b = a
a = a - b // ==> a = a + b -a = b

3. 关系运算符
1）关系运算符的结果都是bool类型，要么是true,要么是false。
2）关系运算符中 “==” 不能误写成 “=”（前者代表判断，后者代表赋值）

4 > 5 //表示为假，即为false

4. 逻辑运算符
逻辑与（&&）同时为真则为真
逻辑或（ || ）同时为假则为假
逻辑非（ ！）！true = false
注：&&也叫短路与，如果第一个条件为false，则第二个条件不会判断，最终结果为false。
|| 也叫短路或，如果第一个条件为true，则第二个条件不会判断，最终结果为true。

package main
import "fmt"
func test() bool {
    fmt.Println("test")
    return true
}
func main() {
    var i int = 10
	if i<9 && test() {
		fmt.Println("ok")
	}
}
//输出结果为空，因为 i<9 为false，因此后面的 test() 就不执行

//判断闰年
package main
import "fmt"
func main() {
    var year int = 2024
	if (year % 4 == 0 && year % 100 != 0)|| year % 400 == 0 {
		fmt.Printf("%v年是闰年",year)
	} else {
		fmt.Println("不是闰年！")
	}
	} //输出结果是：2024年是闰年

运算符优先级顺序：

6. 其它运算符
指针 *，地址&

3. 键盘输入语句

1）使用 fmt.Scanln() 获取 【只读取一行数据】
2）使用 fmt.Scanf() 获取

4. if-else分支

基本语法：

 if 条件表达式 {
      执行代码块1
   } else {
   执行代码块2
   }

注：{} 是必须有的，就算只有一行代码也要写 {} 。
嵌套分支最好控制在三层以内，否则代码可读性较差。

简单例题：

//1.比较三个数的大小，数字由键盘输入
package main
import "fmt"
func main() {
    var a,b,c,max int
	fmt.Println("请输入a,b,c的值：")
    fmt.Scanf("%d %d %d",&a,&b,&c)
   if a>b {
	   max=a
   } else {
	   max=b
   }
   if c>max {
	   max=c
   }
   fmt.Printf("a,b,c中的最大值是:%v", max)
	}

输出结果是：

请输入a,b,c的值：
18 24 52
a,b,c中的最大值是:52

//2.求方程ax2 + bx + c = 0的根
package main
import (
	"fmt"
	"math"
)
func main() {
    var a,b,c float64
	fmt.Scanf("%f %f %f",&a,&b,&c)
    m := b*b - 4*a*c 
	//多分支判断方程是否有解
	if m>0 {
		x1 := (-b + math.Sqrt(m))/(2*a)
		x2 := (-b - math.Sqrt(m))/(2*a)
		fmt.Printf("x1=%v x2=%v",x1,x2)
	} else if m==0 {
		x := (-b + math.Sqrt(m))/(2*a)
		fmt.Printf("x=%v",x)
	} else {
		fmt.Println("无解")
	}
	}

输出结果是：

3.0 3.0 -6.0
x1=1 x2=-2

/*3.出票系统：根据淡旺季的月份和年龄，打印票价
 4-10 旺季：
    成人（18-60）：60
	儿童（ <18 ）: 半价
	老人（ >60 ）: 全价的1/3
淡季：
    成人：40
    其他：20	

*/
package main
import (
	"fmt"
	_"math" //忽略math包
)
func main() {
   var month int 
   fmt.Println("请输入游玩月份：")
   fmt.Scanln(&month)
   var age int
   fmt.Println("请输入游客年龄：")
   fmt.Scanln(&age)
   var price int = 60
   if month>=4 && month <=10 {
	   if age > 60 {
       fmt.Printf("票价为：%v",price/3)
	   } else if age >= 18 {
		fmt.Printf("票价为：%v",price)
	   } else {
		fmt.Printf("票价为：%v",price/2)
	   }
   } else {
	   if age>=18 && age <=60 {
		fmt.Println("票价为:40")
	   } else {
		fmt.Println("票价为:20")
	   }
   }
	}

输出结果是：

请输入游玩月份：
9
请输入游客年龄：
72
票价为：20

5.switch分支

基本介绍：
1）switch语句用于基于不同条件执行不同动作，每一个case分支都是唯一的，从上到下逐一测试，直到匹配为止。
2）匹配项后面不需要再加break，当程序执行完case语句块后，就会直接退出该switch控制结构。
基本语法：

switch 表达式 {
case 表达式1，表达式2，...:  //Golang里的case语句可以执行多个表达式，使用 逗号 隔开
       语句块1
case 表达式3，表达式4，...:
       语句块2
       //可以有多个case语句
default:  //若case语句里的表达式都不执行，执行default里的语句
     语句块       
}

switch 简单案例：

/*
请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d,e,f,g
a表示星期一，b表示星期二···根据用户的输入显示相应的信息
*/
package main
import "fmt"
func main() {
	var ch byte
	fmt.Println("请输入a,b,c,d,e,f,g中的一个字符：")
    fmt.Scanf("%c",&ch) //输入字符需要指定格式
  switch ch {
  case 'a' :
	fmt.Println("星期一")
  case 'b' :
	fmt.Println("星期二")
  case 'c' :
	fmt.Println("星期三")
  case 'd' :
	fmt.Println("星期四")
  case 'e' :
	fmt.Println("星期五")
  case 'f' :
	fmt.Println("星期六")
  case 'g' :
	fmt.Println("星期天")
  default:
	fmt.Println("输入有误！")
  }
	}

输出结果是：

请输入a,b,c,d,e,f,g中的一个字符：
d
星期四

switch使用细节
1）case后是一个表达式（即：常量值、变量、一个有返回值的函数等都可以）
2）case后的各个表达式值的数据类型，必须和 switch 的表达式数据类型一致。
3）case后面的表达式如果是常量值（字面量），则要求不能重复。
4）default 语句不是必须的。
5）switch后也可以不带表达式，类似 if-else 分支来使用。

	var age int
	fmt.Scan(&age)
switch { // switch后没有表达式，{}里面的内容相当于 if-else
    case age == 10 :
    fmt.Println("age=10")
	case age == 20 :
	fmt.Println("age=20")
	default :
	fmt.Println("无")
   }

6）switch 后也可以直接声明/定义一个变量，分号结束。（不推荐这样使用）

switch grade := 90; {
   case grade >= 90 :
	fmt.Println("成绩优秀")
}

7）switch穿透 fallthrough ,如果在case语句块后增加 fallthrough ，则会继续执行下一个case。（默认只穿透一层）
8）Type Switch：switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际指向的变量类型。

package main
import "fmt"
func main() {
   var x interface{} 
   var y = 10.0
   x = y
   switch x.(type) { //用来判断 x 这个空接口指向哪种数据类型
   case int :
	fmt.Println("x 是 int 型")
   case float64 :
	fmt.Println("x 是 float64 型")
   case bool,string :
	fmt.Println("x 是 bool 或 string 类型")
	default :
	fmt.Println("x 是未知型")
   }
}

输出结果是：

x 是 float64 型