Go-Operatoren

Operatoren sind die Grundlage jeder Programmiersprache. Daher ist Go ohne Operatoren nicht vollständig funktionsfähig. Operatoren erlauben es uns, verschiedene Arten von Operationen auf Operanden auszuführen. In Go können Operatoren nach ihren verschiedenen Funktionen klassifiziert werden:

• Arithmetische Operatoren

• Verhältnisoperatoren

• Logische Operatoren

• bitweise Operatoren

• Zugewiesene Operatoren

• 杂项运算符

Arithmetische Operatoren

Diese werden verwendet, um Arithmetik auf Operanden in Go auszuführen/Mathematische Operationen:

• Addition: “ +Der Operator "+" addiert zwei Operanden. Zum Beispiel x + y.

• Subtraktion: “-Der Operator "-" zieht zwei Operanden ab. Zum Beispiel x-y.

• Multiplikation: *Der Operator "*'" multipliziert zwei Operanden. Zum Beispiel x * y.

• Division: /Der Operator "/'" teilt den ersten Operanden durch den zweiten. Zum Beispiel x / y.

• Modulo:Wenn der erste Operand das zweite teilt, gibt der Operator "%%" den Rest zurück. Zum Beispiel x %% y.

Hinweis: -,+, !, &,*, <-Der Operator "^" wird auch als unärer Operator bezeichnet, der eine höhere Priorität hat.++Der Operator "&" kommt aus dem Statement, es ist kein Ausdruck und daher nicht in der Operatorhierarchie.

package main
import "fmt"
func main() {
　　　　p :=　34
　　　　q :=　20
　　　　//　Addition
　　　　result1　:= p　+　q
　　　　fmt.Printf("Ergebnis der Berechnung p　+　q = %d", result1)
　　　　//　Subtraktion
　　　　result2　:= p　-　q
　　　　fmt.Printf("\nErgebnis der Berechnung p　-　q = %d", result2)
　　　　//　Multiplikation
　　　　result3　:= p　*　q
　　　　fmt.Printf("\nErgebnis der Berechnung p　*　q = %d", result3)
　　　　//　Division
　　　　result4　:= p　/　q
　　　　fmt.Printf("\nErgebnis der Berechnung p　/　q = %d", result4)
　　　　//　Modulo
　　　　result5　:= p % q
　　　　fmt.Printf("\nBerechnungsergebnis p %% q = %d", result5)
}

Ausgabe:

Berechnungsergebnis p　+　q =　54
Berechnungsergebnis p　-　q =　14
Berechnungsergebnis p　*　q =　680
Berechnungsergebnis p　/　q =　1
Berechnungsergebnis p % q =　14

Verhältnisoperatoren

Verhältnisoperatoren werden verwendet, um zwei Werte zu vergleichen. Lassen Sie uns einmal sehen:

• '==' (gleich)Der Operator überprüft, ob zwei gegebene Operanden gleich sind. Wenn gleich, gibt er true zurück. Andernfalls gibt er false zurück. Zum Beispiel:5 == 5gibt true zurück.

• '!=' (ungleich)Der Operator überprüft, ob zwei gegebene Operanden gleich sind. Wenn ungleich, gibt er true zurück. Andernfalls gibt er false zurück. Dies ist die genaue booleche Komplementation des Operators '=='. Zum Beispiel:5!= 5gibt false zurück.

• '>' (größer)Der Operator überprüft, ob der erste Operanden größer als den zweiten Operanden ist. Wenn größer, gibt er true zurück. Andernfalls gibt er false zurück. Zum Beispiel:6> 5gibt true zurück.

• '<' (kleiner)Der Operator überprüft, ob der erste Operanden kleiner als den zweiten Operanden ist. Wenn kleiner, gibt er true zurück. Andernfalls gibt er false zurück. Zum Beispiel:6 <5gibt false zurück.

• '>=' (größer als oder gleich)Der Operator überprüft, ob der erste Operanden größer oder gleich dem zweiten Operanden ist. Wenn größer oder gleich, gibt er true zurück. Andernfalls gibt er false zurück. Zum Beispiel:5>= 5gibt true zurück.

• “<=” (kleiner als oder gleich)Der Operator überprüft, ob der erste Operanden kleiner oder gleich dem zweiten Operanden ist. Wenn kleiner oder gleich, gibt er true zurück. Andernfalls gibt er false zurück. Zum Beispiel:5 <= 5wird auch true zurückgeben.

