如何在 Golang 中使用運算符

運算符是每種程式語言的基礎。因此，如果不使用運算符，Golang語言的功能是不完整的。運算符允許我們對操作數執行不同類型的操作。在 Go語言中，運算子可以根據其不同的功能進行分類。

算術運算符

Go 語言中使用這些運算子對運算元進行運算：

• 加法：“+”將兩個操作數相加。例如：x+y。
• 減法：“-”減去兩個操作數。例如：xy。
• 乘法：「*」將兩個運算元相乘。例如：x*y。
• 除法：「/」將第一個運算元除以第二個運算元。例如：x/y。
• 餘數：'%' 運算子傳回第一個運算元除以第二個運算元後的餘數。例如：x%y。

 注意： -、+、!、&、*、<- 和 ^ 也稱為一元運算符，一元運算符的優先權更高。 ++ 和 — 運算子來自語句，它們不是表達式，因此它們位於運算子層次結構之外。

例如：

//Minh họa chương trình Go dùng toán tử số học
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// Phép cộng
result1:= p + q 
fmt.Printf("Result of p + q = %d", result1) 
	
// Phép trừ
result2:= p - q 
fmt.Printf("\nResult of p - q = %d", result2) 
	
// Phép nhân
result3:= p * q 
fmt.Printf("\nResult of p * q = %d", result3) 
	
// Division 
result4:= p / q 
fmt.Printf("\nResult of p / q = %d", result4) 
	
// Modulus 
result5:= p % q 
fmt.Printf("\nResult of p %% q = %d", result5) 
} 

結果：

Kết quả của p + q = 54
Kết quả của p - q = 14
Kết quả của p * q = 680
Kết quả của p / q = 1
Kết quả của p % q = 14

關係運算符

關係運算子用於比較兩個值。讓我們逐一看一下每個運算符：

• 「==」（等於）運算子檢查兩個給定的運算元是否相等。如果相等，則傳回 true。否則，返回 false。例如，5==5 將傳回 true。
• '!='（不等於）運算子檢查兩個給定的運算元是否相等。否則，傳回 true。否則，返回 false。這是“==”運算符的精確布林補碼。例如，5!=5 將傳回 false。
• '>'（大於）運算子檢查第一個運算元是否大於第二個運算元。如果更大，則傳回 true。如果少於，則傳回 false。例如，6>5 將傳回 true。
• '<'（小於）運算子檢查第一個運算元是否小於第二個運算元。如果較小，則傳回 true。如果不是，則傳回 false。例如，<5 將返回
• '>='（大於等於）運算子檢查第一個運算元是否大於或等於第二個運算元。如果大於或等於，則傳回 true。如果小於或等於，則傳回 false。例如：5>=5 將傳回 true。
• '<='（小於或等於）運算子檢查第一個運算元是否小於或等於第二個運算元。如果大於或等於，則傳回 true。如果小於或等於，則傳回 false。例如：<=5 也會返回

例如：

// Minh họa chương trình Go dùng toán tử quan hệ
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// ‘=='(Equal To) 
result1:= p == q 
fmt.Println(result1) 
	
// ‘!='(Not Equal To) 
result2:= p != q 
fmt.Println(result2) 
	
// ‘<‘(less than)="" result3:="p">< q="" fmt.println(result3)="" ‘="">'(Greater Than) 
result4:= p > q 
fmt.Println(result4) 
	
// ‘>='(Greater Than Equal To) 
result5:= p >= q 
fmt.Println(result5) 
	
// ‘<='(less than="" equal="" to)="" result6:="p"><= q="" fmt.println(result6)="" }="">

結果：

false
true
false
true
true
false

邏輯運算符

它們用於組合兩個或多個條件/約束或補充所考慮的初始條件的評估。

• AND：當考慮的兩個條件都滿足時，「&&」運算子傳回 true。否則，返回 false。例如，當 a 和 b 都為真（即非零）時，a && b 傳回 true。
• 或：運算子「||」當考慮的一個（或兩個）條件滿足時傳回 true。否則，返回 false。例如：a ||如果 a 或 b 為真（即非零），則 b 傳回 true。當然，當a和b都為真時，它會回傳true。
• 邏輯非：'！ '當考慮的條件不滿足時，運算子傳回 true。否則，返回 false。例如：如果 a 為假，即 a = 0，則 !a 傳回 true。

例如：

