Vai operatori del linguaggio

Successivo: Vai lingua istruzioni condizionali

Gli operatori vengono utilizzate per eseguire operazioni matematiche o logiche in un'applicazione in esecuzione.

Vai operatori sono costruiti nella lingua:

Gli operatori aritmetici
Operatori relazionali
Operatori logici
operatori bit per bit
Operatori di assegnazione
altri operatori

Diamo un'occhiata a ciascuno in particolare gli operatori introdotte.

Gli operatori aritmetici

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

Operatori relazionali

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

Operatori logici

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

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

Operatori di assegnazione

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

altri operatori

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

precedenza Operatore

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

Precedente: Go Lingua Constant

Successivo: Vai lingua istruzioni condizionali

Go corso

Vai operatori del linguaggio

Gli operatori aritmetici

Operatori relazionali

Operatori logici

operatori bit per bit

Operatori di assegnazione

altri operatori

precedenza Operatore