Go語言運算子

itbsl發表於2018-10-26
Go

目錄

運算子用於在程式執行時執行數學或邏輯運算。

Go 語言內建的運算子有：算術運算子、賦值運算子、邏輯運算子、關係運算子、位運算子、其他運算子

算術運算子

算數運算子是對數值型的變數進行運算的，比如:加減乘除，在Go程式中使用的非常多。

下表列出了所有Go語言的算術運算子。假定 A 值為 10，B 值為 3。

運算子 描述 例項
+ 相加 A + B 輸出結果13
– 相減 A – B 輸出結果 7
* 相乘 A * B 輸出結果 30
/ 相除 A / B 輸出結果 3
% 求餘 A % B 輸出結果 1
++ 自增 A++ 輸出結果 11
— 自減 A– 輸出結果 2

注意事項

  1. 對於除號”/”,它的整數除和小數除是有區別的：整數之間做除法時，只保留整數部分而捨棄小數部分(而非四捨五入)。例如:10 / 3 = 3; 10.0 / 3 = 3.333； 18 / 5 = 3

    var res int = 10 / 3 //正確
var res int = 10.0 / 3 //錯誤，右邊計算的結果是float型別，而左邊的變數是int型別，不可以賦值

  2. 對於一個數取模時(例如:A % B),可以等價A % B = A – A / B * B，這樣我們可以看到取模的一個本質運算。-10 % 3 和10 % -3的結果是不一樣的

    -10 % 3 = -10 - ( -10 / 3) * 3

        = -10 - (-3 * 3)

         = -10+9

     = -1
    10 % -3 = 10 - (10 / -3) * -3
     = 10 - (-3) * -3
     = 10 - 9
     = 1

  3. Golang的自增自減只能當做一個獨立語句使用，不能出現在賦值語句的右邊(例如:var res int = n++)，也不能像if i++ > 0 {}這樣使用

  4. Golang的++和—只能寫在變數的後面，不能寫在變數的前面，即:只有a++,沒有++a

  5. Golang的設計者去掉C/Java中的自增自減得容易混淆的寫法，讓Golang更加簡潔、統一。(強制性的)

如何計算A%B的結果呢？

公示:A % B = A – A / B * B

-10 % 3 = -10 - ( -10 / 3) * 3

        = -10 - (-3 * 3)

        = -10+9

        = -1
10 % -3 = 10 - (10 / -3) * -3
        = 10 - (-3) * -3
        = 10 - 9
        = 1

賦值運算子

賦值運算子就是將某個運算後的值，賦給指定的變數。

運算子 描述 例項
= 簡單的賦值運算子，將一個表示式的值賦給一個左值 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
<<= 左移後賦值 C <<= 2 等於 C = C << 2
>>= 右移後賦值 C >>= 2 等於 C = C >> 2
&= 按位與後賦值 C &= 2 等於 C = C & 2
^= 按位異或後賦值 C ^= 2 等於 C = C ^ 2
|= 按位或後賦值 C |= 2 等於 C = C | 2

邏輯運算子

用於連線多個條件(一般來講就是關係表示式)，最終的結果也是一個bool值。

下表列出了所有Go語言的邏輯運算子。假定 A 值為 True，B 值為 False。

運算子 描述 例項
&& 邏輯 AND 運算子。 如果兩邊的運算元都是 True，則條件 True，否則為 False。 (A && B) 為 False
|| 邏輯 OR 運算子。 如果兩邊的運算元有一個 True，則條件 True，否則為 False。 (A || B) 為 True
! 邏輯 NOT 運算子。 如果條件為 True，則邏輯 NOT 條件 False，否則為 True。 !(A && B) 為 True

短路與和短路或

&&也叫短路與:如果第一個條件為false,則第二個條件不會判斷，最終結果為false

||也叫短路或:如果第一個條件為true，則第二個條件不會判斷，最終結果為true

關係運算子

關係運算子的結果都是bool型，要麼是true，要麼是false；關係表示式經常用在if結構的條件中或迴圈結構的條件中

下表列出了所有Go語言的關係運算子。假定 A 值為 10，B 值為 20。

運算子 描述 例項
== 檢查兩個值是否相等，如果相等返回 true 否則返回 false。 (A == B) 為 false
!= 檢查兩個值是否不相等，如果不相等返回 true 否則返回 false。 (A != B) 為 true
> 檢查左邊值是否大於右邊值，如果是返回 true 否則返回 false。 (A > B) 為 false
< 檢查左邊值是否小於右邊值，如果是返回 true 否則返回 false。 (A < B) 為 true
>= 檢查左邊值是否大於等於右邊值，如果是返回 true 否則返回 false。 (A >= B) 為 false
<= 檢查左邊值是否小於等於右邊值，如果是返回 true 否則返回 false。 (A <= B) 為 true

位運算子

位運算子對整數在記憶體中的二進位制位進行操作。(這裡不理解的可以先看008.計算機進位制介紹)

