Go操作符与表达式 | 个人技术笔记

说明

Golang基础 - 操作符与表达式

# 1、算术运算法

运算符	说明
+	相加
-	相减
*	相乘
/	相除
%	求余数

package main

import "fmt"


func main() {
    // 四则运算
	var a float32 = 8
	var b float32 = 3
	var c = a + b  // 加
	var d = a - b  // 减
	var e = a * b  // 乘
	var f = a / b  // 除

	var m = 8
	var n = 3
	var o = m % n  // 取余

	fmt.Printf("c=%f\n", c)
	fmt.Printf("d=%f\n", d)
	fmt.Printf("e=%f\n", e)
	fmt.Printf("f=%f\n", f)
	fmt.Printf("o=%d\n", o)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 2、关系运算符

运算符	说明
==	检查两个值是否相等，如果相等返回True否则返回False
!=	检查两个值是否不相等，如果不相等返回True否则返回False
>	检查左边的值是否大于右边的值，如果是返回True否则返回False
>=	检查左边的值是否大于等于右边的值，如果是返回True否则返回False
<	检查左边的值是否小于右边的值，如果是返回True否则返回False
<=	检查左边的值是否小于等于右边的值，如果是返回True否则返回False

package main

import "fmt"

func main() {
	var a int = 8
	var b int = 9
	var c int = 8
	var d int = 4

	fmt.Println(a != b)
	fmt.Println(a == c)
	fmt.Println(a < d)
	fmt.Println(a <= c)
	fmt.Println(c > d)
	fmt.Println(b >= a)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 3、逻辑运算符

运算符	说明
&&	逻辑AND运算符。如果两边的操作结果都为True，则为True，否则为False
\|\|	逻辑OR运算符。如果两边操作结果有一个位True，则为True，否则为False
！	逻辑NOT运算符。如果条件为True则为False，如果条件为False则为True

package main

import "fmt"

func main() {
	var a int = 8
	var b int = 9
	var c int = 8

	fmt.Println(a < b && c >= a)
	fmt.Println(a < b || a > c)
	fmt.Println(!(a > c))
}

1
2
3
4
5
6
7
8
9
10
11
12
13

# 4、位运算符

运算符	说明
&	参与运算的两个数字各对应的二进制位相与（`对应的两个位上都是1才为1`）
\|	参与运算的两个数字各对应的二进制位相或（`对应的两个位上有一个为1就为1`）
^	参与运算的两个数字各对应的二进制位相异或，当对应的二进制位上数字不同时结果为1（`对应的两个位上的数字不同就为1`）。作为一元运算符时表示按位取反，符号位也跟着变。
<<	左移n位就是乘以2的n次方。a<<b就是把a的各二进制位全部向左移动b位，高位丢弃，低位补0
>>	右移n位就是除以2的n次方。a>>b就是把a的各二进制位右移b位

# 4.1 &运算

  0101
& 0110
--------
  0101

1
2
3
4

# 4.2 |运算

  0101
| 0110
--------
  0111

1
2
3
4

# 4.3 ^运算

  0101
^ 0110
--------
  0011

1
2
3
4

^的一元运算：

# 这里没有把符号位放进来
^ 1110
--------
  1001

1
2
3
4

# 4.4 >>运算

# 正数右移，高位补0
0101  >>2  0001

# 负数右移，高位补1
1101 >>2  1111

1
2
3
4
5

# 4.5 <<运算

# 负数左移，右侧补0
1101  <<2  0100

1
2

负数右移还是负数，负数左移有可能变成正数。

# 4.6 示例

main.go

package main

import (
	"day01/util"
	"fmt"
	"runtime"
	"strconv"
)


func main() {
    // 获取当前操作系统架构以及int类型的Size，64位操作系统int为8个字节
    fmt.Printf("os arch: %s, int size: %d\n", runtime.GOARCH, strconv.IntSize)
	fmt.Printf("260 %b\n", util.BinaryFormat(260)) // int 260 = 2^8+2^2 的二进制表示
	fmt.Printf("-260 %b\n", util.BinaryFormat(-260))
	fmt.Printf("-260<<23 %b\n", util.BinaryFormat(-260<<23))
	fmt.Printf("-260>>23 %b\n", util.BinaryFormat(-260>>23)) // 负数右移最高位补 1
	fmt.Printf("260>>23 %b\n", util.BinaryFormat(260>>23))   // 正数右移最高位补 0

	// &运算 对应位上同时为1则为1
	fmt.Printf("%b\n", 6&5) // 6==> 2^2+2^1 ==> 110  5==> 2^2+2^0 ==> 101  110 & 101 ==> 100
	// |运算 对应位上有以一个1就为1
	fmt.Printf("%b\n", 6|5) // 6==> 2^2+2^1 ==> 110  5==> 2^2+2^0 ==> 101  110 | 101 ==> 111
	// ^运算 对应位上不同则为1，否则为0
	fmt.Printf("%b\n", 6^5) // 6==> 2^2+2^1 ==> 110  5==> 2^2+2^0 ==> 101  110 ^ 101 ==> 011 ==> 11
	fmt.Printf("%b\n", ^5)  // 5==> 2^2+2^0 ==> 101  ^ 101 ==> 010 ==> 10    这里会把最高位也带入，所以显示 -110

	fmt.Printf("%b\n", 5>>1) // 101 ==> 10
	fmt.Printf("%b\n", 5<<1) // 101 ==> 1010
}

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

day01/util/binary.go

package util

import (
	"math"
	"strings"
)

func BinaryFormat(n int64) string {
	sb := strings.Builder{}     // 字符串拼接，通过Builder{}性能比通过`+`拼接性能更高
	c := int64(math.Pow(2, 31)) // 最高位上是1，其他位全是0.这里的int是64位
	// c = 1000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
	//fmt.Printf("%b\n", c)
	for i := 0; i < 32; i++ {
		if n&c != 0 { // 判断n当前位上是否为1
			sb.WriteString("1")
		} else {
			sb.WriteString("0")
		}
		c >>= 1 // "1"往右位移一位  c = c >> 1
	}
	return sb.String()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 5、赋值运算符

运算符	说明
=	简单的赋值运算，将一个表达式的值赋给左侧的变量
+=	相加之后再赋值
-=	相减之后再赋值
*=	相乘之后再赋值
/=	相除之后再赋值
%=	取余之后再赋值
<<=	左移之后再赋值
>>=	右移之后再赋值
&=	按位与后再赋值
\|=	按位或后再赋值
^=	按位异或后再赋值

package main

import "fmt"

func main() {
	// 赋值运算
	a := 5 // a = 5
	a += 1 // a = 5 + 1 = 6
	b := 7 // b = 7
	b *= a // b = 7 * 6 = 42

	fmt.Println(a, b)

	fmt.Printf("6 %b\n", util.BinaryFormat(6))
	fmt.Printf("42 %b\n", util.BinaryFormat(42))
	b ^= a // b = b ^ a   0010 1010 ^ 0000 0110  ==> 00101100
	fmt.Println(b)
	fmt.Printf("44 %b\n", util.BinaryFormat(44))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19