算数运算符，比较运算符，逻辑运算符，赋值运算符，运算优先级

1.算数运算符

package main

import "fmt"

func main() {
	//说明，如果运算的数都是整数，那么除后，去掉小数部分，保留整数部分
	fmt.Println(10 / 4)
	var n1 float32 = 10 / 4 //
	fmt.Println(n1)

	//如果我们希望保留小数部分，则需要有浮点数参与运算
	var n2 float32 = 10.0 / 4
	fmt.Println(n2)

	//演示%的使用
	//看一个公式a%b=a-a/b*b
	fmt.Println(10 % 3)  //=1
	fmt.Println(-10 % 3) //=-10-(10)/3*3=-10-(-9)=-1
	fmt.Println(10 % -3)
	fmt.Println(-10 % -3)

	//++和--的使用
	var i int = 10
	i++                  //等价i=i+1
	fmt.Println("i=", i) //11
	i--                  //等价i = i-i
	fmt.Println("i=,i")  //10
}
//在golang，中++和--只能独立使用
	// 	var i int = 8
	// 	var a int
	// 	a=i++//错误，i++只能独立使用
	// 	a=i--//错误，i--只能独立使用
	// 	if i++>0{
	// 		fmt.Println("ok")
	// 	}

// 	var i int =1
	// 	i++
	// 	++i//错误，在golang没有，前++ 前--也是错误的

	// 	fmt.println("i",i)
	//

1.1注意事项

1. 对于除号“/”,它的整数和小数除是有区别的，整数之前做除法时，只保留整数部分而舍弃小数部分
2. 对于一个数取模式，可以等价a%b=a-a/b*b,这样我们可以看到取模的一个本质运算
3. Golang的自增自减只能当做一个独立语言使用时，不能这样使用，b：=a++或者b：=a–
4. Glang的++或-只能写在变量的后面，不能写在变量的前面，即：只有a++a–没有++a，–a
5. Golang的设计者去标c、java中的自增自减的容易混淆的写法，让Golang更加的简洁，统一。（强制性）
6. 图片上的是一些案例

package main

import "fmt"

func main() {
	//假如还有97天放假，问：xx个星期零xx天
	var days int = 97
	var week int = days / 7
	var day int = days % 7
	fmt.Printf("%v个星期零%d天\n", week, day)

	//定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：
	//5/9*(华氏温度-100)，请求出华氏温度对应的摄氏温度
	var huashi float32 = 134.2
	var sheshi float32 = 5.0 / 9 * (huashi - 100) //正确的华氏是-32，但是不影响理解
	fmt.Printf("%v对应的摄氏温度=%v \n", huashi, sheshi)
}

2.关系运算符，比较运算符

• 关系运算的结果是bool型，也就是要么是ture，要么是false
• 关系表达式经常用在if结构的条件或者循环结构的条件中
  
  案例演示

package main

import "fmt"

func main() {
	//演示关系运算符的使用
	var n1 int = 9
	var n2 int = 8
	fmt.Println(n1 == n2) //false
	fmt.Println(n1 != n2)
	fmt.Println(n1 > n2)
	fmt.Println(n1 >= n2)
	fmt.Println(n1 < n2)
	fmt.Println(n1 <= n2)

	flag := n1 > n2
	fmt.Println("flag", flag)
}

2.1注意事项

1.关系运算符的结果都是bool型，也就是要么是true，要么是false
2.关系运算符组成的表达式，我们称之为关系表达式：a>b
3.比较运算符“==”不能误写成“=”

3.逻辑运算符

用于连接多个条件，（一般来讲就是关系表达式），最终的结果也是一个bool值

3.1注意事项

&&也叫短路与，如果一个条件为false，则第二个条件不会判断，最终结果为false
||也叫短路线或，如果第一个条件为true，则第二个条件不会判断，最终结果为true
案例

package main

import "fmt"

//声明一个函数（测试）
func test() bool {
	fmt.Println("test..")
	return true
}

func main() {
	var i int = 10
	// //短路与
	// //说明因为 i<9 false,因此后期的test（）就不执行
	// if i > 9 && test() {
	// 	fmt.Println("ok")
	//如果i<9则都不输出

	// }

	if i < 9 || test() {
		fmt.Println("hello...")

	}
	//如果i<9则会输出test和hello，如果i>9则只输出hello
}

4.赋值运算法

package main

import (
	"fmt"
)

func test() int {

	return 90
}
func main() {
	//赋值运算符的使用
	//var i int
	//i=10//基本赋值
	//赋值运算符的使用演示
	//有两个变量，a，b，要求将其进行转换，最终打印结果
	//a=9，b=2，==>a=2 b=9
	a := 9
	b := 2
	fmt.Printf("交换前的情况是a=%v,b=%v\n", a, b)
	//定义一个临时变量
	t := a
	a = b
	b = t
	fmt.Printf("a%v,b%v\n", a, b)
	//复合赋值的操作
	a += 17 //等价a=a+17
	fmt.Println("a=", a)

	//赋值运算符的左边只能是变量，右边可以说变量，表达式，常量值
	//表达式：任何有值都可以看做表达式
	var d int
	d = a           //
	d = 8 + 2*8     //右边是表达式
	d = test() + 90 //=的右边是表达式
	//d = 890         //890常量
	fmt.Println(d)
}

4.1注意特点

• 赋值运算的注销顺序是从右向左
• 赋值的左边只能是变量，但是右边可以是变量，表达式（任何右值都可以看做表达式），常量（比如880）。
  package main

import "fmt"

func main() {
	//有两个变量，a和b，要求将其进行交换，但是不允许使用中间变量，最终打印结果
	var a int = 10
	var b int = 20
	a = a + b //
	b = a - b //b=a+b==>b=a
	b = a - b //b=a+b-b==>b=a
	a = a - b //a=a+b-a==>a=b
	fmt.Printf("a=%vb=%v", a, b)
}

5.运算优先级

• 只有单目运算符，赋值运算符是从右向左运算的