package main
import "fmt"
func main() {
　　　　p :=　34
　　　　q :=　20
　　　　//　‘==’ (gleich)
　　　　result1　:= p == q
　　　　fmt.Println(result1)
　　　　//　‘!=’ (ungleich)
　　　　result2　:= p != q
　　　　fmt.Println(result2)
　　　　//　‘<’ (kleiner)
　　　　result3　:= p < q
　　　　fmt.Println(result3)
　　　　//　‘>’ (größer)
　　　　result4　:= p > q
　　　　fmt.Println(result4)
　　　　//　‘>=’ (größer als oder gleich)
　　　　result5　:= p >= q
　　　　fmt.Println(result5)
　　　　//　‘<=’ (kleiner als oder gleich)
　　　　result6　:= p <= q
　　　　fmt.Println(result6)
}

Ausgabe:

false
true
false
true
true
false

Logische Operatoren

• Logisches AND:Der "&&"-Operator gibt true zurück, wenn beide betrachteten Bedingungen erfüllt sind. Andernfalls gibt er false zurück. Zum Beispiel gibt a && b true zurück, wenn sowohl a als auch b wahr sind (d.h. nicht null).

• Logisches Oder: Der "||"-Operator gibt true zurück, wenn eine (oder beide) Bedingungen erfüllt sind. Andernfalls gibt er false zurück. Zum Beispiel, wenn eine von a oder b wahr ist (d.h. nicht null), gibt || b true zurück. Natürlich gibt er auch true zurück, wenn sowohl a als auch b wahr sind.

• Logisches Negativ: Wenn die Bedingung nicht erfüllt ist, gibt der "!"-Operator true zurück. Andernfalls gibt er false zurück. Zum Beispiel, wenn a falsch ist, d.h. a = 0, dann gibt !a true zurück.

package main
import "fmt"
func main() {
　　　　var p int =　23
　　　　var q int =　60
　　　　if p != q && p <= q {
　　　　　　　　fmt.Println("Wahr")
　　　　}
　　　　if p != q || p <= q {
　　　　　　　　fmt.Println("Wahr")
　　　　}
　　　　if !(p == q) {
　　　　　　　　fmt.Println("Wahr")
　　　　}
}

Ausgabe:

Wahr
Wahr
Wahr

bitweise Operatoren

In der Programmiersprache Go gibt es6bitweise Operatoren können bitweise arbeiten oder für bitweise Operationen verwendet werden. Hier sind die bitweisen Operatoren:

• ＆（Bitweise und）: SetztZwei Zahlen als Operanden, und auf jedes Bit der beiden Zahlen wird die 'und'-Operation angewendet. Nur wenn beide Bits1wenn, dann ist das AND-Ergebnis1.

• |（Bitweise oder）: SetztZwei Zahlen als Operanden, und auf jedes Bit der beiden Zahlen wird die 'oder'-Operation angewendet. Wenn eines der beiden Bits1，OR-Ergebnis ist1.

• ^（Bitweise XOR）: SetztZwei Zahlen als Operanden, und auf jedes Bit der beiden Zahlen wird XOR angewendet. Wenn die beiden Bits unterschiedlich sind, ist das XOR-Ergebnis1.

• <<（Linksverschieben）:Zwei Zahlen nehmen, die Bits des ersten Operanden nach links verschieben, die zweite Zahl bestimmt die Anzahl der zu verschiebenden Stellen.

• >>（Rechtsverschieben）:Zwei Zahlen nehmen, die Bits des ersten Operanden nach rechts verschieben, die zweite Zahl bestimmt die Anzahl der zu verschiebenden Stellen.

• ＆^（AND NOT）:(Bitweise Löschen) Operator, der tatsächlich die &(^) Operation ausführt.

package main
import "fmt"
func main() {
　　　　p :=　134
　　　　q :=　320
　　　　//　& (AND)
　　　　result1　:= p & q
　　　　fmt.Printf("Berechnungsergebnis p & q = %d", result1)
　　　　//　| (OR)
　　　　result2　:= p | q
　　　　fmt.Printf("\nBerechnungsergebnis p | q = %d", result2)
　　　　//　^ (XOR)
　　　　result3　:= p ^ q
　　　　fmt.Printf("\nBerechnungsergebnis p ^ q = %d", result3)
　　　　//　<< (Linksverschieben)
　　　　result4　:= p <<　1
　　　　fmt.Printf("\nBerechnungsergebnis p <<　1　= %d", result4)
　　　　//　>> (Rechtsverschieben)
　　　　result5　:= p >>　1
　　　　fmt.Printf("\nBerechnungsergebnis p >>　1　= %d", result5)
　　　　//　&^ (AND NOT)
　　　　result6　:= p &^ q
　　　　fmt.Printf("\nBerechnungsergebnis p &^ q = %d", result6)
}

