Go语言学习(7) - 运算符

发表于 | 分类于 | 阅读次数:
字数统计: 1,958 字 | 阅读时长 ≈ 9 分钟

运算符用于在程序运行时执行数学或逻辑运算。

Go语言内置的运算符有：

  • 算术运算符
  • 关系运算符
  • 逻辑运算符
  • 位运算符
  • 赋值运算符
  • 其他运算符

算术运算符

  • 算术运算符主要有：+、-、*、/、%（求余）、++（自增）、–（自减）

关系运算符

  • 关系运算符主要有：==、!=、>、<、>=、<=

逻辑运算符

  • 逻辑运算符主要有：&&（逻辑AND）、|| （逻辑OR）、! （逻辑NOT）

位运算符

位运算符对整数在内存中的二进制进行操作。

位运算符比一般的算术运算符速度要快，而且可以实现一些算术运算符不能实现的功能。如果要开发高效率程序，位运算符是必不可少的。位运算符用来对二进制进行操作，包括：按位与（&）、按位或（|）、按位异或（^）、按位左移（<<）、按位右移（>>）

按位与

按位与（&）：对两个数进行操作，然后返回一个新的数，这个数的每个位都需要两个输入数的同一位都为1时 才为1。简单的说：同一位同时为1 则为1

按位或

按位或（|）：比较两个数，然后返回一个新的数，这个数的每一位置设置1的条件是任意一个数的同一位为1 则为1。简单的说：同一位其中一个为1 则为1

按位异或

按位异或（^）：比较两个数，然后返回一个数，这个数的每一位设为1的条件是两个输入数的同一位不同 则为1，如果相同就设为 0 。简单的说：同一位不相同 则为1

左移运算符（<<）

按二进制形式把所有的数字向左移动对应的位数，高位移出（舍弃），低位的空位补零

  1. 语法格式：
    1. 需要移位的数字 << 移位的次数
    2. 例如：3 << 4，则是将 数字3 左移了4位
  2. 计算过程：
    1. 3 << 4
    2. 首先把 3 转换为 二进制数字 0000 0000 0000 0000 0000 0000 0000 0011，然后把该数字高位（左侧）的两个零移出。其他的数字都朝左平移4位，最后在 低位（右侧）的两个空位补零，则得到的最终结果为 0000 0000 0000 0000 0000 0000 0011 0000，则转换为十进制为 48
    3. 用 3 * 2 ^4 计算 更加方便，3 乘以 2 的4次方
  3. 数字意义
    1. 在数字没有溢出的前提下，对于正数 和 负数，左移一位 都相当于 乘以 2的一次方，左移 n 位就相当于 乘以2的 n 次方
右移运算符（>>）

按二进制形式把所有的数字都向右移动对应 位移位数，低位移出（舍弃），高位的空位补符号位，即正数补零，负数 补1

  1. 语法格式
    1. 需要移位的数字 >> 移位的次数
    2. 例如：11 >> 2，则是将数字 11 右移2位
  2. 计算过程
    1. 11的二进制形式为：0000 0000 0000 0000 0000 0000 0000 1011，然后把低位的最后两个数字移出，因为该数字是正数，所有在高位补零，则得到的最终结果为 0000 0000 0000 0000 0000 0000 0000 0010，转化为十进制为2
    2. 用 11 / (2 ^ 2) 计算 更加方便，11 除以 2 的2次方
  3. 数字意义
    1. 右移一位相当于 除2，右移 n 位，则相当于 除以2的 n 次方

赋值运算符

赋值运算符有：=、+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|=。

DEMO示例

以下是上面知识点的代码演示：

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
package main
import "fmt"

var a = 21.0
var b = 5.0
var c float64

func main() {
	fmt.Println("算术运算符 --- start---")
	Arithmetic()
	fmt.Println()

	fmt.Println("关系运算符 --- start---")
	Relational()
	fmt.Println()

	fmt.Println("逻辑运算符 --- start---")
	Logical()
	fmt.Println()

	fmt.Println("位运算符 --- start---")
	Bitwise()
	fmt.Println()

	fmt.Println("赋值运算符 --- start---")
	Assignment()
	fmt.Println()
}

