运算符+流程控制+包+函数

运算符

运算符是一种特殊的符号，用于表示数据的运算、赋值和比较等

算数运算符

算术运算符是对数值类型的变量进行运算的

细节说明

1. 对于除号 ‘/’ ，他的他的整数和小数除是由区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如：x := 19/5 结果是3
2. 当对一个数取模时，可以等价 a%b = a - a/b*b
3. Golang的自增自减只能当作一个独立使用
4. Golang的++和–只能在变量的后面使用

赋值运算符

两数交换，不允许使用中间变量

	a := 10
	b:= 7
	a = a+b
	b = a-b
	b = a-b

比较运算符

逻辑运算符

位运算符

其他运算符

优先级

键盘输入语句

1. fmt.Scanln()

	var name string
	var age  int
	var salary float64
	var isPass bool

	println("姓名：")
	fmt.Scanln(&name)
	println("年龄：")
	fmt.Scanln(&age)
	println("薪资：")
	fmt.Scanln(&salary)
	println("是否通过考试：")
	fmt.Scanln(&isPass)

	fmt.Printf("姓名 %s ，年龄 %d ，薪资 %f ，是否通过考试 %t",name,age,salary,isPass)

2. fmt.Scanf()

	var name string
	var age  int
	var salary float64
	var isPass bool

	fmt.Scanf("%s %d %f %t",&name,&age,&salary,&isPass)

	fmt.Printf("姓名 %s ，年龄 %d ，薪资 %f ，是否通过考试 %t",name,age,salary,isPass)

流程控制

分支控制

if-else if-else

if 条件表达式1{
} else if 条件表达式2{
}
...
else{
}

switch

switch 表达式{
	case 表达式1,表达式2:
		语句块1
	case 表达式2,表达式3:
		语句块2
	...
	default:
		默认语句块
}

匹配项后面不需要加 break 语句
细节

1. switch后可以不带表达式，类似于if-else分支来使用
2. switch后可以直接声明/定义一个变量，分号结束，不推荐
3. switch穿透-fallthrough，如果在case语句块后增加fallthrough，会继续执行下一个case
4. case表达式 可以是一个范围
5. Type Switch：switch语句还可以被用于type-switch来判断某个interface变量实际指向的变量类型
6. switch demo

/*
1. 使用switch把小写类型的char型转为大写（键盘输入）
	只转换abcde，其他输出other
*/
func demo1() {
	var input byte
	fmt.Printf("请输入：")
	fmt.Scanf("%c",&input)
	switch int(input) {
		case 97:
			fmt.Printf("%c",65)
		case 98:
			fmt.Printf("%c",66)
		case 99:
			fmt.Printf("%c",67)
		case 100:
			fmt.Printf("%c",68)
		case 101:
			fmt.Printf("%c",69)
		default:
			fmt.Println("other")

	}
}

/*
2. 对学生成绩 大于60分 输出合格，低于60分，输出不合格
	（输入成绩不能大于100）
*/
func demo2(){
	var input float64
	fmt.Printf("请输入：")
	fmt.Scanf("%f",&input)
	switch {
	case input > 100:
		fmt.Println("输入成绩不能大于100")
	case input >= 60:
		fmt.Println("合格")
	case input >= 0:
		fmt.Println("不和格")
	default:
		fmt.Println("input inValid")

	}
}
/*
3. 根据用户指定月份，打印该月份所属的季节。
	345春季，678夏季，9，10，11秋季，12，1，2冬季
*/
func demo3(){
	var input int
	fmt.Printf("请输入：")
	fmt.Scanf("%d",&input)
	switch input{
	case 3,4,5:
		fmt.Println("春季")
	case 6,7,8:
		fmt.Println("夏季")
	case 9,10,11:
		fmt.Println("秋季")
	case 1,2,12:
		fmt.Println("冬季")

	default:
		fmt.Println("input inValid")

	}
}
/*
4. 根据用户输入显示对应的星期时间（string），
		如果"星期一"，显示 "干煸豆角"
		如果"星期二"，显示 "醋溜土豆"
		如果"星期三"，显示 "红烧狮子头"
		如果"星期四"，显示 "油炸花生米"
		如果"星期五"，显示 "蒜蓉扇贝"
		如果"星期六"，显示 "东北乱炖"
		如果"星期日"，显示 "大盘鸡"
*/
func demo4(){
	var input string
	fmt.Printf("请输入：")
	fmt.Scanf("%s",&input)
	switch input{
	case "星期一":
		fmt.Println("干煸豆角")
	case "星期二":
		fmt.Println("醋溜土豆")
	case "星期三":
		fmt.Println("红烧狮子头")
	case "星期四":
		fmt.Println("油炸花生米")
	case "星期五":
		fmt.Println("蒜蓉扇贝")
	case "星期六":
		fmt.Println("东北乱炖")
	case "星期日":
		fmt.Println("大盘鸡")
	default:
		fmt.Println("input inValid")

	}
}

循环控制

for循环控制

• 基本语法

