Operatoren in der Go-Sprache

Operatoren werden verwendet, um mathematische oder logische Operationen auszuführen, während das Programm läuft.

Die integrierten Operatoren in der Go-Sprache sind:

Arithmetische Operatoren
Relationale Operatoren
Logische Operatoren
Bitweise Operatoren
Zuweisungsoperatoren
Weitere Operatoren

Sehen wir uns nun die Einführung zu jedem Operator im Detail an.

Arithmetische Operatoren

Die folgende Tabelle listet alle arithmetischen Operatoren in der Go-Sprache auf. Angenommen A = 10, B = 20.

Operatoren	Beschreibung	Beispiel
+	Addition	A + B Ausgabeergebnis 30
-	Subtraktion	A - B Ausgabeergebnis -10
*	Multiplikation	A * B Ausgabeergebnis 200
/	Division	B / A Ausgabeergebnis 2
%	Rest	B % A Ausgabeergebnis 0
++	Inkrement	A++ Ausgabeergebnis 11
--	Dekrement	A-- Ausgabeergebnis 9

Die folgenden Beispiele veranschaulichen die Verwendung der arithmetischen Operatoren:

Beispiel

package main

import "fmt"

func main() {

var a int = 21
var b int = 10
var c int

c = a + b
fmt.Printf("Zeile 1 - der Wert von c ist %d\n", c )
c = a - b
fmt.Printf("Zeile 2 - der Wert von c ist %d\n", c )
c = a * b
fmt.Printf("Zeile 3 - der Wert von c ist %d\n", c )
c = a / b
fmt.Printf("Zeile 4 - der Wert von c ist %d\n", c )
c = a % b
fmt.Printf("Zeile 5 - der Wert von c ist %d"\n", c )
a++
fmt.Printf("Zeile 6 - der Wert von a ist %d"\n", a )
a=21 // Der Einfachheit halber wird a hier zum Testen auf 21 neu zugewiesen
a--
fmt.Printf("Zeile 7 - der Wert von a ist %d"\n", a )
}

Ausführungsergebnis des obigen Beispiels:

第一行 - c 的值为 31
第二行 - c 的值为 11
第三行 - c 的值为 210
第四行 - c 的值为 2
第五行 - c 的值为 1
第六行 - a 的值为 22
第七行 - a 的值为 20

Relationale Operatoren

Die Tabelle listet alle relationalen Operatoren in der Sprache Go auf. Angenommen A = 10, B = 20.

Operatoren	Beschreibung	Beispiel
==	Prüft, ob zwei Werte gleich sind. Wenn sie gleich sind, wird True zurückgegeben; andernfalls wird False zurückgegeben.	(A == B) ist False
!=	Prüft, ob zwei Werte ungleich sind. Wenn sie ungleich sind, wird True zurückgegeben; andernfalls wird False zurückgegeben.	(A != B) ist True
>	Prüft, ob der Wert auf der linken Seite größer als der Wert auf der rechten Seite ist. Wenn ja, wird True zurückgegeben; andernfalls wird False zurückgegeben.	(A > B) ist False
<	Prüft, ob der Wert links kleiner als der Wert rechts ist. Wenn ja, wird True zurückgegeben; andernfalls False.	(A < B) ist True
>=	Prüft, ob der Wert links größer als oder gleich dem Wert rechts ist. Wenn ja, wird True zurückgegeben; andernfalls False.	(A >= B) ist False
<=	Prüft, ob der Wert links kleiner als oder gleich dem Wert rechts ist. Wenn ja, wird True zurückgegeben; andernfalls False.	(A <= B) ist True

Die folgenden Beispiele zeigen die Verwendung der Vergleichsoperatoren:

Beispiel

package main

import "fmt"

func main() {
var a int = 21
var b int = 10

if( a == b ) {
fmt.Printf("Zeile 1 - a ist gleich b\n" )
} else {
fmt.Printf("Zeile 1 - a ist nicht gleich b\n" )
}
if ( a < b ) {
fmt.Printf("Zeile 2 - a ist kleiner als b\n" )
} else {
fmt.Printf("Zeile 2 - a ist nicht kleiner als b\n" )
}

if ( a > b ) {
fmt.Printf("Zeile 3 - a ist größer als b\n" )
} else {
fmt.Printf("Zeile 3 - a ist nicht größer als b"\n" )
}
/* Lass uns den Wert von a und b ändern */
a = 5
b = 20
if ( a <= b ) {
fmt.Printf("Zeile 4 - a ist kleiner oder gleich b\n" )
}
if ( b >= a ) {
fmt.Printf("Zeile 5 - b ist größer oder gleich a\n" )
}
}

Ausführungsergebnis des obigen Beispiels:

第一行 - a 不等于 b
第二行 - a 不小于 b
第三行 - a 大于 b
第四行 - a 小于等于 b
第五行 - b 大于等于 a

Logische Operatoren

Die folgende Tabelle listet alle logischen Operatoren in der Sprache Go auf. Angenommen, A = Wahr, B = Falsch.

Operatoren	Beschreibung	Beispiel
&&	Logischer UND-Operator. Wenn beide Operanden Wahr sind, ist die Bedingung Wahr; andernfalls ist sie Falsch.	(A && B) ist Falsch
\|\|	Logischer ODER-Operator. Wenn mindestens ein Operand Wahr ist, ist die Bedingung Wahr; andernfalls ist sie Falsch.	(A \|\| B) ist Wahr
!	Logischer NICHT-Operator. Wenn die Bedingung Wahr ist, ist die logische NICHT-Bedingung Falsch; andernfalls ist sie Wahr.	!(A && B) ist Wahr

Die folgenden Beispiele demonstrieren die Verwendung der logischen Operatoren:

Beispiel

package main

import "fmt"

func main() {
var a bool = true
var b bool = false
if ( a && b ) {
fmt.Printf("Zeile 1 - Bedingung ist wahr\n" )
}
if ( a || b ) {
fmt.Printf("Zeile 2 - Bedingung ist wahr\n" )
}
/* Ändere die Werte von a und b */
a = false
b = wahr
if ( a && b ) {
fmt.Printf("Zeile 3 - Bedingung ist wahr\n" )
} else {
fmt.Printf("Zeile 3 - Bedingung ist falsch\n" )
}
if ( !(a && b) ) {
fmt.Printf("Zeile 4 - Bedingung ist wahr\n" )
}
}

Ausführungsergebnis des obigen Beispiels:

第二行 - 条件为 true
第三行 - 条件为 false
第四行 - 条件为 true

Bitweise Operatoren

Bitweise Operatoren arbeiten mit den Binärbits von Ganzzahlen im Speicher.

Die folgende Tabelle listet die Berechnungen der bitweisen Operatoren &, | und ^ auf:

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Angenommen, A = 60; B = 13; ihre Binärzahlen werden umgewandelt in:

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

Die von der Sprache Go unterstützten bitweisen Operatoren sind in der folgenden Tabelle dargestellt. Angenommen A = 60, B = 13:

Operatoren	Beschreibung	Beispiel
&	Der bitweise AND-Operator "&" ist ein binärer Operator. Seine Funktion ist es, eine bitweise UND-Verknüpfung der entsprechenden Binärbits der beiden an der Operation beteiligten Zahlen durchzuführen.	(A & B) ergibt 12, binär 0000 1100
\|	Der bitweise OR-Operator "\|" ist ein binärer Operator. Seine Funktion ist es, eine bitweise ODER-Verknüpfung der entsprechenden Binärbits der beiden an der Operation beteiligten Zahlen durchzuführen.	(A \| B) ergibt 61, binär 0011 1101
^	Der bitweise XOR-Operator "^" ist ein binärer Operator. Seine Funktion ist es, eine XOR-Verknüpfung der entsprechenden Binärbits der beiden an der Operation beteiligten Zahlen durchzuführen. Wenn die entsprechenden Binärbits unterschiedlich sind, ist das Ergebnis 1.	(A ^ B) ergibt 49, binär 0011 0001
<<	Der Linksverschiebungsoperator "<<" ist ein binärer Operator. Eine Linksverschiebung um n Bits entspricht der Multiplikation mit 2 hoch n. Seine Funktion ist es, alle Binärbits des Operanden links von "<<" um eine Anzahl von Bits nach links zu verschieben, die durch den Operanden rechts von "<<" angegeben wird; höherwertige Bits werden verworfen, und niederwertige Bits werden mit 0 aufgefüllt.	A << 2 ergibt 240, binär 1111 0000
>>	Der Rechtsverschiebungsoperator ">>" ist ein binärer Operator. Eine Rechtsverschiebung um n Bits entspricht der Division durch 2 hoch n. Seine Funktion ist es, alle Binärbits des Operanden links von ">>" um eine Anzahl von Bits nach rechts zu verschieben, die durch den Operanden rechts von ">>" angegeben wird.	A >> 2 ergibt 15, binär 0000 1111

Das folgende Beispiel demonstriert die Verwendung von bitweisen Operatoren:

Beispiel

package main

import "fmt"

func main() {

var a uint = 60 /* 60 = 0011 1100 */
var b uint = 13 /* 13 = 0000 1101 */
var c uint = 0

c = a & b /* 12 = 0000 1100 */
fmt.Printf("Zeile 1 - der Wert von c ist %d\n", c )

c = a | b /* 61 = 0011 1101 */
fmt.Printf("Zeile 2 - der Wert von c ist %d\n", c )

c = a ^ b /* 49 = 0011 0001 */
fmt.Printf("Zeile 3 - der Wert von c ist %d\n", c )

c = a << 2 /* 240 = 1111 0000 */
fmt.Printf("Zeile 4 - der Wert von c ist %d\n", c )

c = a >> 2 /* 15 = 0000 1111 */
fmt.Printf("Zeile 5 - der Wert von c ist %d"\n", c )
}

Ausführungsergebnis des obigen Beispiels:

第一行 - c 的值为 12
第二行 - c 的值为 61
第三行 - c 的值为 49
第四行 - c 的值为 240
第五行 - c 的值为 15

Zuweisungsoperatoren

Die folgende Tabelle listet alle Zuweisungsoperatoren in der Sprache Go auf.

Operatoren	Beschreibung	Beispiel
=	Einfacher Zuweisungsoperator, der den Wert eines Ausdrucks einem L-Wert zuweist.	C = A + B weist C das Ergebnis des Ausdrucks A + B zu
+=	Addieren und zuweisen	C += A entspricht C = C + A
-=	Subtrahieren und zuweisen	C -= A entspricht C = C - A
*=	Multiplizieren und zuweisen	C = A entspricht C = C A
/=	Dividieren und zuweisen	C /= A entspricht C = C / A
%=	Modulo und zuweisen	C %= A ist gleich C = C % A
<<=	Linksverschiebungszuweisung	C <<= 2 ist äquivalent zu C = C << 2
>>=	Rechtsverschiebungszuweisung	C >>= 2 ist äquivalent zu C = C >> 2
&=	Bitweises UND mit Zuweisung	C &= 2 ist äquivalent zu C = C & 2
^=	Bitweises XOR mit Zuweisung	C ^= 2 ist äquivalent zu C = C ^ 2
\|=	Bitweises ODER mit Zuweisung	C \|= 2 ist äquivalent zu C = C \| 2

Die folgenden Beispiele veranschaulichen die Verwendung der Zuweisungsoperatoren:

Beispiel

package main

import "fmt"

func main() {
var a int = 21
var c int

c = a
fmt.Printf(Zeile 1 - = Operator-Beispiel, c-Wert = %d\n", c )

c += a
fmt.Printf(Zeile 2 - += Operator-Beispiel, c-Wert = %d\n", c )

c -= a
fmt.Printf(Zeile 3 - -= Operator-Beispiel, c-Wert = %d\n", c )

c *= a
fmt.Printf(Zeile 4 - *= Operator-Beispiel, c-Wert = %d\n", c )

c /= a
fmt.Printf(Zeile 5 - /= Operator-Beispiel, c-Wert = %d\n", c )

c = 200;

c <<= 2
fmt.Printf(Zeile 6 - <<= Operator-Beispiel, c-Wert = %d\n", c )

c >>= 2
fmt.Printf(Zeile 7 - >>= Operator-Beispiel, c-Wert = %d\n", c )

c &= 2
fmt.Printf(Zeile 8 - &= Operator-Beispiel, c-Wert = %d\n", c )

c ^= 2
fmt.Printf(Zeile 9 - ^= Operator-Beispiel, c-Wert = %d\n", c )

c |= 2
fmt.Printf(Zeile 10 - |= Operator-Beispiel, c-Wert = %d\n", c )

}

Ausführungsergebnis des obigen Beispiels:

第 1 行 - =  运算符实例，c 值为 = 21
第 2 行 - += 运算符实例，c 值为 = 42
第 3 行 - -= 运算符实例，c 值为 = 21
第 4 行 - *= 运算符实例，c 值为 = 441
第 5 行 - /= 运算符实例，c 值为 = 21
第 6行  - <<= 运算符实例，c 值为 = 800
第 7 行 - >>= 运算符实例，c 值为 = 200
第 8 行 - &= 运算符实例，c 值为 = 0
第 9 行 - ^= 运算符实例，c 值为 = 2
第 10 行 - |= 运算符实例，c 值为 = 2

Weitere Operatoren

Die folgende Tabelle listet weitere Operatoren in der Sprache Go auf.

Operatoren	Beschreibung	Beispiel
&	Gibt die Speicheradresse einer Variablen zurück	&a; gibt die tatsächliche Adresse der Variablen an.
*	Zeigervariable.	*a; ist eine Zeigervariable

Die folgenden Beispiele demonstrieren die Verwendung weiterer Operatoren:

Beispiel

package main

import "fmt"

func main() {
var a int = 4
var b int32
var c float32
var ptr *int

/* Operator-Beispiel */
fmt.Printf("Zeile 1 - Typ der Variable a = %T"\n", a );
fmt.Printf("Zeile 2 - Typ der Variable b = %T"\n", b );
fmt.Printf("Zeile 3 - Typ der Variable c = %T"\n", c );

/* Beispiel für &- und *-Operatoren */
ptr = &a /* 'ptr' enthält die Adresse der Variable 'a' */
fmt.Printf("Der Wert von a ist %d\n", a);
fmt.Printf("*ptr ist %d\n", *ptr);
}

Ausführungsergebnis des obigen Beispiels:

第 1 行 - a 变量类型为 = int
第 2 行 - b 变量类型为 = int32
第 3 行 - c 变量类型为 = float32
a 的值为  4
*ptr 为 4

Operatorrangfolge

Einige Operatoren haben eine höhere Priorität. Die Auswertungsrichtung binärer Operatoren ist immer von links nach rechts. Die folgende Tabelle listet alle Operatoren und ihre Rangfolge auf, wobei von oben nach unten eine Rangfolge von hoch nach niedrig dargestellt wird:

Rangfolge	Operatoren
5	* / % << >> & &^
4	+ - \| ^
3	== != < <= > >=
2	&&
1	\|\|

Natürlich können Sie Klammern verwenden, um die Gesamtpriorität der Operationen eines Ausdrucks vorübergehend zu erhöhen.

Ausführungsergebnis des obigen Beispiels:

Beispiel

package main

import "fmt"

func main() {
var a int = 20
var b int = 10
var c int = 15
var d int = 5
var e int;

e = (a + b) * c / d; // ( 30 * 15 ) / 5
fmt.Printf("The value of (a + b) * c / d is : %d"\n", e );

e = ((a + b) * c) / d; // (30 * 15 ) / 5
fmt.Printf("The value of ((a + b) * c) / d is : %d"\n" , e );

e = (a + b) * (c / d); // (30) * (15/5)
fmt.Printf("The value of (a + b) * (c / d) is : %d"\n", e );

e = a + (b * c) / d; // 20 + (150/5)
fmt.Printf("The value of a + (b * c) / d is : %d"\n" , e );
}

Ausführungsergebnis des obigen Beispiels:

(a + b) * c / d 的值为 : 90
((a + b) * c) / d 的值为  : 90
(a + b) * (c / d) 的值为  : 90
a + (b * c) / d 的值为  : 50

Weitere Erweiterungen