Impara Operatori Logici | Strutture di Controllo

Un'altra categoria di operatori è rappresentata dagli operatori logici. A differenza di altri operatori che operano su valori numerici, gli operatori logici sono progettati per gestire valori booleani. Esistono tre operatori logici:

Operatore	Logica
`!`	NOT
`\|\|`	OR
`&&`	AND

L'operatore NOT (!) viene utilizzato per negare (invertire) un'espressione booleana. Ecco un semplice esempio che include una if-statement:

index.go


              12345678
            
package main
import "fmt"

func main() {
    if (false) {
        fmt.Println("Print if True")
    }
}

Nel codice sopra, l'istruzione Print non verrà eseguita perché la condizione è false per impostazione predefinita. Tuttavia, se includiamo un operatore NOT nell'espressione, questa verrà negata e, di conseguenza, sarà equivalente a true:

index.go


              12345678
            
package main
import "fmt"

func main() {
    if (!false) {
        fmt.Println("Print if True")
    }
}

Possiamo anche utilizzare l'operatore NOT (!) in casi più complessi. Tuttavia, è necessario racchiudere le espressioni tra parentesi prima di negarle. Ad esempio, se vogliamo negare 3 > 4, scriveremmo !(3 > 4):

index.go


              12345678
            
package main
import "fmt"

func main() {
    if (!(3 > 4)) {
        fmt.Println("Print if True")
    }
}

L'operatore OR (||) valuta due operandi e restituisce true se almeno uno degli operandi è true.

Nota

Un operando si riferisce a un valore o a un'espressione utilizzata come input per un operatore in un'istruzione o espressione. Ad esempio, nell'espressione 1 + 2, i valori 1 e 2 sono operandi. Nel caso degli operatori logici, un operando è sempre un'espressione o un valore booleano.

Ecco un esempio che illustra l'utilizzo di base degli operatori logici:

index.go


              1234567
            
package main
import "fmt"

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

La prima istruzione restituisce true perché uno degli operandi nell'espressione true || false è true. Al contrario, la seconda istruzione restituisce false poiché entrambi gli operandi sono false in quell'espressione. Di seguito è riportata la tabella della verità per l'operatore logico OR:

Nota

Una tabella della verità è una rappresentazione logica che mostra tutte le possibili combinazioni di ingressi e i relativi valori di uscita.

Input	Output
`true \|\| true`	true
`true \|\| false`	true
`false \|\| true`	true
`false \|\| false`	false

È possibile concatenare operatori logici OR per combinare più operandi. In questo caso, l'espressione viene valutata da sinistra a destra:

index.go


              123456
            
package main
import "fmt"

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

L'ordine di valutazione per l'espressione sopra è il seguente:

Nota

Per impostazione predefinita, tutte le espressioni logiche vengono valutate da sinistra a destra.

L'operatore logico AND (&&) è simile all'operatore OR (||), ma restituisce true solo se entrambi gli operandi hanno valore true. La tabella della verità per l'operazione logica AND (&&) è fornita di seguito:

Input	Output
`true && true`	true
`true && false`	false
`false && true`	false
`false && false`	false

Segue un esempio più complesso che dimostra un utilizzo pratico degli operatori logici. Prendere un momento per esaminare il codice e comprenderne il funzionamento:

index.go


              1234567891011
            
package main
import "fmt"

func main() {
    var x int = 99
    if (1 <= x && x <= 10 || 90 <= x && x <= 100) {
        fmt.Printf("The value %d is in the range 1-10 or 90-100", x)
    } else {
        fmt.Printf("The value %d is not in the range 1-10 or 90-100", x)
    }
}

Si noti che nell'esempio sopra vengono utilizzati più operatori e valori per creare una condizione più complessa. Durante l'esecuzione, l'espressione viene valutata in base alla priorità degli operatori. Gli operatori con priorità più alta vengono valutati per primi, ed è importante comprendere l'ordine in cui vengono elaborati. Gli operatori di confronto hanno una priorità superiore rispetto agli operatori logici.

Di seguito è riportato un diagramma che illustra la classifica di priorità degli operatori logici:

Il diagramma seguente illustra come viene valutata l'espressione 1 <= x && x <= 10 || 90 <= x && x <= 100:

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 4

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Awesome!

Completion rate improved to 1.96

Scorri per mostrare il menu

Operatore	Logica
`!`	NOT
`\|\|`	OR
`&&`	AND

L'operatore NOT (!) viene utilizzato per negare (invertire) un'espressione booleana. Ecco un semplice esempio che include una if-statement:

index.go


              12345678
            
package main
import "fmt"

func main() {
    if (false) {
        fmt.Println("Print if True")
    }
}

index.go


              12345678
            
package main
import "fmt"

func main() {
    if (!false) {
        fmt.Println("Print if True")
    }
}

index.go


              12345678
            
package main
import "fmt"

func main() {
    if (!(3 > 4)) {
        fmt.Println("Print if True")
    }
}

L'operatore OR (||) valuta due operandi e restituisce true se almeno uno degli operandi è true.

Nota

Un operando si riferisce a un valore o a un'espressione utilizzata come input per un operatore in un'istruzione o espressione. Ad esempio, nell'espressione 1 + 2, i valori 1 e 2 sono operandi. Nel caso degli operatori logici, un operando è sempre un'espressione o un valore booleano.

Ecco un esempio che illustra l'utilizzo di base degli operatori logici:

index.go


              1234567
            
package main
import "fmt"

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

Nota

Una tabella della verità è una rappresentazione logica che mostra tutte le possibili combinazioni di ingressi e i relativi valori di uscita.

Input	Output
`true \|\| true`	true
`true \|\| false`	true
`false \|\| true`	true
`false \|\| false`	false

È possibile concatenare operatori logici OR per combinare più operandi. In questo caso, l'espressione viene valutata da sinistra a destra:

index.go


              123456
            
package main
import "fmt"

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

L'ordine di valutazione per l'espressione sopra è il seguente:

Nota

Per impostazione predefinita, tutte le espressioni logiche vengono valutate da sinistra a destra.

Input	Output
`true && true`	true
`true && false`	false
`false && true`	false
`false && false`	false

Segue un esempio più complesso che dimostra un utilizzo pratico degli operatori logici. Prendere un momento per esaminare il codice e comprenderne il funzionamento:

index.go


              1234567891011
            
package main
import "fmt"

func main() {
    var x int = 99
    if (1 <= x && x <= 10 || 90 <= x && x <= 100) {
        fmt.Printf("The value %d is in the range 1-10 or 90-100", x)
    } else {
        fmt.Printf("The value %d is not in the range 1-10 or 90-100", x)
    }
}

Di seguito è riportato un diagramma che illustra la classifica di priorità degli operatori logici:

Il diagramma seguente illustra come viene valutata l'espressione 1 <= x && x <= 10 || 90 <= x && x <= 100:

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 4