// Minh họa chương trình Go dùng toán tử logic
package main 
import "fmt"
func main() { 
	var p int = 23
	var q int = 60
		
	if(p!=q && p<=q){ fmt.println("true")="" }="" if(p!="q" ||=""><=q){ fmt.println("true")="" }="" if(!(p="=q)){" fmt.println("true")="" }="" }="">

結果：

True
True
True

位元運算符

Go語言中有6個位元運算符，它們在位元層級進行操作，或用於執行逐位運算。以下是位元運算子：

• &（位元與）：以兩個數字作為操作數，並對兩個數字的每一位執行「與」運算。只有當兩位均為 1 時，AND 的結果才為 1。
• | （位元或）：以兩個數字作為操作數，並對兩個數字的每一位執行或運算。若兩個位元中任一個為 1，則「或」的結果為 1。
• ^（位元異或）：以兩個數字作為操作數，並對兩個數字的每一位執行異或運算。如果兩位不同，則 XOR 的結果為 1。
• <（左移）：取兩個數字，將第一個操作數的位元左移，第二個操作數決定要移動的位數
• >>（右移）：取兩個數字，將第一個操作數的位元向右移動，第二個操作數決定要移動的位數。
• &^（與非）：這是一個明確的位元運算子。

例如：

// Minh họa chương trình Go dùng toán tử bitwise
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// & (bitwise AND) 
result1:= p & q 
fmt.Printf("Result of p & q = %d", result1) 
	
// | (bitwise OR) 
result2:= p | q 
fmt.Printf("\nResult of p | q = %d", result2) 
	
// ^ (bitwise XOR) 
result3:= p ^ q 
fmt.Printf("\nResult of p ^ q = %d", result3) 
	
// < (left="" shift)="" result4:="p">< 1="" fmt.printf("\nresult="" of="" p="">< 1="%d" ,"="" result4)="">> (right shift) 
result5:= p >> 1
fmt.Printf("\nResult of p >> 1 = %d", result5) 
	
// &^ (AND NOT) 
result6:= p &^ q 
fmt.Printf("\nResult of p &^ q = %d", result6) 
	
	
} 

結果：

Kết quả của p & q = 0
Kết quả của p | q = 54
Kết quả của p ^ q = 54
Kết quả của p < 1="68" kết="" quả="" của="" p="">> 1 = 17
Kết quả của p &^ q = 34

賦值運算符

賦值運算子用於為變數賦值。賦值運算子的左操作數是一個變量，賦值運算子的右操作數是一個值。右邊的值必須與左邊的變數具有相同的資料類型，否則編譯器將回傳錯誤。不同類型的賦值運算子如下所示：

• 「=」（簡單賦值）：這是最簡單的賦值運算子。此運算子用於將右邊的值賦給左邊的變數。
• 「+=」（附加賦值）：此運算子是運算子『+』和『=』的組合。這個運算子首先將左邊變數的目前值與右邊的值相加，然後將結果賦給左邊變數。
• 「-=」（減號賦值）：此運算子是運算子『-』和『=』的組合。此運算子首先從右側變數的值中減去左側變數的目前值，然後將結果賦給左側變數。
• 「*=」（乘法賦值）：此運算子是運算子『*』和『=』的組合。這個運算子首先將左邊變數的目前值乘以右邊的值，然後將結果賦給左邊變數。
• 「/=」（除法賦值）：此運算子是 '/' 和 '=' 運算子的組合。這個運算子先將左邊變數的目前值除以右邊的值，然後將結果賦給左邊變數。
• 「%=」（餘數賦值）：此運算子是『%』和『=』運算子的組合。此運算子首先根據右側的值取左側變數目前值的餘數，然後將結果賦給左側變數。
• “&=”（位元與）：此運算子是“&”和“=”運算子的組合。此運算子首先將左邊變數的目前值與右邊的值進行「位元與」運算，然後將結果賦給左邊變數。
• “^=”（位元異或）：此運算子是“^”和“=”運算符的組合。這個運算子首先將左邊變數的目前值與右邊變數的值進行“位元異或”，然後將結果賦給左邊變數。
• 「|=」（位元或）：此運算子是「|」的組合運算子和『=』。這個運算子首先將左邊變數的目前值與右邊變數的值進行“位元或”，然後將結果賦給左邊變數。
• 「<=：此運算子是「<」和「=」運算子的組合。此運算子首先將左側變數的目前值「移動」右側的值，然後將結果賦給右側的變數。
• “>>=”：此運算子是運算子“>>”和“=”的組合。此運算子首先將左邊變數的目前值與右邊的值進行「右移與」運算，然後將結果賦給左邊變數。

例如：

// Minh họa chương trình Go dùng toán tử gán
package main 
	
import "fmt"
	
func main() { 
var p int = 45
	var q int = 50
	
// “=”(Simple Assignment) 
p = q 
fmt.Println(p) 
	
// “+=”(Add Assignment) 
	p += q 
fmt.Println(p) 
	
//“-=”(Subtract Assignment) 
p-=q 
fmt.Println(p) 
	
// “*=”(Multiply Assignment) 
p*= q 
fmt.Println(p) 
	
// “/=”(Division Assignment) 
	p /= q 
fmt.Println(p) 
	
	// “%=”(Modulus Assignment) 
	p %= q 
fmt.Println(p) 
	
} 

結果：

50
100
50
2500
50
0

其他營運商

• &：此運算子傳回變數的位址。
• *：此運算子提供指向變數的指標。
• <-：這個操作符的名稱是receive。它用於從

// Minh họa chương trình sử dụng toán tử khác
package main 
	
import "fmt"
	
func main() { 
a := 4
	
// Dùng địa chỉ của toán tử (&) toán tử trỏ gián tiếp (*)

b := &a 
fmt.Println(*b) 
*b = 7
fmt.Println(a) 
} 

結果：

4
7