Go 語言運算子

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

Go 語言內建的運算子有：

• 算術運算子

• 關係運算子

• 邏輯運算子

• 位元運算子

• #賦值運算子

• 其他運算子

接下來讓我們來詳細看看各個運算子的介紹。

---

算術運算子

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

##+#相加相減相乘相除求餘自增#自減

運算子	#描述	#實例
A + B 輸出結果30		-
A - B 輸出結果-10		*
A * B 輸出結果200		/
B / A 輸出結果2		%
B % A 輸出結果0		++
A++ 輸出結果11		--

A-- 輸出結果9

---

以下實例示範了各個算術運算子的用法：

package main

import "fmt"

func main() {

   var a int = 21
   var b int = 10
   var c int

   c = a + b
   fmt.Printf("第一行 - c 的值为 %d\n", c )
   c = a - b
   fmt.Printf("第二行 - c 的值为 %d\n", c )
   c = a * b
   fmt.Printf("第三行 - c 的值为 %d\n", c )
   c = a / b
   fmt.Printf("第四行 - c 的值为 %d\n", c )
   c = a % b
   fmt.Printf("第五行 - c 的值为 %d\n", c )
   a++
   fmt.Printf("第六行 - c 的值为 %d\n", a )
   a--
   fmt.Printf("第七行 - c 的值为 %d\n", a )
}

以上實例執行結果：

第一行 - c 的值为 31
第二行 - c 的值为 11
第三行 - c 的值为 210
第四行 - c 的值为 2
第五行 - c 的值为 1
第六行 - c 的值为 22
第七行 - c 的值为 21

關係運算子下表列出了所有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############

以下實例示範了關係運算子的用法：

package main

import "fmt"

func main() {
   var a int = 21
   var b int = 10

   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" )
   }
   /* Lets change value of a and b */
   a = 5
   b = 20
   if ( a <= b ) {
      fmt.Printf("第四行 - a 小于等于  b\n" )
   }
   if ( b >= a ) {
      fmt.Printf("第五行 - b 大于等于 b\n" )
   }
}

以上實例運行結果：

第一行 - a 不等于 b
第二行 - a 不小于 b
第三行 - a 大于 b
第四行 - a 小于等于  b
第五行 - b 大于等于 b

---

邏輯運算子

下表列出了所有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

#以下實例示範了邏輯運算子的用法：

package main

import "fmt"

func main() {
   var a bool = true
   var b bool = false
   if ( a && b ) {
      fmt.Printf("第一行 - 条件为 true\n" )
   }
   if ( a || b ) {
      fmt.Printf("第二行 - 条件为 true\n" )
   }
   /* 修改 a 和 b 的值 */
   a = false
   b = true
   if ( a && b ) {
      fmt.Printf("第三行 - 条件为 true\n" )
   } else {
      fmt.Printf("第三行 - 条件为 false\n" )
   }
   if ( !(a && b) ) {
      fmt.Printf("第四行 - 条件为 true\n" )
   }
}

以上實例執行結果：

第二行 - 条件为 true
第三行 - 条件为 false
第四行 - 条件为 true

---

位元運算子

位元運算子對整數在記憶體中的二進位位元進行操作。

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

##qp & qp | qp ^ q#00#0 000#101111#1##0#10011#

假定 A = 60;  B = 13; 其二進制數轉換為：

A = 0011 1100

B = 0000 1101

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

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

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

p
		##1

##實例 ##&位元與運算子"&"是雙目運算子。 其功能為參與運算的兩數各對應的二進位相與。 (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\n", c )

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

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

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

   c = a >> 2     /* 15 = 0000 1111 */
   fmt.Printf("第五行 - c 的值为 %d\n", c )
}

以上實例運行結果：

第一行 - c 的值为 12
第二行 - c 的值为 61
第三行 - c 的值为 49
第四行 - c 的值为 240
第五行 - c 的值为 15

---

賦值運算子

下表列出了所有Go語言的賦值運算子。

##=+ =##C += A 等於C = C + A-=#相減後再賦值C -= A 等於C = C - A*=相乘後再賦值相除後再賦值求餘後再賦值左移後賦值右移後賦值按位與後賦值位異或後賦值按位或後賦值

運算子	#描述	#實例
##簡單的賦值運算符，將一個表達式的值賦給一個左值	C = A + B 將A + B 表達式結果賦值給C
相加後再賦值
##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

---

以下實例示範了賦值運算子的用法：

package main

import "fmt"

func main() {
   var a int = 21
   var c int

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

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

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

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

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

   c  = 200; 

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

   c >>=  2
   fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %d\n", c )

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

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

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

}

以上實例執行結果：

第 1 行 - =  运算符实例，c 值为 = 21
第 2 行 - += 运算符实例，c 值为 = 42
第 3 行 - -= 运算符实例，c 值为 = 21
第 4 行 - *= 运算符实例，c 值为 = 441
第 5 行 - /= 运算符实例，c 值为 = 21
第 6行  - <<= 运算符实例，c 值为 = 800
第 7 行 - >>= 运算符实例，c 值为 = 200
第 8 行 - &= 运算符实例，c 值为 = 0
第 9 行 - ^= 运算符实例，c 值为 = 2
第 10 行 - |= 运算符实例，c 值为 = 2

其他運算子下表列出了Go語言的其他運算子。 描述#傳回變數儲存位址指標變數。

		運算子
#實例		&
&a; 將給出變數的實際位址。		*

*a; 是指標變數

---

以下實例示範了其他運算子的用法：

package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int

   /* 运算符实例 */
   fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
   fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
   fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );

   /*  & 和 * 运算符实例 */
   ptr = &a	/* 'ptr' 包含了 'a' 变量的地址 */
   fmt.Printf("a 的值为  %d\n", a);
   fmt.Printf("*ptr 为 %d\n", *ptr);
}

以上實例執行結果：

第 1 行 - a 变量类型为 = int
第 2 行 - b 变量类型为 = int32
第 3 行 - c 变量类型为 = float32
a 的值为  4
*ptr 为 4

運算子優先權有些運算子擁有較高的優先權，二元運算子的運算方向皆由左至右。下表列出了所有運算子以及它們的優先級，由上至下代表優先順序由高到低：優先權765432

運算符
^ !
* / % << > > & &^
+ - | ^
== ! = < <= >= >
<-

package main

import "fmt"

func main() {
   var a int = 20
   var b int = 10
   var c int = 15
   var d int = 5
   var e int;

   e = (a + b) * c / d;      // ( 30 * 15 ) / 5
   fmt.Printf("(a + b) * c / d 的值为 : %d\n",  e );

   e = ((a + b) * c) / d;    // (30 * 15 ) / 5
   fmt.Printf("((a + b) * c) / d 的值为  : %d\n" ,  e );

   e = (a + b) * (c / d);   // (30) * (15/5)
   fmt.Printf("(a + b) * (c / d) 的值为  : %d\n",  e );

   e = a + (b * c) / d;     //  20 + (150/5)
   fmt.Printf("a + (b * c) / d 的值为  : %d\n" ,  e );  
}

(a + b) * c / d 的值为 : 90
((a + b) * c) / d 的值为  : 90
(a + b) * (c / d) 的值为  : 90
a + (b * c) / d 的值为  : 50