Go 语言 运算符

Go 语言 运算符

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

一、算术运算符：

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

运算符	运算	范例	结果
+	正号	+3	3
-	负号	-4	-4
+	加	1+1	2
-	减	2-1	1
*	乘	2*3	6
/	除	5/5	1
%	取模(取余)	7%5	2
++	自增	a=1 a++(a=a+1)	2
–	自减	a=2 a–(a=a-1)	1
+	字符串相加	“fe” + “_cow”	“fe_cow”

1.除法：

package main
import (
	"fmt"
)

func main(){
	// 讲解 除法 /
	// 如果运算符的数都是整数, 那么除后, 去掉小数部分，保留整数部分
	fmt.Println(10 / 4)

	// 如果希望保留小数部分, 需要有浮点数参与运算
	fmt.Println(10.0 / 4)
}	

// 输出结果
2
2.5

注意事项:

1. 除法运算符，都是整数，除后去掉小数部分，保留整数部分；
2. 保留小数部分，需要有浮点数参与运算；

2.取余：

package main
import (
	"fmt"
)

func main(){
	// 讲解 取模(取余)

	// 公式: a % b = a - a / b * b
	fmt.Println("10%3=", 10 % 3)
	fmt.Println("-10%3=", -10 % 3)
	fmt.Println("10%-3=", 10 % -3)
	fmt.Println("-10%-3=", -10 % -3)
}	

// 输出结果
10%3= 1
-10%3= -1
10%-3= 1
-10%-3= -1

公式：a % b = a - a / b * b

3.自增、自减：

package main
import (
	"fmt"
)

func main(){
	// 讲解 自增、自减
	var i = 10
	i++
	fmt.Println("i=", i)
	i--
	fmt.Println("i=", i)
}	

// 输出结果
i= 11
i= 10

4.注意事项：

1. 除号/，整数除 和 小数除 是有区别。整数之间做除法，仅保留整数部分；

   10 / 4

   // 输出结果： 2

2. 取模时，本质运算公式**a % b = a - a / b * b **；

3. go 自增自减 只能当作一个独立语言使用。错误示范如下：

   package main
   import (
   	"fmt"
   )
   
   func main(){
   	// 在 go 中, ++ 和 -- 只能独立使用
   	var i int = 8
   	var j int 
   	a = i++  // 报错, i++ 只能独立使用, 不可以赋值给变量 a
   	b = i--  // 报错原因同上
   
   	//  也会报错
   	if i++ > 0 {
   		fmt.Println("ok")
   	}
   
   
   }	
   

4. go 的++ 和 – ，只能写在变量的后面，不能写在变量的前面；

a++ // 正确

++a // 错误

二、关系运算符：

1. 关系运算符的结果都是 bool 类型，也就是要么是true，要么是false；
2. 关系运算符，组成的表达式，称为关系表达式，经常用在if条件或循环结构条件中；

关系运算符表格：

运算符	运算	范例	结果
==	相等于	1 == 2	false
!=	不等于	1 != 2	true
<	小于	1 < 2	true
>	大于	1 > 2	false
<=	小于等于	1 <= 2	true
>=	大于等于	1 >= 2	false

举个栗子：

package main
import (
	"fmt"
)

func main(){
	// 关系运算符的使用
	var a int = 9
	var b int = 8
	fmt.Println(a == b)
	fmt.Println(a != b)
	fmt.Println(a > b)
	fmt.Println(b > a)
	fmt.Println(a >= b)
	fmt.Println(a <= b)

	num := a > b
	fmt.Println("num=", num)

}	

// 输出结果
false
true
true
false
true
false
num= true

三、逻辑运算符：

用于连接多个条件(一般将就是关系表达式)，最终结果也是一个bool值。

逻辑运算符表格：

假定 A 值 为 True，B 值为 False

运算符	描述	实例
&&	逻辑与运算符。A、B都为 True，则为 True， 否则 False	(A && B) 为 False
||	逻辑或运算符。A、B 只要有一个为 True，则为 True，否则 False	(A || B) 为 True
！	逻辑非运算符。若条件为True，则逻辑为 False，否则为 True	!(A&&B) 为 True

举个栗子：

package main
import (
	"fmt"
)

func main(){
	// 逻辑运算符的使用
	var age int = 20

	// 逻辑与的使用
	if age > 15 && age < 30 {
		fmt.Println("ok1")
	}

	if age > 15 && age < 18 {
		fmt.Println("ok2")
	}

	// 逻辑或的使用
	if age > 15 || age < 18 {
		fmt.Println("ok3")
	}

	if age > 30 || age < 18 {
		fmt.Println("ok4")
	}

	// 逻辑非的使用

	if age > 18 {
		fmt.Println("ok5")
	}

	if !(age > 18) {
		fmt.Println("ok6")
	}

}	

// 输出结果
ok1
ok3
ok5

注意事项：

1. && 也叫短路与。如果第一个条件为 false，则第二个条件不会判断，最终结果就为 false；
2. || 也叫短路非。如果第一个条件为 true，则第二个条件不会判断，最终结果为 true；

短路与、或的栗子：

package main
import (
	"fmt"
)

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

	var age int = 20

	// 短路与的栗子
	// 如果 age < 10 为 false, 后面的 test函数就不会执行, 直接返回 false
	if age < 10 && test(){
		fmt.Println("ok1")
	}

	// 短路或的栗子
	// 如果 age > 10 为 true, 后面的 test 函数就不会执行, 直接返回 true
	if age > 10 || test(){
		fmt.Println("ok2")
	}

}	

// 输出结果
ok2

四、赋值运算符：

赋值运算符就是将某个运算后的值，赋给指定的变量。

赋值运算符表格：

运算符	描述	实例
=	将一个表达式的值，赋值给一个左值	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

举个栗子：

package main
import (
	"fmt"
)

func main(){
	// 赋值运算符的使用

	// 有两个变量 a，b 要求将结果进行交换
	a := 1
	b := 2
	fmt.Printf("交换前 a=%v  b=%v\n", a, b)
	a, b = 2, 1
	fmt.Printf("交换后 a=%v  b=%v\n", a, b)

	// 复合赋值的操作
	a *= 3  // 等于 a = a * 3
	fmt.Printf("a=%v", a)
}	

// 输出结果
交换前 a=1  b=2
交换后 a=2  b=1
a=6

赋值运算符特点：

1. 运算顺序从右往左：

   var c int

   c = a + 3 // 赋值运算的执行顺序从 右 向 左

2. 赋值运算符的左边，只能是变量。右边可以是变量、表达式、常量值。

3. 复合赋值运算符等于下面的结果：

   a += 3 等于 a = a + 3

五、其他运算符：

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

举个栗子：

package main
import (
	"fmt"
)

func main(){
	// 其他运算符使用
	var i int = 10
	fmt.Printf("i 的地址是：%v\n", &i)

	var ptr *int = &i
	fmt.Printf("指针ptr的变量值是：%v", *ptr)
}	

// 输出结果
i 的地址是：0xc00006e068
指针ptr的变量值是：10

go 语言不支持三元运算符。