Operatori Bitwise in Go

Gli operatori bitwise in Go permettono di manipolare i singoli bit dei numeri interi. Sono utili per ottimizzazioni, flag, maschere e operazioni a basso livello.

Operatori Disponibili

Operatore	Nome	Descrizione
&	AND	1 solo se entrambi i bit sono 1
|	OR	1 se almeno un bit è 1
^	XOR	1 se i bit sono diversi
&^	AND NOT (bit clear)	Cancella i bit specificati
<<	Shift sinistro	Sposta i bit a sinistra
>>	Shift destro	Sposta i bit a destra

AND Bitwise (&)

a := 12  // 1100
b := 10  // 1010

fmt.Println(a & b)  // 8 → 1000

Utile per verificare se un bit specifico è impostato.

OR Bitwise (|)

a := 12  // 1100
b := 10  // 1010

fmt.Println(a | b)  // 14 → 1110

Utile per impostare bit specifici.

XOR Bitwise (^)

a := 12  // 1100
b := 10  // 1010

fmt.Println(a ^ b)  // 6 → 0110

// Come operatore unario, ^ inverte tutti i bit (complemento)
fmt.Println(^a)  // -13 (complemento a due)

AND NOT / Bit Clear (&^)

Operatore esclusivo di Go che cancella bit specifici:

a := 12  // 1100
b := 10  // 1010

fmt.Println(a &^ b)  // 4 → 0100
// Cancella da 'a' i bit che sono 1 in 'b'

Shift Sinistro (<<) e Destro (>>)

a := 3    // 0011
fmt.Println(a << 1)  // 6  → 0110
fmt.Println(a << 2)  // 12 → 1100

b := 12   // 1100
fmt.Println(b >> 1)  // 6  → 0110
fmt.Println(b >> 2)  // 3  → 0011

Lo shift sinistro equivale a moltiplicare per potenze di 2, lo shift destro a dividere.

Pattern: Gestione Flag con Bitmask

const (
    Lettura    = 1 << iota // 001 = 1
    Scrittura              // 010 = 2
    Esecuzione             // 100 = 4
)

func main() {
    permessi := Lettura | Scrittura // 011 = 3

    // Verifica se ha il permesso di lettura
    if permessi&Lettura != 0 {
        fmt.Println("Ha permesso di lettura")
    }

    // Aggiungi permesso di esecuzione
    permessi |= Esecuzione // 111 = 7

    // Rimuovi permesso di scrittura
    permessi &^= Scrittura // 101 = 5
}

Pattern: Potenze di 2

const (
    KB = 1 << 10 // 1024
    MB = 1 << 20 // 1.048.576
    GB = 1 << 30 // 1.073.741.824
)

Conclusione

Gli operatori bitwise sono strumenti potenti per manipolazioni a basso livello. In Go, l’operatore &^ (AND NOT) è una peculiarità che semplifica la cancellazione di bit specifici. L’uso combinato con iota e le costanti rende la gestione dei flag particolarmente elegante.