go語言的運算符

什麼是運算符：運算符用於在程序運行時執行數學或邏輯運算

go語言的運算符以下：

算術運算符
關係運算符
邏輯運算符
位運算符
賦值運算符
其餘運算符　　

 

一，算數運算符

運算符	描述	實例
+	相加	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("第六行 - a 的值爲 %d\n", a )
   a=21   // 爲了方便測試，a 這裏從新賦值爲 21
   a--
   fmt.Printf("第七行 - a 的值爲 %d\n", a )
}

二，關係運算符

    關係運算符主要是用於判斷語句或者條件語句中

運算符	描述	實例
==	檢查兩個值是否相等，若是相等返回 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 大於等於 a\n" )
   }
}

三，邏輯運算符

  主要是用於判斷語句和條件語句，能將多個條件組合起來一塊進行判斷

運算符	描述	實例
&&	邏輯 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" )
   }
}　　

四，位運算符

   什麼是位運算符：位運算符對整數在內存中的二進制位進行操做

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

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 = 0011 1100

B = 0000 1101

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

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

Go 語言支持的位運算符以下：

&	按位與運算符"&"是雙目運算符。 其功能是參與運算的兩數各對應的二進位相與。	(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 = 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　

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 )

}

六， 其餘運算符

&	返回變量存儲地址	&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);
}

指針變量 * 和地址值 & 的區別：指針變量保存的是一個地址值，會分配獨立的內存來存儲一個整型數字。當變量前面有 * 標識時，纔等同於 & 的用法，不然會直接輸出一個整型數字

func main() {
   var a int = 4
   var ptr *int
   ptr = &a
   println("a的值爲", a);    // 4
   println("*ptr爲", *ptr);  // 4
   println("ptr爲", ptr);    // 824633794744
}

七，運算符的優先級

    有些運算符擁有較高的優先級，二元運算符的運算方向均是從左至右。下表列出了全部運算符以及它們的優先級，由上至下表明優先級由高到低：

優先級	運算符
7	^ !
6	* / % << >> & &^
5	+ - | ^
4	== != < <= >= >
3	<-
2	&&
1	||

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 );  
}