Il miglior tutorial Vai operatori del linguaggio Nel 2024, in questo tutorial puoi imparare Gli operatori aritmetici,Operatori relazionali,Operatori logici,operatori bit per bit,Operatori di assegnazione,altri operatori,precedenza Operatore,
Gli operatori vengono utilizzate per eseguire operazioni matematiche o logiche in un'applicazione in esecuzione.
Vai operatori sono costruiti nella lingua:
Diamo un'occhiata a ciascuno in particolare gli operatori introdotte.
La seguente tabella elenca tutte le lingue Vai gli operatori aritmetici. Si supponga che A è 10, B è di 20.
| operatori | descrizione | Esempi |
|---|---|---|
| + | Aggiunta | Un'uscita + B 30 |
| - | sottrazione | A - uscita B -10 |
| * | moltiplicato | A * B 200 di uscita |
| / | diviso | B / A Uscita 2 |
| % | resto | uscita B% A 0 |
| ++ | incremento | Un'uscita ++ 11 |
| - | diminuzione | Uscita A-- 9 |
L'esempio seguente mostra l'utilizzo di diversi operatori aritmetici:
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 )
}
Esempi dei risultati operativi di cui sopra:
第一行 - c 的值为 31 第二行 - c 的值为 11 第三行 - c 的值为 210 第四行 - c 的值为 2 第五行 - c 的值为 1 第六行 - c 的值为 22 第七行 - c 的值为 21
La seguente tabella elenca tutti gli operatori relazionali lingua Go. Si supponga che A è 10, B è di 20.
| operatori | descrizione | Esempi |
|---|---|---|
| == | Controllare i due valori sono uguali, ritorna uguale a True se altrimenti False. | (A == B) è False |
| ! = | Controllare se i due valori non sono uguali, non restituisce pari True se altrimenti False. | (A! = B) è True |
| > | Controllare il valore sinistro è maggiore del valore del lato destro, un ritorno Vero altrimenti False. | (A> B) è False |
| < | Controllare il valore di sinistra è inferiore al valore del lato destro, un ritorno vero altrimenti False. | (A <B) è True |
| > = | Controllare se il valore è maggiore o uguale a fianco al valore corretto, restituisce True se è altrimenti False. | (A> = B) è False |
| <= | Controllare se il valore è minore o uguale a fianco al valore corretto, restituisce True se è altrimenti False. | (A <= B) è True |
L'esempio seguente mostra l'utilizzo di operatori relazionali:
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" )
}
}
Esempi dei risultati operativi di cui sopra:
第一行 - a 不等于 b 第二行 - a 不小于 b 第三行 - a 大于 b 第四行 - a 小于等于 b 第五行 - b 大于等于 b
La seguente tabella elenca tutte le lingue Vai operatori logici. Si supponga che A è vero, B è False.
| operatori | descrizione | Esempi |
|---|---|---|
| && | Operatore logico AND. Se entrambi i lati delle operandi sono vere, la condizione è vera, altrimenti False. | (A && B) è False |
| || | Operatore logico OR. Se gli operandi da entrambe le parti c'è una vera, la condizione è vera, altrimenti False. | (A || B) è True |
| ! | NOT logico operatore. Se la condizione è vera, allora la logica NOT Condizione falsa, altrimenti Vero. | ! (A && B) è vera |
L'esempio seguente dimostra l'uso di operatori logici:
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" )
}
}
Esempi dei risultati operativi di cui sopra:
第二行 - 条件为 true 第三行 - 条件为 false 第四行 - 条件为 true
operatori bit per bit su interi bit di memoria funzionano.
Nella tabella seguente sono elencati gli operatori bit a bit &, |, e ^ si calcola:
| 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 |
Si supponga che A = 60; B = 13, il suo numero binario a:
A = 0011 1100 B = 0000 1101 ----------------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
Bit simbolo lingua supporto C mostrato nella tabella seguente. Si supponga che A è di 60, B è 13:
| operatori | descrizione | Esempi |
|---|---|---|
| & | Bitwise operatore "&" è degli operatori binari. La sua funzione è di due numeri binari corrispondenti a ogni fase dell'operazione e partecipazione. | (A & B) risultato è 12, il binario è 0000 1100 |
| | | OR bit a bit operatore "|" è un operatore binario. La sua funzione è quella di partecipare all'operazione di due numeri corrispondenti ciascuna fase binaria o | (A | B) il risultato è 61, il binario è 00.111.101 |
| ^ | OR di bit esclusivo operatore "^" è degli operatori binari. La sua funzione è quella di partecipare all'operazione di due numeri corrispondenti ciascuna XOR binario quando due bit corrispondente binario diverso e il risultato è 1. | (A ^ B) si traduce per il 49 binari a 00.110.001 |
| << | A sinistra operatore di spostamento "<<" è gli operatori binari. N-bit spostamento a sinistra viene moltiplicato per 2 ^ n. La sua funzione di ciascun binario "<<" sinistra della operando sinistro di tutto un numero di bit specificato dal numero "<<" diritto delle mosse decimali, scartando gli 0 alte e basse. | A << 2 risultati per 240 binario è 11110000 |
| >> | Destra operatore di spostamento ">>" sono operatori binari. Destra di n bit è diviso per 2 ^ n. La sua funzione è quella di vari binario ">>" l'operando sinistro Diversi tutto bene, ">>" a destra del numero di bit specificato. | A >> 2 risultati per 15 0000 1111 sistema binario |
L'esempio seguente dimostra l'uso di operatori logici:
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 )
}
Esempi dei risultati operativi di cui sopra:
第一行 - c 的值为 12 第二行 - c 的值为 61 第三行 - c 的值为 49 第四行 - c 的值为 240 第五行 - c 的值为 15
La seguente tabella elenca tutti i Go operatore di assegnazione lingua.
| operatori | descrizione | Esempi |
|---|---|---|
| = | operatore di assegnamento semplice assegna un'espressione valore di un lvalue | C = A + B A + B verrà assegnato al risultato dell'espressione C |
| + = | Aggiunto insieme prima assegnazione | C + = A è uguale a C = C + A |
| - = | Dopo assegnazione sottrazione | C - = A è uguale a C = C - A |
| * = | Poi moltiplicando l'assegnazione | C * = A è uguale a C = C * A |
| / = | Divisione dopo l'assegnazione | C / = A è uguale a C = C / A |
| % = | Resto dopo l'assegnazione | C% = A è uguale a C = C% A |
| << = | A sinistra dopo l'assegnazione | C << = 2 pari a C = C << 2 |
| >> = | Subito dopo l'assegnazione | C >> = 2 pari a C = C >> 2 |
| & = | AND bit a bit assegnazione dopo | C & = 2 pari a C = C & 2 |
| ^ = | Dopo aver premuto l'assegnazione XOR bit | C ^ = 2 pari a C = C ^ 2 |
| | = | Dopo aver premuto posizione o assegnazione | C | = 2 è uguale a C = C | 2 |
L'esempio seguente illustra l'uso dell'operatore di assegnazione:
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 )
}
Esempi dei risultati operativi di cui sopra:
第 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
Nella tabella seguente sono elencati gli altri operatori Go lingua.
| operatori | descrizione | Esempi |
|---|---|---|
| & | Rientro indirizzo di memoria variabile | & A; darà l'indirizzo reale della variabile. |
| * | variabile puntatore. | * A; è una variabile puntatore |
L'esempio seguente mostra l'utilizzo di altri operatori:
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);
}
Esempi dei risultati operativi di cui sopra:
第 1 行 - a 变量类型为 = int 第 2 行 - b 变量类型为 = int32 第 3 行 - c 变量类型为 = float32 a 的值为 4 *ptr 为 4
Alcuni operatori hanno una priorità più alta, gli operatori binari sono la direzione operativa da sinistra a destra. La seguente tabella elenca tutti gli operatori e le loro priorità, rappresentanti dall'alto verso il basso in priorità discendente:
| priorità | operatori |
|---|---|
| 7 | ^! |
| 6 | * /% ^ & << >> & |
| 5 | + - | ^ |
| 4 | ==! = << => => |
| 3 | <- |
| 2 | && |
| 1 | || |
Naturalmente, è possibile utilizzare le parentesi per migliorare temporaneamente la priorità generale del funzionamento di una espressione.
Esempi dei risultati operativi di cui sopra:
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 );
}
Esempi dei risultati operativi di cui sopra:
(a + b) * c / d 的值为 : 90 ((a + b) * c) / d 的值为 : 90 (a + b) * (c / d) 的值为 : 90 a + (b * c) / d 的值为 : 50