Come usare gli operatori in Golang

Gli operatori sono il fondamento di ogni linguaggio di programmazione. Pertanto, la funzionalità del linguaggio Golang è incompleta senza l'uso degli operatori. Gli operatori consentono di eseguire diversi tipi di operazioni sugli operandi. Nel linguaggio Go, gli operatori possono essere classificati in base alle loro diverse funzioni .

operatori aritmetici

Questi operatori vengono utilizzati per eseguire operazioni sugli operandi nel linguaggio Go:

• Addizione: '+' aggiunge due operandi. Ad esempio: x+y.
• Sottrazione: '-' sottrae due operandi. Esempio: xy.
• Moltiplicazione: '*' moltiplica due operandi. Ad esempio: x*y.
• Divisione: '/' divide il primo operando per il secondo operando. Ad esempio: x/y.
• Resto: l'operatore '%' restituisce il resto quando il primo operando viene diviso per il secondo operando. Ad esempio: x%y.

 Nota: -, +, !, &, *, <- e ^ sono anche chiamati operatori unari e la precedenza degli operatori unari è più alta. Gli operatori ++ e — provengono da istruzioni, non sono espressioni, quindi sono esterni alla gerarchia degli operatori.

Per esempio:

//Minh họa chương trình Go dùng toán tử số học
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// Phép cộng
result1:= p + q 
fmt.Printf("Result of p + q = %d", result1) 
	
// Phép trừ
result2:= p - q 
fmt.Printf("\nResult of p - q = %d", result2) 
	
// Phép nhân
result3:= p * q 
fmt.Printf("\nResult of p * q = %d", result3) 
	
// Division 
result4:= p / q 
fmt.Printf("\nResult of p / q = %d", result4) 
	
// Modulus 
result5:= p % q 
fmt.Printf("\nResult of p %% q = %d", result5) 
} 

Risultato:

Kết quả của p + q = 54
Kết quả của p - q = 14
Kết quả của p * q = 680
Kết quả của p / q = 1
Kết quả của p % q = 14

Operatori relazionali

Gli operatori relazionali vengono utilizzati per confrontare due valori. Diamo un'occhiata a ciascun operatore uno per uno:

• L'operatore '=='(Uguale) controlla se i due operandi dati sono uguali o meno. Se è uguale, restituisce true. In caso contrario, restituisce falso. Ad esempio, 5==5 restituirà true.
• L'operatore '!='(Diverso da) controlla se i due operandi dati sono uguali o meno. Altrimenti restituisce true. In caso contrario, restituisce falso. Questo è il complemento booleano esatto dell'operatore '=='. Ad esempio, 5!=5 restituirà falso.
• L'operatore '>' (Maggiore di) controlla se il primo operando è maggiore del secondo operando. Se è maggiore, restituisce true. Se è inferiore, restituisce falso. Ad esempio, 6>5 restituirà true.
• L'operatore '<' (minore di) controlla se il primo operando è minore del secondo operando. Se è inferiore, restituisce true. In caso contrario, restituisce falso. Ad esempio, <5 restituirà
• L'operatore '>='(Maggiore di uguale) controlla se il primo operando è maggiore o uguale al secondo operando. Se maggiore o uguale, restituisce true. Se minore o uguale, restituisce falso. Ad esempio: 5>=5 restituirà true.
• L'operatore '<=' (minore o uguale a) controlla se il primo operando è minore o uguale al secondo operando. Se è maggiore o uguale, restituisce true. Se è minore o uguale, restituisce falso. Ad esempio: <=5 restituirà anche

Per esempio:

// Minh họa chương trình Go dùng toán tử quan hệ
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// ‘=='(Equal To) 
result1:= p == q 
fmt.Println(result1) 
	
// ‘!='(Not Equal To) 
result2:= p != q 
fmt.Println(result2) 
	
// ‘<‘(less than)="" result3:="p">< q="" fmt.println(result3)="" ‘="">'(Greater Than) 
result4:= p > q 
fmt.Println(result4) 
	