下表列出了位運算子 &, |, 和 ^ 的計算：

p q p & q p | q p ^ q
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1

假定 A = 60; B = 13; 其二進位制數(求它們的補碼,實際上是對補碼進行運算)轉換為：

A   = 0011 1100

B   = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

計算機內部採用補碼進行運算

A+B
A的原碼為: 0011 1100   
A的反碼為: 0011 1100
A的補碼為: 0011 1100
B的原碼為: 0000 1101  
B的反碼為: 0000 1101
B的補碼為: 0000 1101
A + B
    0011 1100
    0000 1101
--------------
    0100 1001
    
0100 1001轉換為10進位制整數就是73
    
A-B = A + (-B)
A的原碼為: 0011 1100   
A的反碼為: 0011 1100
A的補碼為: 0011 1100
-B的原碼為: 1000 1101  
-B的反碼為: 1111 0010
-B的補碼為: 1111 0011
A - B = 
     0011 1100
     1111 0011
--------------
     0010 1111

0010 1111轉換為10進位制整數就是47

需要注意的是如果得到的結果是正數，則補碼就是原碼，但是如果得到的結果是負數，則需要將補碼-1取反變成原碼後再轉換成整數
B - A    
-A的原碼為: 1011 1100
-A的反碼為: 1100 0011
-A的補碼為: 1100 0100
B的原碼為: 0000 1101  
B的反碼為: 0000 1101
B的補碼為: 0000 1101
B - A =     
    1100 0100
    0000 1101
--------------
    1101 0001
根據補碼符號位可以看出結果為負數，所以需要先-1轉換為反碼1101 0000，然後符號位不變，取反為原碼為1010 1111即為-47

Go 語言支援的位運算子如下表所示。假定 A 為60，B 為13：

運算子 描述 例項
& 按位與運算子”&”是雙目運算子。 其功能是參與運算的兩數各對應的二進位相與。 (A & B) 結果為 12, 二進位制為 0000 1100
| 按位或運算子”|”是雙目運算子。 其功能是參與運算的兩數各對應的二進位相或 (A | B) 結果為 61, 二進位制為 0011 1101
^ 按位異或運算子”^”是雙目運算子。 其功能是參與運算的兩數各對應的二進位相異或，當兩對應的二進位相異時，結果為1。 (A ^ B) 結果為 49, 二進位制為 0011 0001
<< 左移運算子”<<“是雙目運算子。左移n位就是乘以2的n次方。 其功能把”<<“左邊的運算數的各二進位全部左移若干位，由”<<“右邊的數指定移動的位數，高位丟棄，低位補0。 A << 2 結果為 240 ，二進位制為 1111 0000
>> 右移運算子”>>”是雙目運算子。右移n位就是除以2的n次方。 其功能是把”>>”左邊的運算數的各二進位全部右移若干位，”>>”右邊的數指定移動的位數。 A >> 2 結果為 15 ，二進位制為 0000 1111 
package main

import "fmt"

func main() {

   var a uint = 60    /* 60 = 0011 1100 */  
   var b uint = 13    /* 13 = 0000 1101 */
   var c uint = 0          

   c = a & b       /* 12 = 0000 1100 */ 
   fmt.Printf("第一行 - c 的值為 %d
", c )

   c = a | b       /* 61 = 0011 1101 */
   fmt.Printf("第二行 - c 的值為 %d
", c )

   c = a ^ b       /* 49 = 0011 0001 */
   fmt.Printf("第三行 - c 的值為 %d
", c )

   c = a << 2     /* 240 = 1111 0000 */
   fmt.Printf("第四行 - c 的值為 %d
", c )

   c = a >> 2     /* 15 = 0000 1111 */
   fmt.Printf("第五行 - c 的值為 %d
", c )
}
第一行 - c 的值為 12
第二行 - c 的值為 61
第三行 - c 的值為 49
第四行 - c 的值為 240
第五行 - c 的值為 15

其他運算子

下表列出了Go語言的其他運算子。

運算子 描述 例項
& 返回變數儲存地址 &a; 將給出變數的實際地址。
* 指標變數。 *a; 是一個指標變數

運算子優先順序

運算子有不同的優先順序，所謂優先順序就是表示式運算中的運算順序。如下表，上一行運算子的優先順序總是優於下一行。

只有單目運算子、賦值運算子是從右向左運算的。

分類 描述 關聯性
字尾 () [] -> . ++ — 左到右
單目 + – ! ~ (type) * & sizeof 右到左
乘法 * / % 左到右
加法 + – 左到右
移位 << >> 左到右
關係 < <= > >= 左到右
相等 == != 左到右
按位AND & 左到右
按位XOR ^ 左到右
按位OR | 左到右
邏輯AND && 左到右
邏輯OR || 左到右
賦值運算子 = += -= *= /= %= >>= <<= &= ^= |= 右到左
逗號 , 左到右

說明：Go語言不支援三元運算子。

Golang設計理念

一種事情有且只有一種方法完成

相關文章