Operatori del linguaggio Go

Gli operatori sono la base di qualsiasi linguaggio di programmazione. Pertanto, senza l'uso degli operatori, le funzionalità del linguaggio Go sono incomplete. Gli operatori ci permettono di eseguire diversi tipi di operazioni sugli operandi. In Go, si possono classificare in base alle funzioni degli operatori:

• Operatori aritmetici

• Operatori di relazione

• Operatori logici

• Operatori bitwise

• Operatore di assegnazione

• Operatore di varietà

Operatori aritmetici

Questi sono usati per eseguire operazioni aritmetiche/matematiche sugli operandi del linguaggio Go:

• Addizione: L'operatore ‘+’ aggiunge due operandi. Ad esempio, x + y.

• Sottrazione: L'operatore ‘-’ sottrae due operandi. Ad esempio, x - y.

• Moltiplicazione: '*' operatore moltiplica due operandi. Ad esempio, x * y.

• Divisione: L'operatore '/' divide il primo operando per il secondo. Ad esempio, x / y.

• Calcolo modulo:Quando il primo operando viene diviso per il secondo operando, l'operatore '%' restituisce il resto. Ad esempio, x % y.

Attenzione: -，+，!，＆，*，<- e ^ sono anche chiamati operatori unari, gli operatori unari hanno una priorità più alta. Gli operatori ++ e -- derivano dalla frase, non sono espressioni, quindi non sono nella gerarchia degli operatori.

package main
import "fmt"
func main() {
　　　　p := 34
　　　　q := 20
　　　　// Somma
　　　　result1 := p + q
　　　　fmt.Printf("Risultato di calcolo p + q = %d", result1)
　　　　// Sottrazione
　　　　result2 := p - q
　　　　fmt.Printf("\nRisultato di calcolo p - q = %d", result2)
　　　　// Moltiplicazione
　　　　result3 := p * q
　　　　fmt.Printf("\nRisultato di calcolo p * q = %d", result3)
　　　　// Divisione
　　　　result4 := p / q
　　　　fmt.Printf("\nRisultato di calcolo p / q = %d", result4)
　　　　// Calcolo modulo
　　　　result5 := p % q
　　　　fmt.Printf("\nRisultato di calcolo p %% q = %d", result5)
}

Output:

Il risultato di p + q = 54
Il risultato di p - q = 14
Il risultato di p * q = 680
Il risultato di p / q = 1
Il risultato di p % q = 14

Operatori di relazione

Gli operatori di relazione vengono utilizzati per confrontare due valori. Vediamoli uno ad uno:

• '==' (uguale)L'operatore verifica se i due operandi dati sono uguali. Se sono uguali, restituisce true. Altrimenti, restituisce false. Ad esempio, 5 == 5 restituirà true.

• '!=' (non uguale)L'operatore verifica se i due operandi dati sono uguali. Se non sono uguali, restituisce true. Altrimenti, restituisce false. È il complemento booleano esatto dell'operatore '=='.

• '>' (maggiore)L'operatore verifica se il primo operando è maggiore del secondo operando. Se è maggiore, restituisce true. Altrimenti, restituisce false. Ad esempio, 6 > 5 restituirà true.

• '<' (minore)L'operatore verifica se il primo operando è minore del secondo operando. Se è minore, restituisce true. Altrimenti, restituisce false. Ad esempio, 6 < 5 restituirà false.

• '> = ' (maggiore o uguale)L'operatore verifica se il primo operando è maggiore o uguale al secondo operando. Se è maggiore o uguale, restituisce true. Altrimenti, restituisce false. Ad esempio, 5 >= 5 restituirà true.

• “<=”（minore o uguale）Il confrontatore verifica se il primo operando è minore o uguale al secondo operando. Se è minore o uguale, restituisce true. Altrimenti, restituisce false. Ad esempio, 5 <= 5 restituirà anche true.

