Operatori di Comparazione in Go

Gli operatori di comparazione in Go permettono di confrontare due valori e restituiscono un risultato booleano (true o false). Sono fondamentali per le strutture di controllo come if, for e switch.

Operatori Disponibili

Operatore	Descrizione	Esempio
==	Uguale a	a == b
!=	Diverso da	a != b
<	Minore di	a < b
>	Maggiore di	a > b
<=	Minore o uguale a	a <= b
>=	Maggiore o uguale a	a >= b

Confronto tra Numeri

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 <= 10) // true
    fmt.Println(a >= 20) // false
}

Confronto tra Stringhe

Le stringhe vengono confrontate lessicograficamente (ordine alfabetico basato sui valori Unicode):

package main

import "fmt"

func main() {
    s1 := "abc"
    s2 := "abd"

    fmt.Println(s1 == s2) // false
    fmt.Println(s1 < s2)  // true (c < d)
    fmt.Println("A" < "a") // true (A=65, a=97 in Unicode)
    fmt.Println("go" == "go") // true
}

Confronto tra Struct

Le struct possono essere confrontate con == e != solo se tutti i loro campi sono confrontabili:

type Punto struct {
    X, Y int
}

func main() {
    p1 := Punto{1, 2}
    p2 := Punto{1, 2}
    p3 := Punto{3, 4}

    fmt.Println(p1 == p2) // true
    fmt.Println(p1 == p3) // false
    fmt.Println(p1 != p3) // true
}

Nota: Le struct che contengono campi non confrontabili (come slice, map o funzioni) non possono essere confrontate direttamente.

Confronto con Interfacce

var a interface{} = 42
var b interface{} = 42
var c interface{} = "ciao"

fmt.Println(a == b) // true
fmt.Println(a == c) // false

Utilizzo nei Condizionali

func verificaEta(eta int) string {
    if eta >= 18 {
        return "Maggiorenne"
    }
    return "Minorenne"
}

Tipi Non Confrontabili

In Go, alcuni tipi non supportano il confronto diretto:

• Slice: usa slices.Equal() dal pacchetto slices
• Map: usa maps.Equal() dal pacchetto maps
• Funzioni: possono essere confrontate solo con nil

import "slices"

s1 := []int{1, 2, 3}
s2 := []int{1, 2, 3}
fmt.Println(slices.Equal(s1, s2)) // true

Conclusione

Gli operatori di comparazione sono alla base di ogni decisione logica nel codice Go. Ricorda che Go richiede che i tipi siano identici per effettuare un confronto, non esegue conversioni implicite tra tipi diversi.