// 1
for i := 0; i < 10; i++ {
		println("hello world")
	}
// 2	
i := 0
	for i < 10 {
		println("hello world")
		i++
	}
// 3
i := 1
	for   {
		println("hello world")
		if i == 10 {
			break
		}
		i++
	}

• 遍历字符串

// 1 传统方式 便利汉字会有字符编码问题
str:= "hello world"
	for i := 0; i < len(str); i++ {
		fmt.Printf("%c \n",str[i])
	}
// 2 
str:= "hello world"
	for index, item := range str {
		fmt.Printf("index :%d ,item : %c \n",index,item)
	}

• demo

/*
1 打印1-100 之间所有是9的倍数的整数的个数及总和
 */
func for1(){
	count := 0
	sum := 0
	for i := 1; i < 101; i++ {
		if i % 9 == 0{
			println(i)
			sum += i
			count++
		}
	}
	fmt.Printf("count: %d, sum: %d",count,sum)
}
/*
2 九九乘法表
 */

func for2(){
	for i := 1; i <10; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%d * %d = %d  \t",i,j,i*j)
		}
		fmt.Println()
	}
}

while循环

golang中没有while 和 dowhile 的语法，使用for替换

break 和 continue

都可以指定标签

goto

跳到程序指定标签位置，不主张使用

	fmt.Println("hello world 111")
	fmt.Println("hello world 222")
	fmt.Println("hello world 333")
	goto  label1
	fmt.Println("hello world 444")
	fmt.Println("hello world 555")
	fmt.Println("hello world 666")
	label1:
	fmt.Println("hello world 777")
	fmt.Println("hello world 888")
	fmt.Println("hello world 999")
	

包

包的介绍

说明：go的每一个文件都是属于一个包的，也就说go是以包的形式来管理文件和项目结构的

包的三大作用

1. 区分相同名字的函数、变量标识符
2. 当程序文件很多时，可以很好的管理项目
3. 控制函数、变量等访问范围，即作用域

包的相关说明

1. 打包基本语法
   package util
2. 引入包的基本语法
   import “包的路径”

包的注意事项和细节说明

1. 在给一个文件打包时，该包对应一个文件夹，比如这里的utils文件夹对应的包名就是utils，文件的包名 通常 和文件所在的文件夹名保持一致，一般为小写
2. 当一个文件要使用其他包函数 或 变量时，需要引入对应的包
3. package 指令在文件第一行，然后是import 指令
4. 在import包时，路径从$GOPATH 的src下开始，不用带src，编译器会自动从src下开始引入
5. 为了让其他包的文件，可以访问到本包的函数，则该函数名的首字母需要大写，类似其它语言的public，这样才能访问
6. 在访问其他包函数时，其语法： 包名.函数名
7. 如果包名较长时，Go支持给包起 别名，注意细节，原来的包名就不能使用了
8. 在同一包下，不能有相同的函数名，否则报重复定义
9. 如果你要编译成一个可执行文件，就需要将这个包声明为main，即 package main，这个就是一个语法规范，如果你是写一个库，包名可以自定义

函数

基本语法

func 函数名（形参列表）（返回值列表）{
	执行语句...
	return 返回值列表
}

返回多个值

func main() {
	sum, sub := getResult(5, 2)
	fmt.Printf("sum :%d ,sub:%d  ",sum,sub)

	a ,_ := getResult(4, 2)
	fmt.Printf("sum :%d   ",a)

}
func getResult(n1 int, n2 int) (int, int) {
	sum := n1 + n2
	sub := n1 - n2
	return sum,sub
}

细节说明

• 自定义类型
  
  

• 对函数返回值命名
  

• 支持可变参数
  

init函数

每一个源文件都可以包含一个init函数，该函数在main函数执行前，被go运行框架首先调用，也就说init会在main函数前被调用

匿名函数

Go支持匿名函数，如果我们某个函数只是使用一次，可以考虑使用匿名函数，匿名函数也可以实现多次调用

1. 在定义匿名函数就直接调用

	func (n1 int,n2 int) {
		sum := n1 + n2
		println(sum)
	}(1,2)

2. 将匿名函数赋值给一变量

	var sum = func (n1 int,n2 int)  int{
		sum := n1 + n2
		return sum
	}
	fmt.Println(sum(1,3))

3. 全局匿名函数

var(
	sum = func (n1 int,n2 int)  int{
		sum := n1 + n2
		return sum
	}
)
func main() {
	fmt.Println(sum(1,3))
}

闭包

func main() {
	upper := addUpper()
	fmt.Println(upper(1)) // 11
	fmt.Println(upper(2)) // 13
	fmt.Println(upper(3)) // 16
}

// 累加器
func addUpper( ) func(int)int{
	var n int = 10  // 不会每次初始化
	return func(i int) int {
		n += i
		return n
	}
}

defer

延时机制

函数参数的传递方式

1. 值类型
   int系列
   float系列
   bool
   string
   数组
   结构体struct
2. 引用类型
   指针
   slice
   map
   管道
   interface