Operatori Go

1 Panoramica degli Operatori in Golang

Nel linguaggio Go, gli operatori vengono utilizzati per eseguire le operazioni del codice del programma, tra cui operazioni aritmetiche, confronti relazionali, operazioni logiche e altro. Operatori diversi corrispondono a funzionalità e scenari d'uso differenti. Comprendere e padroneggiare questi operatori è fondamentale per una programmazione efficace.

2 Operatori Aritmetici

Il linguaggio Go fornisce un insieme di operatori aritmetici:

• Addizione (+): Operazione di addizione
• Sottrazione (-): Operazione di sottrazione
• Moltiplicazione (*): Operazione di moltiplicazione
• Divisione (/): Operazione di divisione
• Resto (%): Operazione modulo

Esempi:

package main

import "fmt"

func main() {
    // Operazione di addizione
    sum := 10 + 5
    fmt.Println("10 + 5 =", sum) // Stampa 15

    // Operazione di sottrazione
    diff := 10 - 5
    fmt.Println("10 - 5 =", diff) // Stampa 5

    // Operazione di moltiplicazione
    prod := 10 * 5
    fmt.Println("10 * 5 =", prod) // Stampa 50

    // Operazione di divisione
    quot := 10 / 5
    fmt.Println("10 / 5 =", quot) // Stampa 2

    // Operazione modulo
    rem := 10 % 5
    fmt.Println("10 % 5 =", rem) // Stampa 0
}

3 Operatori Logici

Gli operatori logici nel linguaggio Go sono utilizzati per collegare più condizioni (generalmente utilizzate per valori booleani). Comprendono tre tipi: AND (&&), OR (||) e NOT (!).

3.1 AND (&&)

Quando tutte le condizioni sono vere, il risultato dell'operazione "AND" è vero.

Esempi:

package main

import "fmt"

func main() {
    fmt.Println(true && true)   // Stampa vero
    fmt.Println(true && false)  // Stampa falso
    fmt.Println(false && false) // Stampa falso
    // Il risultato è vero solo quando entrambe le condizioni sono vere
}

3.2 OR (||)

Se almeno una condizione è vera, il risultato dell'operazione "OR" è vero.

Esempi:

package main

import "fmt"

func main() {
    fmt.Println(true || true)   // Stampa vero
    fmt.Println(true || false)  // Stampa vero
    fmt.Println(false || false) // Stampa falso
    // Il risultato è vero se almeno una condizione è vera
}

3.3 NOT (!)

Utilizzato per invertire il valore booleano di una condizione.

Esempi:

package main

import "fmt"

func main() {
    fmt.Println(!true)  // Stampa falso
    fmt.Println(!false) // Stampa vero
    // Inverte il valore booleano
}

4 Operatori di Confronto

Gli operatori di confronto nel linguaggio Go sono utilizzati per confrontare due variabili o valori:

• Uguale a (==)
• Diverso da (!=)
• Maggiore di (>)
• Minore di (<)
• Maggiore o uguale a (>=)
• Minore o uguale a (<=)

Il risultato delle operazioni di confronto è un valore booleano: true o false.

5 Operatori Bitwise

In Go, gli operatori bitwise ci permettono di manipolare direttamente i bit binari dei dati:

• Bitwise AND (&)
• Bitwise OR (|)
• Bitwise XOR (^)
• Spostamento bitwise a sinistra (<<)
• Spostamento bitwise a destra (>>)

Gli operatori bitwise sono principalmente utilizzati nella programmazione a basso livello, come operazioni dirette sull'hardware, crittografia e altri scenari.

6 Operatori di Assegnamento

Gli operatori di assegnamento sono utilizzati per assegnare valori alle variabili. Nel linguaggio Go, ci sono diverse forme di operatori di assegnamento:

• Assegnazione semplice (=)
• Assegnazione di aggiunta (+=)
• Assegnazione di sottrazione (-=)
• Assegnazione di moltiplicazione (*=)
• Assegnazione di divisione (/=)
• Assegnazione di modulo (%=)

Questi operatori rendono il codice più conciso. Ad esempio, x += 1 è equivalente a x = x + 1.

7 Operatori Speciali

7.1 Operatori Incremento (++) e Decremento (--)

L'operatore di incremento (++) e l'operatore di decremento (--) vengono utilizzati per aggiungere 1 e sottrarre 1 al valore di una variabile, rispettivamente. Sono gli unici operatori nel linguaggio Go che possono agire direttamente sulla variabile stessa (non su un'espressione).

package main

import "fmt"

func main() {
    x := 1
    x++
    fmt.Println("x++ =", x) // Stampa 2

    y := 10
    y--
    fmt.Println("y-- =", y) // Stampa 9
}

Si noti che nel linguaggio Go, x++ o x-- non possono fare parte di un'espressione. Ad esempio, z := x++ non è consentito.

7.2 Conversione di tipo

Il linguaggio Go è staticamente tipizzato, il che significa che una volta dichiarata una variabile, il suo tipo non può essere modificato. Pertanto, a volte è necessario convertire una variabile da un tipo a un altro. Go non ha conversioni di tipo automatiche; è richiesta la conversione esplicita del tipo.

Esempio:

package main

import (
	"fmt"
)

func main() {
	var i int = 42
	fmt.Println(float64(i)) // Converti int in float64

	var f float64 = 3.14
	fmt.Println(int(f)) // Converti float64 in int, la parte decimale verrà scartata
}

Quando si esegue la conversione di tipo, è importante assicurarsi che i dati siano sicuri durante il processo di conversione, ad esempio la possibile perdita di precisione durante la conversione di un numero in virgola mobile in un intero.