Cara menggunakan operator di Golang

Operator adalah asas bagi setiap bahasa pengaturcaraan. Oleh itu, kefungsian bahasa Golang tidak lengkap tanpa penggunaan operator. Operator membenarkan kami melakukan pelbagai jenis operasi pada operan. Dalam bahasa Go, pengendali boleh dikelaskan berdasarkan fungsi berbeza mereka .

Operator aritmetik

Operator ini digunakan untuk melaksanakan operasi pada operan dalam bahasa Go:

• Penambahan: '+' menambah dua operan. Contohnya: x+y.
• Penolakan: '-' menolak dua operan. Contoh: xy.
• Pendaraban: '*' mendarab dua operan. Contohnya: x*y.
• Pembahagian: '/' membahagikan operan pertama dengan operan kedua. Contohnya: x/y.
• Baki: Operator '%' mengembalikan baki apabila operan pertama dibahagikan dengan operan kedua. Contohnya: x%y.

 Nota: -, +, !, &, *, <- dan ^ juga dipanggil operator unary dan keutamaan operator unary adalah lebih tinggi. Pengendali ++ dan — berasal daripada pernyataan, ia bukan ungkapan, jadi ia terletak di luar hierarki operator.

Contohnya:

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

Keputusan:

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

Operator Perhubungan

Operator perhubungan digunakan untuk membandingkan dua nilai. Mari kita lihat setiap operator satu demi satu:

• Operator '=='(Equals) menyemak sama ada dua operan yang diberikan adalah sama atau tidak. Jika sama, ia kembali benar. Jika tidak, ia kembali palsu. Contohnya, 5==5 akan kembali benar.
• Operator '!='(Tidak sama dengan) menyemak sama ada dua operan yang diberikan adalah sama atau tidak. Jika tidak, ia kembali benar. Jika tidak, ia kembali palsu. Ini ialah pelengkap boolean tepat bagi operator '=='. Contohnya, 5!=5 akan mengembalikan palsu.
• Operator '>'(Lebih besar daripada) menyemak sama ada operan pertama lebih besar daripada operan kedua. Jika lebih besar, ia kembali benar. Jika kurang, ia kembali palsu. Contohnya, 6>5 akan kembali benar.
• Operator '<'(kurang daripada) menyemak sama ada operan pertama kurang daripada operan kedua. Jika kurang, ia kembali benar. Jika tidak, ia kembali palsu. Sebagai contoh, <5 akan kembali
• Operator '>='(Lebih besar daripada sama) menyemak sama ada operan pertama lebih besar daripada atau sama dengan operan kedua. Jika lebih besar daripada atau sama, ia kembali benar. Jika kurang daripada atau sama, ia mengembalikan palsu. Contohnya: 5>=5 akan kembali benar.
• Operator '<='(kurang daripada atau sama dengan) menyemak jika operan pertama kurang daripada atau sama dengan operan kedua. Jika ia lebih besar daripada atau sama, ia kembali benar. Jika ia kurang daripada atau sama, ia mengembalikan palsu. Contohnya: <=5 juga akan kembali

Contohnya:

// 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)="" }="">

Keputusan:

false
true
false
true
true
false

Pengendali logik

Ia digunakan untuk menggabungkan dua atau lebih syarat/kekangan atau untuk menambah penilaian keadaan awal yang sedang dipertimbangkan.

• DAN: Operator '&&' kembali benar apabila kedua-dua syarat yang dipertimbangkan dipenuhi. Jika tidak, ia kembali palsu. Contohnya, a && b kembali benar apabila kedua-dua a dan b adalah benar (iaitu bukan sifar).
• ATAU: Operator '||' Mengembalikan benar apabila satu (atau kedua-duanya) syarat yang dipertimbangkan dipenuhi. Jika tidak, ia kembali palsu. Contohnya: a || b kembali benar jika sama ada a atau b adalah benar (iaitu bukan sifar). Sudah tentu, ia kembali benar apabila kedua-dua a dan b adalah benar.
• BUKAN Logik: '!' operator Mengembalikan benar apabila syarat yang dipertimbangkan tidak dipenuhi. Jika tidak, ia kembali palsu. Contohnya: !a mengembalikan benar jika a palsu, iaitu apabila a = 0.

Contohnya:

// 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")="" }="" }="">

Keputusan:

True
True
True

Pengendali bitwise

Dalam bahasa Go, terdapat 6 operator bitwise yang beroperasi pada tahap bit atau digunakan untuk melaksanakan operasi bit demi bit. Berikut ialah pengendali bitwise:

• & (bitwise AND): Mengambil dua nombor sebagai operan dan melaksanakan DAN pada setiap bit dua nombor. Keputusan AND hanya 1 jika kedua-dua bit adalah 1.
• | (bitwise OR): Mengambil dua nombor sebagai operan dan melakukan OR pada setiap bit dua nombor. Keputusan OR ialah 1 jika mana-mana daripada dua bit ialah 1.
• ^ (bitwise XOR): Mengambil dua nombor sebagai operan dan melaksanakan XOR pada setiap bit dua nombor. Keputusan XOR ialah 1 jika dua bit berbeza.
• < (anjakan ke kiri): mengambil dua nombor, mengalihkan bit operan pertama ke kiri, operan kedua menentukan bilangan kedudukan untuk beralih
• >> (anjakan ke kanan): Ambil dua nombor, alihkan bit operan pertama ke kanan, operan kedua menentukan bilangan kedudukan untuk beralih.
• &^ (DAN BUKAN): Ini ialah pengendali bitwise yang jelas.

Contohnya:

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

Keputusan:

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

Operator Tugasan

Operator penugasan digunakan untuk menetapkan nilai kepada pembolehubah. Operan kiri pengendali tugasan ialah pembolehubah dan operan kanan pengendali tugasan ialah nilai. Nilai di sebelah kanan mesti mempunyai jenis data yang sama seperti pembolehubah di sebelah kiri, jika tidak, pengkompil akan mengembalikan ralat. Jenis pengendali tugasan yang berbeza ditunjukkan di bawah:

• “="(Tugasan mudah): Ini ialah pengendali tugasan yang paling mudah. Operator ini digunakan untuk menetapkan nilai di sebelah kanan kepada pembolehubah di sebelah kiri.
• “+=”(Tugasan tambahan): Operator ini ialah gabungan operator '+' dan '='. Operator ini mula-mula menambah nilai semasa pembolehubah kiri kepada nilai kanan, dan kemudian memberikan hasilnya kepada pembolehubah kiri.
• “-=”(Tolak Tugasan): Operator ini adalah gabungan operator '-' dan '='. Operator ini mula-mula menolak nilai semasa pembolehubah kiri daripada nilai kanan, dan kemudian memberikan hasilnya kepada pembolehubah kiri.
• “*=”(Tugasan Pendaraban): Operator ini adalah gabungan operator '*' dan '='. Operator ini mula-mula mendarabkan nilai semasa pembolehubah kiri dengan nilai di sebelah kanan, dan kemudian memberikan hasilnya kepada pembolehubah kiri.
• “/=”(Penugasan bahagian): Operator ini adalah gabungan operator '/' dan '='. Operator ini mula-mula membahagikan nilai semasa pembolehubah kiri dengan nilai di sebelah kanan, dan kemudian memberikan hasilnya kepada pembolehubah kiri.
• “%="(Baki tugasan): Operator ini adalah gabungan operator '%' dan '='. Operator ini mula-mula mengambil baki nilai semasa pembolehubah kiri diberikan nilai di sebelah kanan, dan kemudian memberikan hasilnya kepada pembolehubah kiri.
• “&=”(Bitwise AND): Operator ini ialah gabungan operator '&' dan '='. Operator ini mula-mula "bitwise AND" nilai semasa pembolehubah kiri kepada nilai di sebelah kanan, dan kemudian memberikan hasilnya kepada pembolehubah kiri.
• “^=”(Eksklusif bitwise ATAU): Pengendali ini ialah gabungan operator '^' dan '='. Operator ini mula-mula "Bitwise Exclusive OR" nilai semasa pembolehubah kiri dengan nilai kanan dan kemudian memberikan hasilnya kepada pembolehubah kiri.
• “|=”(Termasuk bitwise ATAU): Operator ini ialah gabungan '|' pengendali dan '='. Operator ini mula-mula "Bitwise Inclusive OR" nilai semasa pembolehubah kiri dengan nilai kanan dan kemudian memberikan hasilnya kepada pembolehubah kiri.
• “<=: Operator ini ialah gabungan operator < ' dan '="'." Operator ini mula-mula “mengalih” nilai semasa pembolehubah di sebelah kiri dengan nilai di sebelah kanan dan kemudian memberikan hasilnya kepada pembolehubah di sebelah kanan.
• “>>=": Operator ini ialah gabungan operator '>>' dan '='. Operator ini mula-mula "Anjakan Kanan DAN" nilai semasa pembolehubah kiri dengan nilai di sebelah kanan, dan kemudian memberikan hasilnya kepada pembolehubah kiri.

Contohnya:

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

Keputusan:

50
100
50
2500
50
0

Pengendali lain

• &: Operator ini mengembalikan alamat pembolehubah.
• *: Operator ini menyediakan penunjuk kepada pembolehubah.
• <-: Nama operator ini adalah receive. Ia digunakan untuk menerima nilai daripada

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

Keputusan:

4
7