// 算术运算符
func Arithmetic() {
	c = a + b
	fmt.Printf("第一行 - c 的值为 %.2f\n", c)

	c = a - b
	fmt.Printf("第二行 - c 的值为 %.2f\n", c)

	c = a * b
	fmt.Printf("第三行 - c 的值为 %.2f\n", c)

	c = a / b
	fmt.Printf("第四行 - c 的值为 %.2f\n", c)

	//c = a % b
	fmt.Printf("第五行 - c 的值为 %d\n", int(a)%int(b))

	a++
	fmt.Printf("第六行 - a 的值为 %f\n", a)

	a = 21
	a--
	fmt.Printf("第七行 - a 的值为 %f\n", a)
}

// 关系运算符
func Relational() {
	if (a == b) {
		fmt.Printf("第一行 - a 等于 b \n")
	} else {
		fmt.Printf("第一行 - a 不等于 b \n")
	}

	if (a < b) {
		fmt.Printf("第二行 - a 小于 b \n")
	} else {
		fmt.Printf("第二行 - a 不小于 b \n")
	}

	if (a > b) {
		fmt.Printf("第三行 - a 大于 b \n")
	} else {
		fmt.Printf("第三行 - a 不大于 b \n")
	}
}

// 逻辑运算符
func Logical() {

	a := true
	b := false

	if (a && b) {
		fmt.Printf("第一行 - 条件为 true \n")
	}
	if (a || b) {
		fmt.Printf("第二行 - 条件为 true \n")
	}
	if (!(a && b)) {
		fmt.Printf("第三行 - 条件为 true \n")
	}
}

// 位运算符
func Bitwise() {
	fmt.Println(252 & 63)
	fmt.Println(178 | 94)
	fmt.Println(20 ^ 5)
	fmt.Println(3 << 4)  // 3 * 2 ^ 4
	fmt.Println(11 >> 2) // 11 / (2 ^ 2)
}

// 赋值运算符
func Assignment() {
	c = a
	fmt.Printf("第1行 - =运算符实例，c的值为 %f \n", c)

	c += a
	fmt.Printf("第2行 - +=运算符实例，c的值为 %f \n", c)

	c -= a
	fmt.Printf("第3行 - -=运算符实例，c的值为 %f \n", c)

	c *= a
	fmt.Printf("第4行 - *=运算符实例，c的值为 %f \n", c)

	c /= a
	fmt.Printf("第5行 - /=运算符实例，c的值为 %f \n", c)

	c = a
	fmt.Printf("第6行 - =运算符实例，c的值为 %f \n", c)

	d := 200
	d <<= 2
	fmt.Printf("第7行 - <<=运算符实例，d的值为 %d \n", d)  // d = d * 2^2 = 200 * 2^2 = 800

	d >>= 2
	fmt.Printf("第8行 - >>=运算符实例，d的值为 %d \n", d)  // d = d / (2^2) = 800 / (2^2) = 200

	d &= 2
	fmt.Printf("第9行 - &=运算符实例，d的值为 %d \n", d)	// d = d & 2 = 0

	d |= 2
	fmt.Printf("第10行 - |=运算符实例，d的值为 %d \n", d) // d = d | 2 = 2

	d ^= 2
	fmt.Printf("第11行 - ^=运算符实例，d的值为 %d \n", d) // d = d ^ 2 = 0
}

运行结果为：

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
算术运算符 --- start---
第一行 - c 的值为 26.00
第二行 - c 的值为 16.00
第三行 - c 的值为 105.00
第四行 - c 的值为 4.20
第五行 - c 的值为 1
第六行 - a 的值为 22.000000
第七行 - a 的值为 20.000000

关系运算符 --- start---
第一行 - a 不等于 b 
第二行 - a 不小于 b 
第三行 - a 大于 b 

逻辑运算符 --- start---
第二行 - 条件为 true 
第三行 - 条件为 true 

位运算符 --- start---
60
254
17
48
2

赋值运算符 --- start---
第1行 - =运算符实例，c的值为 20.000000 
第2行 - +=运算符实例，c的值为 40.000000 
第3行 - -=运算符实例，c的值为 20.000000 
第4行 - *=运算符实例，c的值为 400.000000 
第5行 - /=运算符实例，c的值为 20.000000 
第6行 - =运算符实例，c的值为 20.000000 
第7行 - <<=运算符实例，d的值为 800 
第8行 - >>=运算符实例，d的值为 200 
第9行 - &=运算符实例，d的值为 0 
第10行 - |=运算符实例，d的值为 2 
第11行 - ^=运算符实例，d的值为 0
坚持原创技术分享，您的支持将鼓励我继续创作！
-------------本文结束感谢您的阅读-------------
分享到：
0%