Opérateurs Logiques

Une autre catégorie d'opérateurs est connue sous le nom d'opérateurs logiques. Contrairement aux autres opérateurs qui fonctionnent avec des valeurs numériques, les opérateurs logiques sont conçus pour gérer des valeurs booléennes. Il existe trois opérateurs logiques :

Opérateur	Logique
`!`	NOT
`\|\|`	OR
`&&`	AND

L'opérateur NOT (!) est utilisé pour nier (inverser) une expression booléenne. Voici un exemple simple qui inclut une instruction if :

index


              12345678
            
package main
import "fmt"

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

Dans le code ci-dessus, l'instruction Print ne sera pas exécutée car la condition est false par défaut. Cependant, si nous incluons un opérateur NOT dans l'expression, elle sera négative et, par conséquent, équivalente à true:

index


              12345678
            
package main
import "fmt"

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

Nous pouvons également utiliser l'opérateur NOT (!) dans des cas plus complexes. Cependant, nous devons entourer les expressions de parenthèses avant de les nier. Par exemple, si nous voulons nier 3 > 4, nous écririons !(3 > 4):

index


              12345678
            
package main
import "fmt"

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

L'opérateur OR (||) évalue deux opérandes et renvoie true si au moins un des opérandes est true.

Remarque

Un opérande fait référence à une valeur ou une expression utilisée comme entrée pour un opérateur dans une instruction ou une expression. Par exemple, dans l'expression 1 + 2, les valeurs 1 et 2 sont des opérandes. Dans le cas des opérateurs logiques, un opérande est toujours une expression ou une valeur booléenne.

Voici un exemple qui illustre l'utilisation de base des opérateurs logiques:

index


              1234567
            
package main
import "fmt"

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

La première instruction affiche true car l'un des opérandes dans l'expression true || false est true. En revanche, la deuxième instruction affiche false car les deux opérandes sont false dans cette expression. Ci-dessous se trouve la table de vérité pour l'opération logique OU :

Remarque

Une table de vérité est une représentation logique qui affiche toutes les combinaisons possibles d'entrées et leurs valeurs de sortie correspondantes.

Entrée	Sortie
`true \|\| true`	true
`true \|\| false`	true
`false \|\| true`	true
`false \|\| false`	false

Nous pouvons enchaîner les opérateurs logiques OU pour combiner plusieurs opérandes. Dans ce cas, l'expression est évaluée de gauche à droite:

index


              123456
            
package main
import "fmt"

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

L'ordre d'évaluation pour l'expression ci-dessus est le suivant :

Remarque

Par défaut, toutes les expressions logiques sont évaluées de gauche à droite.

L'opérateur logique ET (&&) est similaire à l'opérateur OU (||), mais il retourne true uniquement si les deux opérandes ont une valeur de true. La table de vérité pour l'opération logique ET (&&) est fournie ci-dessous :

Entrée	Sortie
`true && true`	true
`true && false`	false
`false && true`	false
`false && false`	false

Voici un exemple plus complexe qui démontre une utilisation pratique des opérateurs logiques. Prenez un moment pour examiner le code et comprendre comment il fonctionne :

index


              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)
    }
}

Veuillez noter que dans l'exemple ci-dessus, nous utilisons plusieurs opérateurs et valeurs pour créer une condition plus complexe. Lors de l'exécution, l'expression est évaluée en fonction de la priorité de l'opérateur. Les opérateurs de haute priorité sont évalués en premier, et il est important de comprendre l'ordre dans lequel ils sont traités. Les opérateurs de comparaison ont une priorité plus élevée que les opérateurs logiques.

Ci-dessous se trouve un diagramme illustrant le classement de priorité des opérateurs logiques :

Le diagramme suivant illustre comment l'expression 1 <= x && x <= 10 || 90 <= x && x <= 100 est évaluée :

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 4