So verwenden Sie Operatoren in Golang

Operatoren bilden die Grundlage jeder Programmiersprache. Daher ist die Funktionalität der Golang -Sprache ohne den Einsatz von Operatoren unvollständig. Operatoren ermöglichen es uns, verschiedene Arten von Operationen an Operanden durchzuführen. In der Go-Sprache können Operatoren anhand ihrer unterschiedlichen Funktionen klassifiziert werden .

Arithmetische Operatoren

Diese Operatoren werden verwendet, um Operationen an Operanden in der Sprache Go durchzuführen:

• Addition: '+' addiert zwei Operanden. Beispiel: x+y.
• Subtraktion: '-' subtrahiert zwei Operanden. Beispiel: xy.
• Multiplikation: '*' multipliziert zwei Operanden. Beispiel: x*y.
• Division: '/' dividiert den ersten Operanden durch den zweiten. Beispiel: x/y.
• Rest: Der Operator „%“ gibt den Rest zurück, der entsteht, wenn der erste Operand durch den zweiten Operanden geteilt wird. Beispiel: x%y.

 Hinweis: -, +, !, &, *, <- und ^ werden auch als unäre Operatoren bezeichnet und haben eine höhere Priorität. Die Operatoren ++ und — stammen aus Anweisungen und sind keine Ausdrücke. Sie liegen daher außerhalb der Operatorhierarchie.

Zum Beispiel:

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

Ergebnis:

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

Relationale Operatoren

Vergleichsoperatoren dienen zum Vergleichen zweier Werte. Sehen wir uns die Operatoren einzeln an:

• Der Operator '==' (Gleich) prüft, ob die beiden angegebenen Operanden gleich sind. Wenn sie gleich sind, gibt er „true“ zurück. Andernfalls gibt er „false“ zurück. Beispielsweise gibt 5==5 „true“ zurück.
• Der Operator '!=' (Ungleich) prüft, ob die beiden angegebenen Operanden gleich sind. Ist dies nicht der Fall, gibt er true zurück. Andernfalls gibt er false zurück. Dies ist das exakte boolesche Komplement des Operators '=='. Beispielsweise gibt 5!=5 false zurück.
• Der Operator „>“ (Größer als) prüft, ob der erste Operand größer als der zweite Operand ist. Ist er größer, gibt er „true“ zurück. Ist er kleiner, gibt er „false“ zurück. Beispielsweise gibt „6>5“ „true“ zurück.
• Der Operator '<' (kleiner als) prüft, ob der erste Operand kleiner als der zweite Operand ist. Ist er kleiner, gibt er true zurück. Andernfalls gibt er false zurück. Beispielsweise gibt <5 zurück
• Der Operator '>=' (Größer als gleich) prüft, ob der erste Operand größer oder gleich dem zweiten Operanden ist. Bei einem Wert größer oder gleich gibt er true zurück. Bei einem Wert kleiner oder gleich gibt er false zurück. Beispiel: 5>=5 gibt true zurück.
• Der Operator '<=' (kleiner oder gleich) prüft, ob der erste Operand kleiner oder gleich dem zweiten Operanden ist. Ist er größer oder gleich, gibt er true zurück. Ist er kleiner oder gleich, gibt er false zurück. Beispiel: <=5 gibt ebenfalls

Zum Beispiel:

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

Ergebnis:

false
true
false
true
true
false

Logische Operatoren

Sie werden verwendet, um zwei oder mehr Bedingungen/Einschränkungen zu kombinieren oder die Auswertung der betrachteten Anfangsbedingung zu ergänzen.

• UND: Der Operator „&&“ gibt „true“ zurück, wenn beide Bedingungen erfüllt sind. Andernfalls gibt er „false“ zurück. Beispielsweise gibt „a && b“ „true“ zurück, wenn sowohl „a“ als auch „b“ erfüllt sind (also ungleich 0).
• ODER: Der Operator '||' gibt „true“ zurück, wenn eine (oder beide) der betrachteten Bedingungen erfüllt sind. Andernfalls gibt er „false“ zurück. Beispielsweise gibt a || b „true“ zurück, wenn entweder a oder b wahr (also ungleich Null) ist. Natürlich gibt er „true“ zurück, wenn sowohl a als auch b wahr sind.
• Logisches NICHT: Der Operator '!' gibt „true“ zurück, wenn die betreffende Bedingung nicht erfüllt ist. Andernfalls gibt er „false“ zurück. Beispielsweise gibt !a „true“ zurück, wenn a „false“ ist, d. h. wenn a = 0 ist.

Zum Beispiel:

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

Ergebnis:

True
True
True

Bitweise Operatoren

In der Programmiersprache Go gibt es sechs bitweise Operatoren, die auf Bitebene operieren oder zur Durchführung bitweiser Operationen verwendet werden. Die folgenden bitweisen Operatoren sind verfügbar:

