运算符
运算符是—种特殊的符号，用以表示数据的运算、赋值和比较等
# 1. 赋值运算符
赋值运算符:=,+=，-=，=，/=,%= 赋值运算符就是将某个运算后的值，赋给指定的变量。
# 代码示例
package main
import "fmt"
func main() {
// =
var num1 int = 10
fmt.Println(num1)
var num2 int = (10+20)%3 + 3 - 7 //=右侧的值运算清楚后，再赋值给=的左侧
fmt.Println(num2)
// +=
var num3 int = 10
num3 += 20 //等价num3 = num3 + 20;
fmt.Println(num3)
//练习：交换两个数的值并输出结果：
var a int = 8
var b int = 4
fmt.Printf("a = %v,b = %v\n", a, b)
//交换：
// 方式一：引入一个中间变量：
var t int
t = a
a = b
b = t
fmt.Printf("a = %v,b = %v\n", a, b)
// 方式二：多变量赋值形式
var a1 int = 8
var b1 int = 4
b1, a1 = a1, b1
fmt.Printf("a1 = %v,b1 = %v\n", a1, b1)
}
/*
10
-4
30
a = 8,b = 4
a = 4,b = 8
a1 = 4,b1 = 8
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# 2. 关系运算符
关系运算符:==,!=,>,<,> =，<= 关系运算符的结果都是bool型，也就是要么是true，要么是false 关系表达式经常用在流程控制中
# 代码示例
package main
import "fmt"
func main() {
fmt.Println(5 == 9) //判断左右两侧的值是否相等，相等返回true，不相等返回的是false， ==不是=
fmt.Println(5 != 9) //判断不等于
fmt.Println(5 > 9)
fmt.Println(5 < 9)
fmt.Println(5 >= 9)
fmt.Println(5 <= 9)
}
/*
false
true
false
true
false
true
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 3. 逻辑运算符
逻辑运算符:&&(逻辑与/短路与)，||（逻辑或/短路或），!（逻辑非） 用来进行逻辑运算的
# 代码示例
package main
import "fmt"
func main() {
//与逻辑：&& :两个数值/表达式只要有一侧是false，结果一定为false
//也叫短路与：只要第一个数值/表达式的结果是false，那么后面的表达式等就不用运算了，直接结果就是false -->提高运算效率
fmt.Println(true && true)
fmt.Println(true && false)
fmt.Println(false && true)
fmt.Println(false && false)
//或逻辑：||:两个数值/表达式只要有一侧是true，结果一定为true
//也叫短路或：只要第一个数值/表达式的结果是true，那么后面的表达式等就不用运算了，直接结果就是true -->提高运算效率
fmt.Println(true || true)
fmt.Println(true || false)
fmt.Println(false || true)
fmt.Println(false || false)
//非逻辑：取相反的结果：
fmt.Println(!true)
fmt.Println(!false)
}
/*
true
false
false
false
true
true
true
false
false
true
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# 4. 算术运算符
算术运算符：+ ，-，，/，%，++，-- 介绍：算术运算符是对数值类型的变量进行运算的，比如，加减乘除。
# 注意点
# 除号 /
两个int类型数据运算，结果一定为整数类型
浮点类型参与运算，结果为浮点类型
fmt.Println(10 / 3) //两个int类型数据运算，结果一定为整数类型
fmt.Println(10.0 / 3) //浮点类型参与运算，结果为浮点类型
1
2
2
# 自增自减 ++ —
只能单独使用，不能参与到运算中去
++，--只能在变量的后面，不能写在变量的前面 --a ++a 错误写法
var a int = 10
a++
fmt.Println(a)
a--
fmt.Println(a)
1
2
3
4
5
2
3
4
5
# 代码示例
package main
import "fmt"
func main() {
//+加号：
//1.正数 2.相加操作 3.字符串拼接
var n1 int = +10
fmt.Println(n1)
var n2 int = 4 + 7
fmt.Println(n2)
var s1 string = "abc" + "def"
fmt.Println(s1)
// /除号：
fmt.Println(10 / 3) //两个int类型数据运算，结果一定为整数类型
fmt.Println(10.0 / 3) //浮点类型参与运算，结果为浮点类型
// % 取模 等价公式： a%b=a-a/b*b
fmt.Println(10 % 3) // 10%3= 10-10/3*3 = 1
fmt.Println(-10 % 3)
fmt.Println(10 % -3)
fmt.Println(-10 % -3)
//++自增操作：
var a int = 10
a++
fmt.Println(a)
a--
fmt.Println(a)
//++ 自增 加1操作，--自减，减1操作
//go语言里，++，--操作非常简单，只能单独使用，不能参与到运算中去
//go语言里，++，--只能在变量的后面，不能写在变量的前面 --a ++a 错误写法
}
/*
10
11
abcdef
3
3.3333333333333335
1
-1
1
-1
11
10
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# 5. 位运算符
位运算符有七个，分为两类：
逻辑位运算符：位与（&）、位或（|）、位异或（^）、非位（~）
移位运算符：左移（<<）、右移（>>）、无符号右移（>>>）
# 代码示例
package main
import "fmt"
func main() {
var a int = 1 // 00000001
var b int = 5 // 00000101
// & ： 全一得一
fmt.Println(a & b)
// | ：有一得一
fmt.Println(a | b)
// ^ ： 相同为0，不同为1
fmt.Println(b ^ a)
// ~ ：运算规则：0变为1，1变为0
}
/*
1
5
4
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 6. 其它运算符
其它运算符：
- & ：返回变量的存储地址
- ：取指针变量对应的数值
# 代码示例
package main
import "fmt"
func main() {
//定义一个变量：
var age int = 18
fmt.Println("变量地址：", &age) //age对应的存储空间的地址为： 0xc0000100b0
var ptr *int = &age
fmt.Println("ptr赋值为变量地址：", ptr)
fmt.Println("指针地址：", &ptr)
fmt.Println("指针取值：", *ptr)
fmt.Printf("指针类型：%T", ptr)
}
/*
变量地址： 0xc000122058
ptr赋值为变量地址： 0xc000122058
指针地址： 0xc000146020
指针取值： 18
指针类型：*int
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 7. 运算符的优先级
所谓优先级，就是当多个运算符出现在同一个表达式中时，先执行哪个运算符。
Go语言有几十种运算符，被分成十几个级别，有的运算符优先级不同，有的运算符优先级相同，请看下表。
| 优先级 | 分类 | 运算符 | 结合性 |
|---|---|---|---|
| 1 | 逗号运算符 | , | 从左到右 |
| 2 | 赋值运算符 | =、+=、-=、*=、/=、 %=、 >=、 <<=、&=、^=、 | = |
| 3 | 逻辑或 | ||
| 4 | 逻辑与 | && | 从左到右 |
| 5 | 按位或 | ||
| 6 | 按位异或 | ^ | 从左到右 |
| 7 | 按位与 | & | 从左到右 |
| 8 | 相等/不等 | ==、!= | 从左到右 |
| 9 | 关系运算符 | <、<=、>、>= | 从左到右 |
| 10 | 位移运算符 | <<、>> | 从左到右 |
| 11 | 加法/减法 | +、- | 从左到右 |
| 12 | 乘法/除法/取余 | *（乘号）、/、% | 从左到右 |
| 13 | 单目运算符 | !、*（指针）、& 、++、--、+（正号）、-（负号） | 从右到左 |
| 14 | 后缀运算符 | ( )、[ ]、-> | 从左到右 |
注意：优先级值越大，表示优先级越高。
编辑 (opens new window)