Apprendre Opérateurs Logiques | Structures de Contrôle

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

Opérateur	Logique
`!`	NON
`\|\|`	OU
`&&`	ET

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

index.go


              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 l'on inclut un opérateur NOT dans l'expression, celle-ci sera inversée et deviendra donc équivalente à true :

index.go


              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, il est nécessaire d’entourer les expressions de parenthèses avant de les nier. Par exemple, si nous voulons nier 3 > 4, nous écririons !(3 > 4) :

index.go


              12345678
            
package main
import "fmt"

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

L’opérateur OU (||) évalue deux opérandes et retourne true si au moins l’un des opérandes est true.

Remarque

Un opérande désigne 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 illustrant l’utilisation de base des opérateurs logiques :

index.go


              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 seconde instruction affiche false car les deux opérandes sont false dans cette expression. Voici la table de vérité pour l'opération OU logique :

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.

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

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

index.go


              123456
            
package main
import "fmt"

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

L'ordre d'évaluation de 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 la valeur true. La table de vérité pour l'opération logique ET (&&) est présentée ci-dessous :

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

Voici un exemple plus complexe qui illustre une utilisation pratique des opérateurs logiques. Prenez un moment pour examiner le code et comprendre son fonctionnement :

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

Veuillez noter que dans l'exemple ci-dessus, plusieurs opérateurs et valeurs sont utilisés pour créer une condition plus complexe. Lors de l'exécution, l'expression est évaluée en fonction de la priorité des opérateurs. 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.

Vous trouverez ci-dessous un schéma illustrant le classement de priorité des opérateurs logiques :

Le schéma 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

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

Can you explain the difference between the AND and OR logical operators?

What does operator precedence mean in logical expressions?

Can you give more examples of using logical operators in code?

Awesome!

Completion rate improved to 1.96

Glissez pour afficher le menu

Opérateur	Logique
`!`	NON
`\|\|`	OU
`&&`	ET

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

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’opérateur OU (||) évalue deux opérandes et retourne true si au moins l’un des opérandes est true.

Remarque

Un opérande désigne 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 illustrant l’utilisation de base des opérateurs logiques :

index.go


              1234567
            
package main
import "fmt"

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

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.

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

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

index.go


              123456
            
package main
import "fmt"

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

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

Remarque

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

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

Voici un exemple plus complexe qui illustre une utilisation pratique des opérateurs logiques. Prenez un moment pour examiner le code et comprendre son fonctionnement :

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

Vous trouverez ci-dessous un schéma illustrant le classement de priorité des opérateurs logiques :

Le schéma 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