Ausgabe:

Berechnungsergebnis p & q = 0
Berechnungsergebnis p | q =　454
Berechnungsergebnis p ^ q =　454
Berechnungsergebnis p <<　1　=　268
Berechnungsergebnis p >>　1　=　67
Berechnungsergebnis p &^ q =　134

Zugewiesene Operatoren

Zugewiesene Operatoren werden verwendet, um Variablen zu zuweisen. Der linke Operand des Zuweisungsoperators ist eine Variable, während der rechte Operand ein Wert ist. Der Wert muss die gleiche Datentypen als die linke Variable haben, andernfalls wirft der Compiler einen Fehler aus. Die verschiedenen Zuweisungsoperatoren sind wie folgt dargestellt:

• “ =”（简单赋值）：这是最简单的赋值运算符。该运算符用于将右侧的值分配给左侧的变量。

• “ + “+=”（加法赋值）：此运算符是+此运算符是'+'和'='运算符的组合。该运算符首先将左侧变量的当前值添加到右侧的值，然后将结果分配给左侧的变量。

• “-“-=”（减法赋值）：此运算符是-此运算符是'-'和'='运算符的组合。该运算符首先从右侧的值中减去左侧变量的当前值，然后将结果分配给左侧的变量。

• “ * “*=”（乘法赋值）：此运算符是*此运算符是'*'和'='运算符的组合。该运算符首先将左侧变量的当前值乘以右侧值，然后将结果分配给左侧变量。

• “ / “/=”（除法赋值）：此运算符是/此运算符是'/'和'='运算符的组合。该运算符首先将左侧变量的当前值除以右侧值，然后将结果分配给左侧变量。

• “％=”（模赋值）：此运算符是“％”和“ =”运算符的组合。该运算符首先对左侧变量的当前值乘以右侧变量的值，然后将结果赋给左侧变量。

• “＆=”（按位与赋值）：此运算符是'＆'和'='运算符的组合。该运算符首先将左侧变量的当前值与右侧变量进行“按位与”运算，然后将结果分配给左侧变量。

• “ ^ =”（按位异或）：此运算符是'^'和'='运算符的组合。该运算符首先将左侧变量的当前值与右侧变量进行“按位异或”，然后将结果分配给左侧变量。

• “ | =”（按位或）：此运算符是“ |”和'='运算符的组合。该运算符首先将左边变量的当前值与右边的值“按位或”，然后将结果分配给左边的变量。

package main　
　　　　
import "fmt"
　　　　
func main() {　
　　　var p int =　38
　　　　var q int =　70
　　　　　　　
　　　//　“=”(简单赋值)　
　　　p = q　
　　　fmt.Println(p)　
　　　　　　　
　　　//　“+=”(加法赋值)　
　　　　p　+= q　
　　　fmt.Println(p)　
　　　　　　　
　　　//“-=”(减法赋值)　
　　　p-= q　
　　　fmt.Println(p)　
　　　　　　　
　　　//　“*=”(乘法赋值)　
　　　p*= q　
　　　fmt.Println(p)　
　　　　　　　
　　　//　“/=”(除法赋值)　
　　　　p　/= q　
　　　fmt.Println(p)　
　　　　　　
　　　　//　“%=”（求模赋值）　
　　　　p %= q　
　　　fmt.Println(p)　
　　　　　　
}

Ausgabe:

70
140
70
4900
70
0

杂项运算符

• ＆：此运算符返回变量的地址。

• *:此运算符提供指向变量的指针。

• <-:此运算符的名称为接收。它用于从通道接收值。

package main　
　　　　
import "fmt"
　　　　
func main() {　
　　a :=　94
　　　　　
//使用运算符（＆）和
//指针间接（*）运算符
　　b := &a　　
　　fmt.Println(*b)　　
　　*b =　67　
　　fmt.Println(a)　　
}

Ausgabe:

94
67