วิธีใช้ตัวดำเนินการใน 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

ตัวดำเนินการเชิงสัมพันธ์

ตัวดำเนินการเชิงสัมพันธ์ใช้เพื่อเปรียบเทียบค่าสองค่า มาดูตัวดำเนินการแต่ละตัวทีละตัว:

• ตัวดำเนินการ '=='(Equals) จะตรวจสอบว่าตัวดำเนินการทั้งสองตัวที่กำหนดเท่ากันหรือไม่ ถ้าเท่ากันจะคืนค่าเป็นจริง หากไม่เป็นเช่นนั้นจะส่งกลับเป็นเท็จ ตัวอย่างเช่น 5==5 จะส่งคืนค่าเป็นจริง
• ตัวดำเนินการ '!='(ไม่เท่ากับ) จะตรวจสอบว่าตัวดำเนินการทั้งสองตัวที่กำหนดเท่ากันหรือไม่ ไม่เช่นนั้นมันจะกลับมาเป็นจริง หากไม่เป็นเช่นนั้นจะส่งกลับเป็นเท็จ นี่คือส่วนเสริมแบบบูลีนที่แน่นอนของตัวดำเนินการ '==' ตัวอย่างเช่น 5!=5 จะส่งคืนค่า false
• ตัวดำเนินการ '>'(มากกว่า) จะตรวจสอบว่าตัวดำเนินการตัวแรกมากกว่าตัวดำเนินการตัวที่สองหรือไม่ ถ้ามากกว่าจะคืนค่าเป็นจริง หากน้อยกว่าจะส่งคืนค่า false เช่น 6>5 จะส่งคืนค่าเป็นจริง
• ตัวดำเนินการ '<' (น้อยกว่า) จะตรวจสอบว่าตัวดำเนินการตัวแรกน้อยกว่าตัวดำเนินการตัวที่สองหรือไม่ ถ้าน้อยกว่าก็จะกลับมาเป็นจริง หากไม่เป็นเช่นนั้นจะส่งกลับเป็นเท็จ เช่น <5 จะส่งกลับ
• ตัวดำเนินการ '>='(มากกว่าเท่ากับ) จะตรวจสอบว่าตัวดำเนินการตัวแรกมากกว่าหรือเท่ากับตัวดำเนินการตัวที่สองหรือไม่ ถ้ามากกว่าหรือเท่ากับจะคืนค่าเป็นจริง ถ้าน้อยกว่าหรือเท่ากับจะส่งคืนค่า false ตัวอย่าง: 5>=5 จะส่งคืนค่าเป็นจริง
• ตัวดำเนินการ '<='(น้อยกว่าหรือเท่ากับ) จะตรวจสอบว่าตัวดำเนินการตัวแรกน้อยกว่าหรือเท่ากับตัวดำเนินการตัวที่สองหรือไม่ ถ้ามากกว่าหรือเท่ากับจะคืนค่าเป็นจริง ถ้าน้อยกว่าหรือเท่ากับจะคืนค่าเป็นเท็จ ตัวอย่าง: <=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: ตัวดำเนินการ '&&' คืนค่าเป็นจริงเมื่อเงื่อนไขภายใต้การพิจารณาทั้งสองข้อเป็นที่พอใจ หากไม่เป็นเช่นนั้นจะส่งกลับเป็นเท็จ ตัวอย่างเช่น a && b จะส่งคืนค่าเป็นจริงเมื่อทั้ง a และ b เป็นจริง (กล่าวคือ ไม่ใช่ศูนย์)
• หรือ: ตัวดำเนินการ '||' คืนค่าเป็นจริงเมื่อเงื่อนไขหนึ่งข้อ (หรือทั้งสองข้อ) ภายใต้การพิจารณาเป็นที่พอใจ หากไม่เป็นเช่นนั้นจะส่งกลับเป็นเท็จ ตัวอย่าง: || b คืนค่าเป็นจริงถ้า a หรือ b เป็นจริง (กล่าวคือ ไม่ใช่ศูนย์) แน่นอนว่ามันจะคืนค่าเป็นจริงเมื่อทั้ง a และ b เป็นจริง
• ตรรกะ NOT: '!' ตัวดำเนินการ คืนค่าเป็นจริงเมื่อไม่เป็นไปตามเงื่อนไขที่กำลังพิจารณา หากไม่เป็นเช่นนั้นจะส่งกลับเป็นเท็จ ตัวอย่าง: !a คืนค่า true ถ้า a เป็น false นั่นคือเมื่อ a = 0

