Payne的个人小屋

Every day

0%

Golang运算符

发表于 更新于 分类于 Valine：
本文字数： 1.9k 阅读时长 ≈ 2 分钟

本章目标：

  • 了解运算符、运算符的种类、各运算符的特征
  • 进制
  • 位运算符及位运算
  • 运算符优先级

什么是运算符

运算符用于执行程序代码运算，会针对一个以上操作数项目来进行运算
。例如：2+3，其操作数是2和3，而运算符则是“+”。

在vb2005中运算符大致可以分为5种类型：算术运算符、位运算符、 关系运算符、赋值运算符、逻辑运算符。

算数运算符

| 运算符 | 描述 | | :----: | :–: | | + | 相加 | | - | 相减 | | * | 相乘 | | / | 相除 | | % | 求余 |

注意： ++（自增）和--（自减）在Go语言中是单独的语句，并不是运算符。

1
2
3
4
5
6
7
func main() {
 a, b := 3,4
 fmt.Printf("a 加 b = %d\n", a + b)
 fmt.Printf("a 减 b = %d\n", a - b)
 fmt.Printf("a 乘 b = %d\n", a * b)
 fmt.Printf("a 除 b = %d\n", a / b)
}

关系运算符

运算符描述
==检查两个值是否相等，如果相等返回 True 否则返回 False。
!=检查两个值是否不相等，如果不相等返回 True 否则返回 False。
>检查左边值是否大于右边值，如果是返回 True 否则返回 False。
> =检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
<检查左边值是否小于右边值，如果是返回 True 否则返回 False。
<=检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func main() {
 a, b := 3, 4
 //fmt.Println("a == b?",  a == b)         // a == b? false
 //fmt.Println("a != b?",  a != b)         // a != b? true
 //fmt.Println("a >  b?",  a > b )         // a >  b? true
 //fmt.Println("a >= b?",  a >= b)         // a >= b? false
 //fmt.Println("a <  b?",  a < b )         // a >= b? true
 //fmt.Println("a <= b?",  a <= b )        // a <= b? true
}

逻辑运算符

运算符描述
&&逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。
\\
!逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True。
1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

func main() {
 a, b := true, false
 fmt.Println("a && b ?", a && b)      // a && b ? false
 fmt.Println("a || b ?", a || b)      // a || b ? true
 fmt.Println("  !a ?", !a)            //  !a ? false
 fmt.Println("  !b ?", !b)            //  !b ? true
}

位运算符

常见进制

  • 二进制：只有 0 和 1，Go语言中不能直接使用二进制表示整数；

  • 八进制：0-7，以数字 0 开头；

  • 十进制：0-9；

  • 十六进制：0-9 以及 A-F，以 0X 开头，A-F 以及 X 不区分大小写。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    package main

    import "fmt"

    func main() {
     a := 10
     // 二进制
     fmt.Printf("%b\n",a)    // 1010
     // 八进制
     fmt.Printf("%o\n",a)    // 12
     // 十进制
     fmt.Printf("%d\n",a)    // 10
     // 十六进制
     fmt.Printf("%x\n",a)    // a
    }

任意进制转换为十进制

二进制转十进制：从最低位开始，每个位上数乘以 2 的位数减 1 次方然后求和。

1011 = 120 + 121 + 022 + 123 = 11

八进制转十进制：从最低位开始，每个位上数乘以 8 的位数减 1 次方然后求和。

0123 = 380 + 281 + 182 + 083 = 83

其他进制互转

  • 二进制转换八进制：将二进制数从低位开始，每三位一组，转换成八进制数即可；
  • 二进制转十六进制：将二进制数从低位开始，每四位一组，转换成十六进制数即可；
  • 八进制转换二进制：将八进制数每 1 位转换成一个 3 位的二进制数（首位 0 除外）；
  • 十六进制转二进制：将十六进制每 1 位转换成对应的一个 4 位的二进制数即可。

反码补码

对于有符号数而言，二进制的最高为是符号位：0 表示正数，1 表示负数。

短除法进行进制转变

十进制的10-> 二进制：