package main
import "fmt"
func main() {
　　　　p := 34
　　　　q := 20
　　　　// ‘=='(uguale)
　　　　result1 := p == q
　　　　fmt.Println(result1)
　　　　// ‘!='(uguale)
　　　　result2 := p != q
　　　　fmt.Println(result2)
　　　　// ‘<'(minore)
　　　　result3 := p < q
　　　　fmt.Println(result3)
　　　　// ‘>'(maggiore)
　　　　result4 := p > q
　　　　fmt.Println(result4)
　　　　// ‘>='(maggiore o uguale)
　　　　result5 := p >= q
　　　　fmt.Println(result5)
　　　　// ‘<='(minore o uguale)
　　　　result6 := p <= q
　　　　fmt.Println(result6)
}

Output:

false
true
false
true
true
false

Operatori logici

• AND logicoQuando entrambe le condizioni considerate sono soddisfatte, l'operatore '&&' restituisce true. Altrimenti, restituisce false. Ad esempio, quando a e b sono entrambi veri (cioè non zero), a && b restituisce true.

• Logica o Quando una (o entrambe) delle condizioni è soddisfatta, l'operatore '||' restituisce true. Altrimenti, restituisce false. Ad esempio, se uno di a o b è vero (cioè non zero), || b restituisce true. Naturalmente, quando a e b sono entrambi veri, restituisce true.

• Logica non Non soddisfa le condizioni considerate, l'operatore '! 'restituisce true. Altrimenti, restituisce false. Ad esempio, se a è falso, ossia a = 0, allora !a restituisce true.

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

Output:

True
True
True

Operatori bitwise

In Go, ci sono 6 operatori bitwise che possono funzionare a livello di bit o essere utilizzati per operazioni bit per bit. Ecco gli operatori bitwise:

• ＆(operazione di bitwise AND): cheDue numeri come operandi, e si esegue l'operazione di 'AND' su ogni posizione dei due numeri. Il risultato di AND è 1 solo quando entrambi i bit sono 1.

• | (XOR): Prende}}Due numeri come operandi, e si esegue l'operazione "o" su ogni bit dei due numeri. Se almeno uno dei bit è 1, il risultato di OR è 1.

• ^ (XOR): PrendeDue numeri come operandi, e si esegue XOR su ogni bit dei due numeri. Se due bit sono diversi, il risultato di XOR è 1.

• << (sinistra):Prende due numeri, sposta a sinistra il bit del primo operando, il secondo operando determina il numero di bit da spostare.

• >> (destra):Prende due numeri, sposta a destra il bit del primo operando, il secondo operando determina il numero di bit da spostare.

• ＆^ (AND NOT):Operatore di cancellazione bit a bit, che esegue effettivamente l'operazione &(^)

package main
import "fmt"
func main() {
　　　　p := 134
　　　　q := 320
　　　　// & (AND)
　　　　result1 := p & q
　　　　fmt.Printf("Risultato del calcolo p & q = %d", result1)
　　　　// | (OR)
　　　　result2 := p | q
　　　　fmt.Printf("\nRisultato del calcolo p | q = %d", result2)
　　　　// ^ (XOR)
　　　　result3 := p ^ q
　　　　fmt.Printf("\nRisultato del calcolo p ^ q = %d", result3)
　　　　// << (sinistra)
　　　　result4 := p << 1
　　　　fmt.Printf("\nRisultato del calcolo p << 1 = %d", result4)
　　　　// >> (destra)
　　　　result5 := p >> 1
　　　　fmt.Printf("\nRisultato del calcolo p >> 1 = %d", result5)
　　　　// &^ (AND NOT)
　　　　result6 := p &^ q
　　　　fmt.Printf("\nRisultato del calcolo p &^ q = %d", result6)
}

Output:

Risultato del calcolo p & q = 0
Risultato del calcolo p | q = 454
Risultato del calcolo p ^ q = 454
Risultato del calcolo p << 1 = 268
Risultato del calcolo p >> 1 = 67
Risultato del calcolo p &^ q = 134

