Go Sprache Operatoren
Operatoren werden verwendet, mathematischen oder logischen Operationen in einer laufenden Anwendung auszuführen.
Gehen Sie Betreiber in die Sprache integriert:
- Arithmetische Operatoren
- Relationale Operatoren
- Logische Operatoren
- Bitweise Operatoren
- Zuweisungsoperatoren
- Andere Betreiber
Lassen Sie uns jedes sehen im Detail den Weg gebracht hatte.
Arithmetische Operatoren
Die folgende Tabelle listet alle Sprachen Go arithmetischen Operatoren. Es sei angenommen, daß A 10, B 20 ist.
Die Betreiber | Beschreibung | Beispiele |
---|---|---|
+ | Hinzufügen | A + B-Ausgang 30 |
- | Subtraktion | A - B Ausgang -10 |
* | multipliziert | A * B 200 Ausgang |
/ | geteilt | B / A-Ausgang 2 |
% | Rest | B% Ein Ausgang 0 |
++ | Zuwachs | A ++ Ausgabe 11 |
- | Decrement | A-- Ausgang 9 |
Das folgende Beispiel demonstriert die Verwendung von verschiedenen arithmetischen Operatoren:
package main import "fmt" func main() { var a int = 21 var b int = 10 var c int c = a + b fmt.Printf("第一行 - c 的值为 %d\n", c ) c = a - b fmt.Printf("第二行 - c 的值为 %d\n", c ) c = a * b fmt.Printf("第三行 - c 的值为 %d\n", c ) c = a / b fmt.Printf("第四行 - c 的值为 %d\n", c ) c = a % b fmt.Printf("第五行 - c 的值为 %d\n", c ) a++ fmt.Printf("第六行 - c 的值为 %d\n", a ) a-- fmt.Printf("第七行 - c 的值为 %d\n", a ) }
Beispiele für die oben genannten Betriebsergebnisse:
第一行 - c 的值为 31 第二行 - c 的值为 11 第三行 - c 的值为 210 第四行 - c 的值为 2 第五行 - c 的值为 1 第六行 - c 的值为 22 第七行 - c 的值为 21
Relationale Operatoren
Die folgende Tabelle listet alle die Sprache Go relationalen Operatoren. Es sei angenommen, daß A 10, B 20 ist.
Die Betreiber | Beschreibung | Beispiele |
---|---|---|
== | Überprüfen Sie die beiden Werte gleich sind, gleich gibt Wahr zurück, andernfalls, wenn Falsch. | (A == B) ist False |
! = | Überprüfen Sie, ob die beiden Werte nicht gleich sind, nicht gleich gibt Wahr zurück, wenn sonst Falsch. | (A! = B) wahr |
> | Überprüfen Sie die linke Wert größer als der Wert der rechten Seite, eine Rückkehr andernfalls True False fest. | (A> B) falsch |
< | Überprüfen Sie die linke Wert kleiner als der Wert der rechten Seite, eine Rückkehr andernfalls True False fest. | (A <B) wahr |
> = | Prüfen Sie, ob der Wert größer als oder gleich links auf den richtigen Wert, es ist wahr zurück, wenn es sonst falsch ist. | (A> = B) ist False |
<= | Prüfen Sie, ob der Wert kleiner als oder gleich links auf den richtigen Wert, es gibt True zurück, wenn es sonst falsch ist. | (A <= B) wahr |
Das folgende Beispiel demonstriert die Verwendung von relationalen Operatoren:
package main import "fmt" func main() { var a int = 21 var b int = 10 if( a == b ) { fmt.Printf("第一行 - a 等于 b\n" ) } else { fmt.Printf("第一行 - a 不等于 b\n" ) } if ( a < b ) { fmt.Printf("第二行 - a 小于 b\n" ) } else { fmt.Printf("第二行 - a 不小于 b\n" ) } if ( a > b ) { fmt.Printf("第三行 - a 大于 b\n" ) } else { fmt.Printf("第三行 - a 不大于 b\n" ) } /* Lets change value of a and b */ a = 5 b = 20 if ( a <= b ) { fmt.Printf("第四行 - a 小于等于 b\n" ) } if ( b >= a ) { fmt.Printf("第五行 - b 大于等于 b\n" ) } }
Beispiele für die oben genannten Betriebsergebnisse:
第一行 - a 不等于 b 第二行 - a 不小于 b 第三行 - a 大于 b 第四行 - a 小于等于 b 第五行 - b 大于等于 b
Logische Operatoren
Die folgende Tabelle listet alle Sprachen gehen logischen Operatoren. Es sei angenommen, dass A ist wahr, B falsch ist.
Die Betreiber | Beschreibung | Beispiele |
---|---|---|
&& | Logische UND-Operator. Wenn beide Seiten der Operanden wahr sind, ist die Bedingung wahr, sonst Falsch. | (A && B) ist False |
|| | Logische OR-Operator. Wenn die Operanden auf beiden Seiten ein True ist, ist die Bedingung erfüllt, sonst Falsch. | (A || B) wahr |
! | Logischer NOT-Operator. Wenn die Bedingung wahr ist, dann bedingen die logische nicht falsch, sonst Wahr. | ! (A && B) wahr |
Das folgende Beispiel zeigt die Verwendung von logischen Operatoren:
package main import "fmt" func main() { var a bool = true var b bool = false if ( a && b ) { fmt.Printf("第一行 - 条件为 true\n" ) } if ( a || b ) { fmt.Printf("第二行 - 条件为 true\n" ) } /* 修改 a 和 b 的值 */ a = false b = true if ( a && b ) { fmt.Printf("第三行 - 条件为 true\n" ) } else { fmt.Printf("第三行 - 条件为 false\n" ) } if ( !(a && b) ) { fmt.Printf("第四行 - 条件为 true\n" ) } }
Beispiele für die oben genannten Betriebsergebnisse:
第二行 - 条件为 true 第三行 - 条件为 false 第四行 - 条件为 true
Bitweise Operatoren
Bitoperatoren auf ganze Zahlen in Speicherbits arbeiten.
In der folgenden Tabelle sind die Bit-Operatoren &, | und ^ berechnet:
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 |
Es sei angenommen, daß A = 60; B = 13, dessen Binärzahl:
A = 0011 1100 B = 0000 1101 ----------------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
Bit-Computing-Unterstützung C-Sprache-Symbol in der folgenden Tabelle dargestellt. Es sei angenommen, daß A 60, B 13:
Die Betreiber | Beschreibung | Beispiele |
---|---|---|
& | Bitweise AND-Operator "&" ist die binäre Operatoren. Seine Funktion ist, zwei binäre Zahlen zu jeder Phase der Operation und Beteiligung entspricht. | (A & B) Ergebnis ist 12, ist die binäre 0000 1100 |
| | Bitweise OR-Operator "|" ist ein binärer Operator. Seine Funktion ist in den Betrieb von zwei Zahlen jeweils entsprechenden binären Phase bzw. Teilnahme | (A | B) das Ergebnis 61 ist, ist die binäre 00111101 |
^ | Bitweise Exklusiv-ODER-Operator "^" ist die binäre Operatoren. Seine Funktion ist in den Betrieb von zwei Zahlen jeweils entsprechenden binären XOR wenn zwei entsprechende binäre Bit unterschiedlich und das Ergebnis 1 ist, teilzunehmen. | (A ^ B) ergibt sich für die 49-Binärdateien zu 00.110.001 |
<< | Linke Shift-Operator "<<" ist die binäre Operatoren. N-Bit-Linksverschiebung wird durch 2 ^ n multipliziert. Seine Funktion auf jede binäre "<<" links des linken Operanden aller einer Anzahl von Bits durch die Anzahl "<<" rechts vom Komma bewegt angegeben, die hohen und unteren 0s zu verwerfen. | A << 2 Ergebnisse für 240 binär 11110000 |
>> | Rechts Shift-Operator ">>" sind binäre Operatoren. N Bits nach rechts wird durch 2 ^ n geteilt. Seine Funktion ist es, verschiedene binäre ">>" der linke Operand Mehrere alles in Ordnung, ">>" auf der rechten Seite die Anzahl der Bits angegeben. | A >> 2 Ergebnisse für 15 0000 1111 Binärsystem |
Das folgende Beispiel zeigt die Verwendung von logischen Operatoren:
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("第一行 - c 的值为 %d\n", c ) c = a | b /* 61 = 0011 1101 */ fmt.Printf("第二行 - c 的值为 %d\n", c ) c = a ^ b /* 49 = 0011 0001 */ fmt.Printf("第三行 - c 的值为 %d\n", c ) c = a << 2 /* 240 = 1111 0000 */ fmt.Printf("第四行 - c 的值为 %d\n", c ) c = a >> 2 /* 15 = 0000 1111 */ fmt.Printf("第五行 - c 的值为 %d\n", c ) }
Beispiele für die oben genannten Betriebsergebnisse:
第一行 - c 的值为 12 第二行 - c 的值为 61 第三行 - c 的值为 49 第四行 - c 的值为 240 第五行 - c 的值为 15
Zuweisungsoperatoren
Die folgende Tabelle listet alle die Sprache Go Zuweisungsoperator.
Die Betreiber | Beschreibung | Beispiele |
---|---|---|
= | Einfache Zuweisungsoperator weist einen Wert Ausdruck einer L-Wert | C = A + B A + B wird dem C Ausdrucksergebnis zugeordnet werden |
+ = | Hinzugefügt zusammen vor der Zuweisung | C + = A gleich C = C + A |
- = | Nach Subtraktionszuweisung | C - = A gleich C = C - A |
* = | Dann multipliziert die Zuordnung | C * = A gleich C = C * A |
/ = | Abteilung nach der Abtretung | C / A = gleich C = C / A |
% = | Rest nach der Abtretung | C% = A gleich C = C% A |
<< = | Linke nach der Abtretung | C << = 2 gleich C = C << 2 |
>> = | Gleich nach der Zuordnung | C >> = 2 gleich C = C >> 2 |
& = | Bitweise AND-Zuweisung nach | C & = 2 gleich C = C & 2 |
^ = | Nachdem die Bit-XOR-Zuweisung drücken | C ^ = 2 gleich C = C ^ 2 |
| = | Nach dem Drücken von Position oder Zuweisung | C | = 2 gleich C = C | 2 |
Das folgende Beispiel zeigt den Zuweisungsoperator Nutzung:
package main import "fmt" func main() { var a int = 21 var c int c = a fmt.Printf("第 1 行 - = 运算符实例,c 值为 = %d\n", c ) c += a fmt.Printf("第 2 行 - += 运算符实例,c 值为 = %d\n", c ) c -= a fmt.Printf("第 3 行 - -= 运算符实例,c 值为 = %d\n", c ) c *= a fmt.Printf("第 4 行 - *= 运算符实例,c 值为 = %d\n", c ) c /= a fmt.Printf("第 5 行 - /= 运算符实例,c 值为 = %d\n", c ) c = 200; c <<= 2 fmt.Printf("第 6行 - <<= 运算符实例,c 值为 = %d\n", c ) c >>= 2 fmt.Printf("第 7 行 - >>= 运算符实例,c 值为 = %d\n", c ) c &= 2 fmt.Printf("第 8 行 - &= 运算符实例,c 值为 = %d\n", c ) c ^= 2 fmt.Printf("第 9 行 - ^= 运算符实例,c 值为 = %d\n", c ) c |= 2 fmt.Printf("第 10 行 - |= 运算符实例,c 值为 = %d\n", c ) }
Beispiele für die oben genannten Betriebsergebnisse:
第 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
Andere Betreiber
Die folgende Tabelle listet die anderen Operatoren Sprache gehen.
Die Betreiber | Beschreibung | Beispiele |
---|---|---|
& | Rückgabevariable Speicheradresse | & A, wird die reale Adresse der Variablen geben. |
* | Pointer-Variable. | * A; ist eine Zeigervariable |
Das folgende Beispiel demonstriert die Verwendung anderer Betreiber:
package main import "fmt" func main() { var a int = 4 var b int32 var c float32 var ptr *int /* 运算符实例 */ fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a ); fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b ); fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c ); /* & 和 * 运算符实例 */ ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */ fmt.Printf("a 的值为 %d\n", a); fmt.Printf("*ptr 为 %d\n", *ptr); }
Beispiele für die oben genannten Betriebsergebnisse:
第 1 行 - a 变量类型为 = int 第 2 行 - b 变量类型为 = int32 第 3 行 - c 变量类型为 = float32 a 的值为 4 *ptr 为 4
Operator Präzedenz
Einige Betreiber haben eine höhere Priorität, binäre Operatoren sind Arbeitsrichtung von links nach rechts. Die folgende Tabelle listet alle Operatoren und ihre Prioritäten, die Vertreter von oben nach unten in absteigender Priorität:
Priorität | Die Betreiber |
---|---|
7 | ^! |
6 | * /% ^ & << >> & |
5 | + - | ^ |
4 | ==! = << => => |
3 | <- |
2 | && |
1 | || |
Natürlich können Sie Klammern verwenden, um vorübergehend die Gesamtpriorität des Betriebs eines Ausdrucks zu verbessern.
Beispiele für die oben genannten Betriebsergebnisse:
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("(a + b) * c / d 的值为 : %d\n", e ); e = ((a + b) * c) / d; // (30 * 15 ) / 5 fmt.Printf("((a + b) * c) / d 的值为 : %d\n" , e ); e = (a + b) * (c / d); // (30) * (15/5) fmt.Printf("(a + b) * (c / d) 的值为 : %d\n", e ); e = a + (b * c) / d; // 20 + (150/5) fmt.Printf("a + (b * c) / d 的值为 : %d\n" , e ); }
Beispiele für die oben genannten Betriebsergebnisse:
(a + b) * c / d 的值为 : 90 ((a + b) * c) / d 的值为 : 90 (a + b) * (c / d) 的值为 : 90 a + (b * c) / d 的值为 : 50