Booleani

Il tipo bool in Go

Il tipo bool in Go rappresenta un valore booleano che puo assumere solo due valori: true (vero) o false (falso). I booleani sono fondamentali per il controllo del flusso del programma e per le espressioni condizionali.

Dichiarazione di variabili booleane

Puoi dichiarare variabili booleane in diversi modi:

package main

import "fmt"

func main() {
    // Dichiarazione esplicita con tipo
    var attivo bool = true
    var completato bool = false

    // Dichiarazione con inferenza di tipo
    var visibile = true

    // Dichiarazione breve
    abilitato := true

    fmt.Println(attivo, completato, visibile, abilitato)
}

Valore zero

Il valore zero del tipo bool e false. Questo significa che una variabile booleana dichiarata senza un valore iniziale sara automaticamente false:

package main

import "fmt"

func main() {
    var predefinito bool
    fmt.Println(predefinito) // false

    // Anche nei campi di una struct
    type Configurazione struct {
        ModalitaDebug bool
        Verboso       bool
    }

    config := Configurazione{}
    fmt.Println(config.ModalitaDebug) // false
    fmt.Println(config.Verboso)       // false
}

Operazioni booleane

Go supporta tre operatori logici fondamentali per lavorare con i booleani:

AND logico (&&)

Restituisce true solo se entrambi gli operandi sono true:

package main

import "fmt"

func main() {
    fmt.Println(true && true)   // true
    fmt.Println(true && false)  // false
    fmt.Println(false && true)  // false
    fmt.Println(false && false) // false

    eta := 25
    haPatente := true
    puoGuidare := eta >= 18 && haPatente
    fmt.Println("Puo guidare:", puoGuidare) // true
}

OR logico (||)

Restituisce true se almeno uno degli operandi e true:

package main

import "fmt"

func main() {
    fmt.Println(true || true)   // true
    fmt.Println(true || false)  // true
    fmt.Println(false || true)  // true
    fmt.Println(false || false) // false

    eStudente := true
    eAnziano := false
    haSconto := eStudente || eAnziano
    fmt.Println("Ha sconto:", haSconto) // true
}

NOT logico (!)

Inverte il valore booleano:

package main

import "fmt"

func main() {
    fmt.Println(!true)  // false
    fmt.Println(!false) // true

    connesso := true
    disconnesso := !connesso
    fmt.Println("Disconnesso:", disconnesso) // false
}

Utilizzo nelle condizioni

I booleani sono il tipo fondamentale per le istruzioni condizionali in Go:

Istruzioni if

package main

import "fmt"

func main() {
    temperatura := 35

    caldo := temperatura > 30
    if caldo {
        fmt.Println("Fa molto caldo!")
    }

    // Espressione booleana diretta nell'if
    if temperatura > 25 && temperatura <= 30 {
        fmt.Println("Temperatura piacevole")
    } else if temperatura > 30 {
        fmt.Println("Troppo caldo")
    } else {
        fmt.Println("Fa fresco")
    }
}

Cicli con condizioni booleane

package main

import "fmt"

func main() {
    contatore := 0
    continua := true

    for continua {
        contatore++
        fmt.Printf("Iterazione %d\n", contatore)

        if contatore >= 5 {
            continua = false
        }
    }

    fmt.Println("Ciclo terminato dopo", contatore, "iterazioni")
}

Risultati di confronto

Gli operatori di confronto restituiscono sempre un valore booleano:

package main

import "fmt"

func main() {
    a, b := 10, 20

    fmt.Println(a == b)  // false
    fmt.Println(a != b)  // true
    fmt.Println(a < b)   // true
    fmt.Println(a > b)   // false
    fmt.Println(a <= b)  // true
    fmt.Println(a >= b)  // false

    // I risultati sono valori bool
    risultato := a < b
    fmt.Printf("Tipo: %T, Valore: %v\n", risultato, risultato)
    // Tipo: bool, Valore: true
}

Booleani come parametri e valori di ritorno

I booleani sono comunemente usati come parametri e valori di ritorno delle funzioni:

package main

import "fmt"

func ePari(n int) bool {
    return n%2 == 0
}

func eNellIntervallo(valore, minimo, massimo int) bool {
    return valore >= minimo && valore <= massimo
}

func valida(nome string) (bool, string) {
    if len(nome) == 0 {
        return false, "il nome non puo essere vuoto"
    }
    if len(nome) > 50 {
        return false, "il nome e troppo lungo"
    }
    return true, ""
}

func main() {
    fmt.Println(ePari(4))   // true
    fmt.Println(ePari(7))   // false

    fmt.Println(eNellIntervallo(25, 18, 65)) // true
    fmt.Println(eNellIntervallo(10, 18, 65)) // false

    valido, messaggio := valida("Mario")
    if valido {
        fmt.Println("Nome valido")
    } else {
        fmt.Println("Errore:", messaggio)
    }
}

Pattern comuni con i booleani

Flag di stato

package main

import "fmt"

type Server struct {
    Nome     string
    Attivo   bool
    InPausa  bool
}

func (s *Server) Stato() string {
    if !s.Attivo {
        return "spento"
    }
    if s.InPausa {
        return "in pausa"
    }
    return "in esecuzione"
}

func main() {
    server := Server{Nome: "web-01", Attivo: true, InPausa: false}
    fmt.Printf("%s: %s\n", server.Nome, server.Stato())

    server.InPausa = true
    fmt.Printf("%s: %s\n", server.Nome, server.Stato())
}

Idioma comma-ok

Un pattern molto comune in Go e l’idioma “comma-ok”, dove il secondo valore di ritorno e un booleano che indica il successo dell’operazione:

package main

import "fmt"

func main() {
    capitali := map[string]string{
        "Italia": "Roma",
        "Francia": "Parigi",
    }

    // L'idioma comma-ok per verificare l'esistenza
    capitale, ok := capitali["Italia"]
    if ok {
        fmt.Println("Trovato:", capitale) // Trovato: Roma
    }

    capitale, ok = capitali["Giappone"]
    if !ok {
        fmt.Println("Non trovato") // Non trovato
    }
}

Conclusione

Il tipo bool in Go e semplice ma essenziale. Con i suoi due valori (true e false), il valore zero false e i tre operatori logici (&&, ||, !), i booleani controllano il flusso di esecuzione dei programmi Go. L’idioma “comma-ok” e i pattern con flag di stato mostrano come i booleani vengano utilizzati idiomaticamente nella programmazione Go quotidiana.