ตัวอย่างเช่น:

// 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 ตัวที่ทำงานที่ระดับบิตหรือใช้ในการดำเนินการแบบบิตต่อบิต ต่อไปนี้คือตัวดำเนินการระดับบิต:

• & (AND ตามบิต): รับตัวเลขสองตัวเป็นตัวดำเนินการและดำเนินการ AND กับทุกบิตของตัวเลขทั้งสองตัว ผลลัพธ์ของ AND จะเป็น 1 เฉพาะเมื่อบิตทั้งสองเป็น 1
• - (แบบบิต OR): รับตัวเลขสองตัวเป็นตัวดำเนินการและดำเนินการ OR กับทุกบิตของตัวเลขทั้งสองตัว ผลลัพธ์ของ OR คือ 1 ถ้าบิตใดบิตหนึ่งมีค่าเป็น 1
• ^ (XOR ตามบิต): รับตัวเลขสองตัวเป็นตัวดำเนินการและดำเนินการ XOR กับทุกบิตของตัวเลขทั้งสองตัว ผลลัพธ์ของ XOR คือ 1 หากสองบิตแตกต่างกัน
• < (เลื่อนซ้าย): ใช้ตัวเลขสองตัว เลื่อนบิตของตัวดำเนินการตัวแรกไปทางซ้าย ตัวดำเนินการตัวที่สองกำหนดจำนวนตำแหน่งที่จะเลื่อน
• >> (เลื่อนขวา): ใช้ตัวเลข 2 ตัว เลื่อนบิตของตัวดำเนินการตัวแรกไปทางขวา ตัวดำเนินการตัวที่สองจะกำหนดจำนวนตำแหน่งที่จะเลื่อน
• &^ (AND NOT) นี่เป็นตัวดำเนินการระดับบิตที่ชัดเจน

ตัวอย่างเช่น:

// 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

ผู้ดำเนินการมอบหมาย

ตัวดำเนินการกำหนดค่าใช้ในการกำหนดค่าให้กับตัวแปร ตัวดำเนินการทางซ้ายของตัวดำเนินการกำหนดค่าเป็นตัวแปร และตัวดำเนินการทางขวาของตัวดำเนินการกำหนดค่าเป็นค่า ค่าทางด้านขวาจะต้องมีชนิดข้อมูลเดียวกันกับตัวแปรทางด้านซ้าย มิฉะนั้น คอมไพเลอร์จะส่งกลับข้อผิดพลาด ตัวดำเนินการกำหนดค่าประเภทต่างๆ มีแสดงด้านล่างนี้:

• “="(การกำหนดค่าแบบง่าย): นี่เป็นตัวดำเนินการกำหนดค่าแบบง่ายที่สุด ตัวดำเนินการนี้ใช้ในการกำหนดค่าทางด้านขวาให้กับตัวแปรทางด้านซ้าย
• “+=”(การกำหนดค่าเพิ่มเติม): ตัวดำเนินการนี้เป็นการผสมผสานระหว่างตัวดำเนินการ '+' และ '=' ตัวดำเนินการนี้จะเพิ่มค่าปัจจุบันของตัวแปรทางด้านซ้ายลงในค่าของตัวแปรทางด้านขวาก่อน จากนั้นจึงกำหนดผลลัพธ์ให้กับตัวแปรทางด้านซ้าย
• “-=”(การกำหนดค่าลบ): ตัวดำเนินการนี้เป็นการผสมผสานระหว่างตัวดำเนินการ '-' และ '=' ตัวดำเนินการนี้จะลบค่าปัจจุบันของตัวแปรทางซ้ายออกจากค่าทางขวาก่อน แล้วจึงกำหนดผลลัพธ์ให้กับตัวแปรทางซ้าย
• “*=”(การมอบหมายการคูณ) ตัวดำเนินการนี้เป็นการผสมผสานระหว่างตัวดำเนินการ '*' และ '=' ตัวดำเนินการนี้จะคูณค่าปัจจุบันของตัวแปรทางซ้ายด้วยค่าทางขวาก่อน แล้วจึงกำหนดผลลัพธ์ให้กับตัวแปรทางซ้าย
• “/=” (การมอบหมายการหาร): ตัวดำเนินการนี้เป็นการผสมผสานระหว่างตัวดำเนินการ '/' และ '=' ตัวดำเนินการนี้จะหารค่าปัจจุบันของตัวแปรทางซ้ายด้วยค่าทางขวาก่อน แล้วจึงกำหนดผลลัพธ์ให้กับตัวแปรทางซ้าย
• “%=”(การกำหนดค่าส่วนที่เหลือ): ตัวดำเนินการนี้เป็นการผสมผสานระหว่างตัวดำเนินการ '%' และ '=' ตัวดำเนินการนี้จะรับค่าที่เหลือของค่าปัจจุบันของตัวแปรทางซ้ายจากค่าทางขวาก่อน แล้วจึงกำหนดผลลัพธ์ให้กับตัวแปรทางซ้าย
• “&=”(Bitwise AND): ตัวดำเนินการนี้เป็นการผสมผสานระหว่างตัวดำเนินการ '&' และ '=' ตัวดำเนินการนี้จะทำการ “AND แบบบิตต่อบิต” ก่อน โดยจะคำนวณค่าปัจจุบันของตัวแปรทางด้านซ้ายไปยังค่าทางด้านขวา จากนั้นจึงกำหนดผลลัพธ์ให้กับตัวแปรทางด้านซ้าย
• “^=”(ค่า OR เฉพาะระดับบิต): ตัวดำเนินการนี้เป็นการผสมผสานระหว่างตัวดำเนินการ '^' และ '=' ตัวดำเนินการนี้จะทำ “Bitwise Exclusive OR” ก่อน โดยกำหนดค่าปัจจุบันของตัวแปรทางซ้ายด้วยค่าของตัวแปรทางขวา แล้วจึงกำหนดผลลัพธ์ให้กับตัวแปรทางซ้าย
• “|=”(รวมค่าบิต OR): ตัวดำเนินการนี้เป็นการผสมผสานระหว่าง '|' ตัวดำเนินการและ '=' ตัวดำเนินการนี้จะทำ “Bitwise Inclusive OR” ก่อน โดยกำหนดค่าปัจจุบันของตัวแปรทางซ้ายด้วยค่าของตัวแปรทางขวา แล้วจึงกำหนดผลลัพธ์ให้กับตัวแปรทางซ้าย
• “<=: ตัวดำเนินการนี้เป็นการผสมผสานระหว่างตัวดำเนินการ < ' และ '="'” ตัวดำเนินการนี้จะ “เลื่อน” ค่าปัจจุบันของตัวแปรทางด้านซ้ายด้วยค่าทางด้านขวาก่อน จากนั้นจึงกำหนดผลลัพธ์ให้กับตัวแปรทางด้านขวา
• “>>=”: ตัวดำเนินการนี้เป็นการผสมผสานระหว่างตัวดำเนินการ '>>' และ '=' ตัวดำเนินการนี้จะทำการ “เลื่อนขวาและ” ค่าปัจจุบันของตัวแปรทางซ้ายด้วยค่าทางขวาก่อน จากนั้นจึงกำหนดผลลัพธ์ให้กับตัวแปรทางซ้าย

ตัวอย่างเช่น:

// 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

ผู้ประกอบการอื่น ๆ

• &: ตัวดำเนินการนี้ส่งคืนที่อยู่ของตัวแปร
• *: ตัวดำเนินการนี้ทำหน้าที่ระบุตัวชี้ไปยังตัวแปร
• <-: ชื่อของตัวดำเนินการนี้คือรับ ใช้เพื่อรับค่าจาก

// 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