Operatori Logici in Go

Gli operatori logici in Go permettono di combinare espressioni booleane per creare condizioni più complesse. Restituiscono sempre un valore bool.

Operatori Disponibili

Operatore	Nome	Descrizione
&&	AND logico	Vero se entrambe le condizioni sono vere
||	OR logico	Vero se almeno una condizione è vera
!	NOT logico	Inverte il valore booleano

AND Logico (&&)

L’operatore && restituisce true solo se entrambe le condizioni sono vere:

package main

import "fmt"

func main() {
    eta := 25
    haPatente := true

    if eta >= 18 && haPatente {
        fmt.Println("Puoi guidare")
    }

    fmt.Println(true && true)   // true
    fmt.Println(true && false)  // false
    fmt.Println(false && true)  // false
    fmt.Println(false && false) // false
}

OR Logico (||)

L’operatore || restituisce true se almeno una condizione è vera:

func main() {
    giorno := "sabato"

    if giorno == "sabato" || giorno == "domenica" {
        fmt.Println("È weekend!")
    }

    fmt.Println(true || true)   // true
    fmt.Println(true || false)  // true
    fmt.Println(false || true)  // true
    fmt.Println(false || false) // false
}

NOT Logico (!)

L’operatore ! inverte un valore booleano:

func main() {
    attivo := false

    if !attivo {
        fmt.Println("L'utente non è attivo")
    }

    fmt.Println(!true)  // false
    fmt.Println(!false) // true
}

Valutazione Short-Circuit

Go utilizza la valutazione a corto circuito: se il risultato è determinabile dal primo operando, il secondo non viene valutato.

func controlloLento() bool {
    fmt.Println("Questa funzione è stata chiamata")
    return true
}

func main() {
    // controlloLento() NON viene chiamata perché false && ... è sempre false
    if false && controlloLento() {
        fmt.Println("Non raggiungibile")
    }

    // controlloLento() NON viene chiamata perché true || ... è sempre true
    if true || controlloLento() {
        fmt.Println("Sempre raggiungibile")
    }
}

Combinare Più Condizioni

func puoIscriversi(eta int, haDocumenti bool, haAcconto bool) bool {
    return eta >= 18 && (haDocumenti || haAcconto)
}

Le parentesi controllano la precedenza: ! ha la precedenza più alta, seguita da &&, poi ||.

Conclusione

Gli operatori logici sono essenziali per costruire condizioni complesse in Go. Sfruttare la valutazione short-circuit può migliorare le performance evitando calcoli inutili, ed è importante conoscere la precedenza degli operatori per evitare errori logici.