// ‘>='(Greater Than Equal To) 
result5:= p >= q 
fmt.Println(result5) 
	
// ‘<='(less than="" equal="" to)="" result6:="p"><= q="" fmt.println(result6)="" }="">

Risultato:

false
true
false
true
true
false

operatori logici

Vengono utilizzati per combinare due o più condizioni/vincoli o per integrare la valutazione della condizione iniziale in esame.

• AND: l'operatore '&&' restituisce true quando entrambe le condizioni in esame sono soddisfatte. In caso contrario, restituisce falso. Ad esempio, a && b restituisce true quando sia a che b sono true (ovvero diversi da zero).
• OPPURE: Operatore '||' Restituisce true quando una (o entrambe) le condizioni in esame sono soddisfatte. In caso contrario, restituisce falso. Ad esempio: a || b restituisce true se a o b è vero (ovvero diverso da zero). Naturalmente, restituisce true quando sia a che b sono true.
• NON logico: il '!' operatore Restituisce true quando la condizione in esame non è soddisfatta. In caso contrario, restituisce falso. Ad esempio: !a restituisce true se a è falso, cioè quando a = 0.

Per esempio:

// Minh họa chương trình Go dùng toán tử logic
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" ||=""><=q){ fmt.println("true")="" }="" if(!(p="=q)){" fmt.println("true")="" }="" }="">

Risultato:

True
True
True

operatori bit a bit

Nel linguaggio Go ci sono 6 operatori bit a bit che operano a livello di bit o vengono utilizzati per eseguire operazioni bit per bit. Di seguito sono riportati gli operatori bit a bit:

• & (AND bit a bit): accetta due numeri come operandi ed esegue AND su ogni bit dei due numeri. Il risultato di AND è 1 solo se entrambi i bit sono 1.
• | (OR bit a bit): accetta due numeri come operandi ed esegue l'OR su ogni bit dei due numeri. Il risultato di OR è 1 se uno dei due bit è 1.
• ^ (XOR bit a bit): accetta due numeri come operandi ed esegue XOR su ogni bit dei due numeri. Il risultato di XOR è 1 se i due bit sono diversi.
• < (sposta a sinistra): prende due numeri, sposta i bit del primo operando a sinistra, il secondo operando determina il numero di posizioni da spostare
• >> (spostamento a destra): prendi due numeri, sposta i bit del primo operando a destra, il secondo operando determina il numero di posizioni da spostare.
• &^ (AND NOT): questo è un operatore bit a bit esplicito.

Per esempio:

// Minh họa chương trình Go dùng toán tử bitwise
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// & (bitwise AND) 
result1:= p & q 
fmt.Printf("Result of p & q = %d", result1) 
	
// | (bitwise OR) 
result2:= p | q 
fmt.Printf("\nResult of p | q = %d", result2) 
	
// ^ (bitwise XOR) 
result3:= p ^ q 
fmt.Printf("\nResult of p ^ q = %d", result3) 
	
// < (left="" shift)="" result4:="p">< 1="" fmt.printf("\nresult="" of="" p="">< 1="%d" ,"="" result4)="">> (right shift) 
result5:= p >> 1
fmt.Printf("\nResult of p >> 1 = %d", result5) 
	
// &^ (AND NOT) 
result6:= p &^ q 
fmt.Printf("\nResult of p &^ q = %d", result6) 
	
	
} 

Risultato:

Kết quả của p & q = 0
Kết quả của p | q = 54
Kết quả của p ^ q = 54
Kết quả của p < 1="68" kết="" quả="" của="" p="">> 1 = 17
Kết quả của p &^ q = 34

Operatore di assegnazione

L'operatore di assegnazione viene utilizzato per assegnare un valore a una variabile. L'operando sinistro dell'operatore di assegnazione è una variabile e l'operando destro dell'operatore di assegnazione è un valore. Il valore a destra deve avere lo stesso tipo di dati della variabile a sinistra, altrimenti il ​​compilatore restituirà un errore. Di seguito sono riportati i diversi tipi di operatori di assegnazione:

