Go学习系列06-运算符

算术运算符

算术表达式

由算术运算符连接起来的式子： 如:1+1 a-b

(变量ab前面已声明并赋初值)

运算优先级：先乘除，后加减，有括号先算括号里的，相同级别的从左至右运算

必须是同等类型才可以进行运算！

int 转float多小数，float转int丢精度

package main

import "fmt"

func main() {
	var a int = 10
	var b int = 20
	fmt.Printf("a+b=%d\n", a+b)
	fmt.Printf("b-a=%d\n", b-a)
	fmt.Printf("b*a=%d\n", b*a)
	fmt.Printf("b/a=%d\n", b/a)
	fmt.Printf("b%%a=%d\n", b%a)
}
//a+b=30
//b-a=10
//b*a=200
//b/a=2
//b%a=0

自增和自减

package main

import "fmt"

func main() {
	var a int = 10
	var b int = 12
	a++  // 等价于 a=a+1，并且只能独立使用
	b--  // 等价于 b=b-1
	fmt.Printf("a=%d, b=%d", a, b)
}
//a=11, b=11

注意：GO语言中没有前自增，这是与其它编程语言不同的地方

示例

某学生三门课成绩为,语文:90 数学:80 英语:67,编程求总分和平均分

package main

import "fmt"

func main() {
	var chinese int = 90
	var math int = 80
	var english int = 67

	var sum, avg int
	sum = chinese + math + english
	avg = sum / 3
	fmt.Printf("总分: %d，平均分: %d", sum, avg)
}

优化： 减少变量定义，可以直接在fmt的时候计算

package main

import "fmt"

func main() {
	var chinese int = 90
	var math int = 80
	var english int = 67
	fmt.Printf("总分: %d，平均分: %.2f", chinese+math+english, float64((chinese+math+english)/3))
}

赋值运算符

运算符	描述	实例
=	简单的赋值运算符，将一个表达式的值赋给一个左值	C=A+B 将 A+B 表达式结果赋值给 C
+=	相加后再赋值	C+=A 等于 C=C+A
-=	相减后再赋值	C-=A 等于 C=C-A
*=	相乘后再赋值	C*=A 等于 C=C*A
/=	相除后再赋值	C/=A 等于 C=C/A
%=	求余后再赋值	C%=A 等于 C=C%A
<<=	左移后赋值	C<<=2 等于 C=C<<2
>>=	右移后赋值	C>>=2 等于 C=C>>2
&=	按位与后赋值	C&=2 等于 C=C&2
^=	按位异或后赋值	C^=2 等于 C=C^2
|=	按位或后赋值	C|=2 等于 C=C|2

赋值运算符的特点

• 从右往左顺序计算
• 左边只能是变量
• 右边可以是变量、表达式、常量值

示例

有两个变量，a 和 b，要求将其进行交换，但是不允许使用中间变量，最终打印结果

package main

import "fmt"

func main() {
	a := 10
	b := 20

	a = a + b // 此时a是两者的和
	b = a - b // 此时 两者和 - b 就是之前a的值
	a = a - b // 此时b是之前a的值，两者之和-之前a的值就是之前b的值
	fmt.Printf("a=%v, b=%v", a, b)
}
//a=20, b=10

关系运算符

假定 A 值为 10，B 值为 20

运算符	描述	实例
==	检查两个值是否相等，如果相等返回 True 否则返回 False	(A == B) 为 False
!=	检查两个值是否不相等，如果不相等返回 True否则返回 False	(A != B) 为 True
>	检查左边值是否大于右边值，如果是返回 True否则返回 False	(A > B) 为 False
<	检查左边值是否小于右边值，如果是返回 True 否则返回 False	(A < B) 为 True
>=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False	(A >= B) 为 False
<=	检查左边值是否小于等于右边值，如果是返回 True否则返回 False	(A <= B) 为 True

关系运算符注意的点

• 同类型才可以比较
• 结果是bool类型，只有true和false
• 用关系运算符组成的表达式，就是关系表达式 A > B

示例

func main() {
	var n1 int = 9
	var n2 int = 8
	fmt.Println(n1 == n2)
	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)
}
//false
//true
//true
//true
//false
//false
//flag= true

逻辑运算符

假定 A 值为 True，B 值为 False

运算符	描述	实例
&&	逻辑 AND 运算符。如果两边的操作数都是 True，则条件 True，否则为 False	(A && B) 为 False
||	逻辑 OR 运算符。如果两边的操作数有一个 True，则条件 True，否则为 False	(A || B) 为 True
!	逻辑 NOT 运算符。如果条件为 True，则逻辑 NOT 条件 False，否则为 True	!(A && B) 为 True

逻辑运算符注意的点

• 有逻辑运算符连接的表达式叫做逻辑表达式
• 逻辑运算符两边的一般都是关系表达式或bool类型
• 逻辑表达式的值也是bool类型
• &&也叫短路与
  • 如果第一个条件为fasle，则第二个条件不会判断，最终结果为fasle
• || 也叫短路或
  • 如果第一个条件为true，则第二个条件不会判断，最终结果为true

示例

func test(num int) bool {
	fmt.Printf("test %d func is running", num)
	return true
}
func main() {
	var i int = 10
	if i < 9 && test(1) {
		fmt.Println("1: false && true")
	}

	if i > 9 && test(2) {
		fmt.Println("2: true && true")
	}

	if i < 9 || test(3) {
		fmt.Println("3: false || true")
	}

	if i > 9 || test(4) {
		fmt.Println("4: true || true")
	}

}
//test 2 func is running2: true && true
//test 3 func is running3: false || true
//4: true || true

其他运算符

运算符	描述	实例
&	返回变量存储地址	&a 将给出变量的实际地址
*	返回内存地址指向的变量	*a 是一个指针变量

func main() {
	var a int = 4
	var b int32
	var c float32
	var ptr *int
	fmt.Printf("a type is :%T\n", a)
	fmt.Printf("b type is :%T\n", b)
	fmt.Printf("c type is :%T\n", c)

	ptr = &a
	fmt.Printf("a value is : %d\n", a)
	fmt.Printf("ptr is : %d\n", ptr)
	fmt.Printf("ptr is : %d\n", *ptr)
}
//a type is :int
//b type is :int32
//c type is :float32
//a value is : 4
//ptr is : 824633811112
//ptr is : 4

运算的优先级

• 一元运算符（单目运算符）：只需要一个操作数的运算符
• 二元运算符：有2个操作数的运算符
• 逻辑与的优先级高于逻辑或

一元运算符拥有最高优先级

分类	描述	顺序
赋值运算符	= += -= *= /= %= >>= <<= &= ^= |=	右到左
单目	+ - ! ~ (type) * & sizeof	右到左
后缀	() [[ -> . ++ –	左到右
乘法	* / %	左到右
加法	+ -	左到右
移位	>> <<	左到右
关系	> >= < <=	左到右
相等(关系)	== !=	左到右
按位AND	&	左到右
按位XOR	^	左到右
按位OR	|	左到右
逻辑AND	&&	左到右
逻辑OR	||	左到右
逗号	,	左到右