二进制的1011 -> 十进制

想要详细了解其原理的可以参考短除法
相关说明

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

运算符描述
&参与运算的两数各对应的二进位相与。 （两位均为1才为1）
\
^参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 （两位不一样则为1）
<<左移n位就是乘以2的n次方。 “a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
> >右移n位就是除以2的n次方。 “a>>b”是把a的各二进位全部右移b位。

XOR - 异或：相同为0，不同为1.也可用“进位加法”来理解

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
x ^ 0 = X
x ^ 1s = ~x  # 1s = ~ 0
x ^ (~x) = 1s 
x ^ x = 0
c = a ^ b  => a ^ c = b, b ^c = a # 交换两数
a ^ b ^ c = a ^(b ^ c) = (a ^ b) ^c # associative

// 指定未知的位运算

1. 将x最右边的n位请零： x & (~0 << n )
2. 获取x的第n位值（0 或 1）： （x >> n）& 1
3. 获取x的第n位的幂值：x & （1 << n）
4. 仅将第n位置为 1： x | (1 << n)
5. 仅将第n位置为0：x & （~1（1 << n））
6. 将x最高位至第n位(含)清零：x & ((1 << n) - 1)

// 实战位运算要点

// 判断奇偶性
x % 2 == 1 - > (x & 1) == 1 
x & 2 == 0 -> (x&1) == 0
 // 清零最低位的1
x = x & (x - 1)
// 得到最低位的1
x & ~x 
x & ~ x = > 0

为了更清晰的观察其变化，我们使用二进制来进行演示

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

import "fmt"

func main() {
 a, b := 13, 21
 fmt.Printf("a:%b & %b = %b\n", a, b, a & b)
 fmt.Printf("a:%b | %b = %b\n", a, b, a | b)
 fmt.Printf("a:%b ^ %b = %b\n", a, b, a ^ b)
 fmt.Printf("a:%b ^ %b = %b\n", a, b, a ^ b)

 // 左移
  // 二进制表示
 fmt.Printf("%b << %b = %b\n",2, 2, 2<<2) // 10 << 10 = 1000
  // 十进制
 fmt.Printf("%d << %d = %d\n",2, 2, 2<<2) // 2 << 2 = 8
 // 右移
  // 二进制
 fmt.Printf("%b >> %b = %b\n",2, 2, 2>>2) // 10 >> 10 = 0
  // 十进制
 fmt.Printf("%d >> %d = %d\n",2, 2, 2>>2) // 2 >> 2 = 0
}

赋值运算符

运算符描述
=简单的赋值运算符，将一个表达式的值赋给一个左值
+=相加后再赋值
-=相减后再赋值
*=相乘后再赋值
/=相除后再赋值
%=求余后再赋值
<<=左移后赋值
> > =右移后赋值
&=按位与后赋值
\=
^=按位异或后赋值

运算符优先级

运算符优先级确定表达式中的分组。这会影响表达式的计算方式。某些运算符比其他运算符具有更高的优先级;
例如，乘法运算符比加法运算符有更高的优先级。

当同级别的运算符出现在同一个表达式中，从左到右的顺序计算，比如乘除一起，不管是乘在前面还是除在前面都是从左到右计算乘、除运算符。加减亦是如此。

例如：x = 7 + 3 * 2; 这里，计算结果x被分配13，而不是20，因为运算符 *具有比+
有更的优先级，所以它首先乘以3 * 2，然后加上7。

这里，具有最高优先级的运算符放在表的顶部，具有最低优先级的运算符出现在底部。 在表达式中，将首先计算较高优先级运算符。

分类描述关联性
后缀()[]->.++ –左到右
一元+ -!~++ --(type)*&sizeof右到左
乘法*/ %左到右
加法+ -左到右
移位<<>>左到右
关系<<=>>=左到右
相等==!=左到右
按位AND&左到右
按位XOR^左到右
按位OR\
逻辑AND&&左到右
逻辑OR\\
条件?:右到左
分配=+=-=*=/= %=>>= <<= &= ^= \=
逗号,左到右
相关文章