• “="(Assegnazione semplice): questo è l'operatore di assegnazione più semplice. Questo operatore viene utilizzato per assegnare il valore a destra alla variabile a sinistra.
• “+="(Assegnazione aggiuntiva): questo operatore è una combinazione degli operatori '+' e '='. Questo operatore somma prima il valore corrente della variabile di sinistra al valore della variabile di destra, quindi assegna il risultato alla variabile di sinistra.
• “-=”(Assegnazione meno): questo operatore è una combinazione degli operatori '-' e '='. Questo operatore sottrae prima il valore corrente della variabile di sinistra dal valore della variabile di destra, quindi assegna il risultato alla variabile di sinistra.
• “*=”(Assegnazione di moltiplicazione): questo operatore è una combinazione degli operatori '*' e '='. Questo operatore moltiplica prima il valore corrente della variabile di sinistra per il valore di destra, quindi assegna il risultato alla variabile di sinistra.
• “/="(Assegnazione di divisione): questo operatore è una combinazione degli operatori '/' e '='. Questo operatore divide prima il valore corrente della variabile di sinistra per il valore di destra, quindi assegna il risultato alla variabile di sinistra.
• “%="(Assegnazione del resto): questo operatore è una combinazione degli operatori '%' e '='. Questo operatore prende prima il resto del valore corrente della variabile di sinistra dato il valore sulla destra, quindi assegna il risultato alla variabile di sinistra.
• “&="(AND bit a bit): questo operatore è una combinazione degli operatori '&' e '='. Questo operatore esegue prima l'operazione "AND bit a bit" tra il valore corrente della variabile di sinistra e il valore di destra, quindi assegna il risultato alla variabile di sinistra.
• “^="(OR esclusivo bit a bit): questo operatore è una combinazione degli operatori '^' e '='. Questo operatore esegue prima l'operazione "OR esclusivo bit a bit" sul valore corrente della variabile di sinistra per il valore della variabile di destra e poi assegna il risultato alla variabile di sinistra.
• “|="(OR bit a bit inclusivo): questo operatore è una combinazione di '|' operatori e '='. Questo operatore esegue prima l'operazione "OR bit a bit inclusivo" tra il valore corrente della variabile di sinistra e il valore della variabile di destra, quindi assegna il risultato alla variabile di sinistra.
• "<=: questo operatore è una combinazione degli operatori < ' e '="'." Questo operatore prima "sposta" il valore corrente della variabile a sinistra del valore a destra e poi assegna il risultato alla variabile a destra.
• “>>=": questo operatore è una combinazione degli operatori '>>' e '='. Questo operatore prima esegue un "AND a destra" sul valore corrente della variabile a sinistra con il valore a destra, quindi assegna il risultato alla variabile a sinistra.

Per esempio:

// Minh họa chương trình Go dùng toán tử gán
package main 
	
import "fmt"
	
func main() { 
var p int = 45
	var q int = 50
	
// “=”(Simple Assignment) 
p = q 
fmt.Println(p) 
	
// “+=”(Add Assignment) 
	p += q 
fmt.Println(p) 
	
//“-=”(Subtract Assignment) 
p-=q 
fmt.Println(p) 
	
// “*=”(Multiply Assignment) 
p*= q 
fmt.Println(p) 
	
// “/=”(Division Assignment) 
	p /= q 
fmt.Println(p) 
	
	// “%=”(Modulus Assignment) 
	p %= q 
fmt.Println(p) 
	
} 

Risultato:

50
100
50
2500
50
0

Altri operatori

• &: questo operatore restituisce l'indirizzo di una variabile.
• *: Questo operatore fornisce un puntatore a una variabile.
• <-: Il nome di questo operatore è receive. Viene utilizzato per ricevere un valore da

// Minh họa chương trình sử dụng toán tử khác
package main 
	
import "fmt"
	
func main() { 
a := 4
	
// Dùng địa chỉ của toán tử (&) toán tử trỏ gián tiếp (*)

b := &a 
fmt.Println(*b) 
*b = 7
fmt.Println(a) 
} 

Risultato:

4
7