• & (bitweises UND): Nimmt zwei Zahlen als Operanden und führt für jedes Bit der beiden Zahlen eine UND-Verknüpfung durch. Das Ergebnis von UND ist nur dann 1, wenn beide Bits 1 sind.
• | (bitweises ODER): Nimmt zwei Zahlen als Operanden und führt eine ODER-Verknüpfung mit jedem Bit der beiden Zahlen durch. Das Ergebnis der ODER-Verknüpfung ist 1, wenn eines der beiden Bits 1 ist.
• ^ (bitweises XOR): Verwendet zwei Zahlen als Operanden und führt eine XOR-Verknüpfung aller Bits der beiden Zahlen durch. Das Ergebnis von XOR ist 1, wenn die beiden Bits unterschiedlich sind.
• < (nach links verschieben): nimmt zwei Zahlen, verschiebt die Bits des ersten Operanden nach links, der zweite Operand bestimmt die Anzahl der zu verschiebenden Positionen
• >> (nach rechts verschieben): Nehmen Sie zwei Zahlen, verschieben Sie die Bits des ersten Operanden nach rechts, der zweite Operand bestimmt die Anzahl der zu verschiebenden Positionen.
• &^ (UND NICHT): Dies ist ein expliziter bitweiser Operator.

Zum Beispiel:

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

Ergebnis:

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

Zuweisungsoperator

Zuweisungsoperatoren dienen dazu, einer Variablen einen Wert zuzuweisen. Der linke Operand eines Zuweisungsoperators ist eine Variable, der rechte Operand ein Wert. Der rechte Wert muss denselben Datentyp wie die linke Variable haben, sonst meldet der Compiler einen Fehler. Die verschiedenen Arten von Zuweisungsoperatoren sind unten aufgeführt:

• „=“ (Einfache Zuweisung): Dies ist der einfachste Zuweisungsoperator. Mit diesem Operator wird der Wert auf der rechten Seite der Variablen auf der linken Seite zugewiesen.
• „+=“ (Zusätzliche Zuweisung): Dieser Operator ist eine Kombination der Operatoren „+“ und „=“. Dieser Operator addiert zunächst den aktuellen Wert der linken Variable zum Wert auf der rechten Seite und weist das Ergebnis anschließend der linken Variable zu.
• „-=“ (Subtraktionszuweisung): Dieser Operator ist eine Kombination der Operatoren „-“ und „=“. Dieser Operator subtrahiert zunächst den aktuellen Wert der linken Variable vom Wert auf der rechten Seite und weist das Ergebnis dann der linken Variable zu.
• „*=“ (Multiplikationszuweisung): Dieser Operator ist eine Kombination der Operatoren „*“ und „=“. Dieser Operator multipliziert zunächst den aktuellen Wert der linken Variable mit dem Wert auf der rechten Seite und weist das Ergebnis dann der linken Variable zu.
• „/=“ (Divisionszuweisung): Dieser Operator ist eine Kombination der Operatoren „/“ und „=“. Dieser Operator dividiert zunächst den aktuellen Wert der linken Variable durch den Wert auf der rechten Seite und weist das Ergebnis dann der linken Variable zu.
• „%=“ (Zuweisung mit Restdivision): Dieser Operator ist eine Kombination der Operatoren „%“ und „=“. Dieser Operator addiert zunächst den Rest des aktuellen Wertes der linken Variable zum Wert auf der rechten Seite und weist das Ergebnis anschließend der linken Variable zu.
• „&=“ (Bitweise UND-Zuweisung): Dieser Operator ist eine Kombination der Operatoren „&“ und „=“. Er verknüpft zunächst den aktuellen Wert der linken Variable mit dem Wert auf der rechten Seite und weist das Ergebnis anschließend der linken Variable zu.
• „^=“ (Bitweises Exklusiv-ODER): Dieser Operator ist eine Kombination der Operatoren „^“ und „=“. Er verknüpft zunächst den aktuellen Wert der linken Variable mit dem Wert auf der rechten Seite mit einem „Bitweisen Exklusiv-ODER“ und weist das Ergebnis anschließend der linken Variable zu.
• „|=“ (Bitweises Inklusives ODER): Dieser Operator ist eine Kombination der Operatoren „|“ und „=“. Er verknüpft zunächst den aktuellen Wert der linken Variable mit dem Wert der rechten und weist das Ergebnis anschließend der linken Variable zu.
• „<=: Dieser Operator ist eine Kombination der Operatoren <‘ und ‚=‘.“ Dieser Operator „verschobt“ zunächst den aktuellen Wert der linken Variable um den Wert auf der rechten Seite und weist das Ergebnis anschließend der rechten Variable zu.
• „>>=“: Dieser Operator ist eine Kombination der Operatoren „>>“ und „=“. Er verknüpft den aktuellen Wert der linken Variable zunächst mit dem Wert auf der rechten Seite per „Rechtsverschiebung UND“ und weist das Ergebnis anschließend der linken Variable zu.

Zum Beispiel:

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

Ergebnis:

50
100
50
2500
50
0

Andere Betreiber

• &: Dieser Operator gibt die Adresse einer Variablen zurück.
• *: Dieser Operator stellt einen Zeiger auf eine Variable bereit.
• <-: Der Name dieses Operators ist „receive“. Er wird verwendet, um einen Wert von

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

Ergebnis:

4
7