Operatore di assegnazione

L'operatore di assegnazione viene utilizzato per assegnare un valore a una variabile. L'operando di sinistra dell'operatore di assegnazione è una variabile, mentre l'operando di destra è un valore. Il valore di destra deve avere lo stesso tipo di dati della variabile di sinistra, altrimenti il compilatore genererà un errore. Ecco alcuni esempi di operatori di assegnazione di tipo diverso:

• " = " (assegnazione semplice):Questo è l'operatore di assegnazione più semplice. Questo operatore viene utilizzato per assegnare il valore di destra al variabile di sinistra.

• “ + =”（assegnazione aggiunta）：Questo operatore è la combinazione di "+" e l'operatore "=". Questo operatore prima aggiunge il valore corrente della variabile di sinistra al valore di destra, quindi assegna il risultato alla variabile di sinistra.

• “ -=”（assegnazione sottrazione）：Questo operatore è la combinazione di "-" e l'operatore "=". Questo operatore prima sottrae il valore corrente della variabile di sinistra dal valore di destra, quindi assegna il risultato alla variabile di sinistra.

• “ * =”（assegnazione moltiplicazione）：Questo operatore è la combinazione di "*" e l'operatore "=". Questo operatore prima moltiplica il valore corrente della variabile di sinistra per il valore di destra, quindi assegna il risultato alla variabile di sinistra.

• “ / =”（assegnazione divisione）：Questo operatore è la combinazione di "/" e l'operatore "=". Questo operatore prima divide il valore corrente della variabile di sinistra per il valore di destra, quindi assegna il risultato alla variabile di sinistra.

• “％=”（assegnazione modulo）：Questo operatore è la combinazione di "%" e l'operatore "=". Questo operatore prima moltiplica il valore corrente della variabile di sinistra per il valore di destra, quindi assegna il risultato alla variabile di sinistra.

• “＆=”（assegnazione e bitwise）：Questo operatore è la combinazione di "＆" e l'operatore "=". Questo operatore prima esegue un "e bitwise " tra il valore corrente della variabile di sinistra e il valore di destra, quindi assegna il risultato alla variabile di sinistra.

• “ ^ =”（esclusione bitwise）：Questo operatore è la combinazione di "^" e l'operatore "=". Questo operatore prima esegue un "esclusione bitwise " tra il valore corrente della variabile di sinistra e il valore di destra, quindi assegna il risultato alla variabile di sinistra.

• “ | =”（o bitwise）：Questo operatore è la combinazione di " | " e l'operatore "=". Questo operatore prima esegue un "o bitwise " tra il valore corrente della variabile di sinistra e il valore di destra, quindi assegna il risultato alla variabile di sinistra.

package main　
　　　　
import "fmt"
　　　　
func main() {　
　　　var p int = 38
　　　　var q int = 70
　　　　　　　
　　　// "="(assegnazione semplice)　
　　　p = q　
　　　fmt.Println(p)　
　　　　　　　
　　　// "+= "(assegnazione aggiunta)　
　　　　p += q　
　　　fmt.Println(p)　
　　　　　　　
　　　// "-= "(assegnazione sottrazione)　
　　　p -= q　
　　　fmt.Println(p)　
　　　　　　　
　　　// "*= "(assegnazione moltiplicazione)　
　　　p *= q　
　　　fmt.Println(p)　
　　　　　　　
　　　// "/="(assegnazione divisione)　
　　　　p /= q　
　　　fmt.Println(p)　
　　　　　　
　　　　// "%= "(assegnazione modulo)　
　　　　p %= q　
　　　fmt.Println(p)　
　　　　　　
}

Output:

70
140
70
4900
70
0

Operatore di varietà

• ＆：Questo operatore restituisce l'indirizzo del variabile.

• *：Questo operatore fornisce un puntatore al variabile.

• <-：Il nome di questo operatore è ricezione. Serve per ricevere valori da un canale.

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

Output:

94
67