Comprendre la logique booléenne en Go

Le type de données booléen (bool) peut être l'une des deux valeurs, soittrue oufalse. Les booléens sont utilisés en programmation pour établir des comparaisons et contrôler le déroulement du programme.

Les booléens représentent les valeurs de vérité associées à la branche logique des mathématiques, qui informe les algorithmes en informatique. Nommé d'après le mathématicien George Boole, le mot booléen commence toujours par unB majuscule.

Le type de données dans Go pour Boolean estbool, tout en minuscules. Les valeurstrue etfalse seront toujours avec unt etf minuscule respectivement, car ce sont des valeurs spéciales dans Go.

Ce didacticiel couvrira les bases dont vous aurez besoin pour comprendre le fonctionnement du type de donnéesbool, y compris la comparaison booléenne, les opérateurs logiques et les tables de vérité.

Opérateurs de comparaison

En programmation,comparison operators est utilisé pour comparer les valeurs et évaluer jusqu'à une seule valeur booléenne vraie ou fausse.

Le tableau ci-dessous présente les opérateurs de comparaison booléens.

Opérateur	Ce que cela veut dire
==	Égal à
!=	Pas égal à
<	Moins que
>	Plus grand que
⇐	Inférieur ou égal à
>=	Plus grand ou égal à

Opérateur

Ce que cela veut dire

Égal à

Pas égal à

Moins que

Plus grand que

⇐

Inférieur ou égal à

Plus grand ou égal à

Pour comprendre le fonctionnement de ces opérateurs, assignons deux nombres entiers à deux variables dans un programme Go:

x := 5
y := 8

Dans cet exemple, puisquex a la valeur de5, il est inférieur ày qui a la valeur de8.

En utilisant ces deux variables et leurs valeurs associées, passons en revue les opérateurs du tableau précédent. Dans ce programme, vous demanderez à Go d’imprimer si chaque opérateur de comparaison a la valeur true ou false. Pour vous aider à mieux comprendre cette sortie, vous devrez également imprimer une chaîne pour vous montrer ce qu’elle évalue:

package main

import "fmt"

func main() {
    x := 5
    y := 8

    fmt.Println("x == y:", x == y)
    fmt.Println("x != y:", x != y)
    fmt.Println("x < y:", x < y)
    fmt.Println("x > y:", x > y)
    fmt.Println("x <= y:", x <= y)
    fmt.Println("x >= y:", x >= y)
}

Outputx == y: false
x != y: true
x < y: true
x > y: false
x <= y: true
x >= y: false

Suivant la logique mathématique, Go a évalué les expressions suivantes:

Est-ce que 5 (x) est égal à 8 (y)? false
5 n'est pas égal à 8? true
Est-ce que 5 est inférieur à 8? true
Est-ce que 5 est supérieur à 8? false
Est-ce que 5 est inférieur ou égal à 8? true
Est-ce que 5 n'est pas inférieur ou égal à 8? false

Bien que des entiers aient été utilisés ici, vous pouvez les remplacer par des valeurs flottantes.

Les chaînes peuvent également être utilisées avec des opérateurs booléens. Ils sont sensibles à la casse, sauf si vous utilisez une méthode de chaîne supplémentaire.

Vous pouvez regarder comment les chaînes sont comparées dans la pratique:

Sammy := "Sammy"
sammy := "sammy"

fmt.Println("Sammy == sammy: ", Sammy == sammy)

OutputSammy == sammy:  false

La chaîneSammy n'est pas égale à la chaînesammy, car elles ne sont pas exactement les mêmes; l'un commence par unS majuscule et l'autre par uns minuscule. Mais, si vous ajoutez une autre variable à laquelle la valeurSammy est attribuée, elle sera évaluée comme étant égale:

Sammy := "Sammy"
sammy := "sammy"
alsoSammy := "Sammy"

fmt.Println("Sammy == sammy: ", Sammy == sammy)
fmt.Println("Sammy == alsoSammy", Sammy == alsoSammy)

OutputSammy == sammy:  false
Sammy == alsoSammy true

Vous pouvez également utiliser les autres opérateurs de comparaison, y compris> et< pour comparer deux chaînes. Go comparera ces chaînes lexicographiquement en utilisant les valeurs ASCII des caractères.

Vous pouvez également évaluer les valeurs booléennes avec des opérateurs de comparaison:

t := true
f := false

fmt.Println("t != f: ", t != f)

Outputt != f:  true

Le bloc de code précédent a évalué quetrue n'est pas égal àfalse.

Notez la différence entre les deux opérateurs= et==.

x = y   // Sets x equal to y
x == y  // Evaluates whether x is equal to y

Le premier= est l'opérateur d'affectation, qui définira une valeur égale à une autre. Le second,==, est un opérateur de comparaison et évaluera si deux valeurs sont égales.

Opérateurs logiques

Deux opérateurs logiques sont utilisés pour comparer les valeurs. Ils évaluent les expressions jusqu'à des valeurs booléennes, renvoyant soittrue, soitfalse. Ces opérateurs sont&&,|| et!, et sont définis dans la liste ci-dessous:

&& (x && y) est l'opérateurand. C'est vrai si les deux affirmations sont vraies.
|| (x || y) est l'opérateuror. C'est vrai si au moins une affirmation est vraie.
! (!x) est l'opérateurnot. C'est vrai que si la déclaration est fausse.

Les opérateurs logiques sont généralement utilisés pour évaluer si deux expressions ou plus sont vraies ou non. Par exemple, ils peuvent être utilisés pour déterminer si la note est réussie et si l'étudiant est inscrit au cours. Si les deux cas sont vrais, alors une note sera attribuée à l'étudiant dans le système. Un autre exemple consisterait à déterminer si un utilisateur est un client actif valide d'une boutique en ligne en fonction de son crédit en magasin ou de son achat au cours des 6 derniers mois.

Pour comprendre le fonctionnement des opérateurs logiques, évaluons trois expressions:

fmt.Println((9 > 7) && (2 < 4))   // Both original expressions are true
fmt.Println((8 == 8) || (6 != 6)) // One original expression is true
fmt.Println(!(3 <= 1))            // The original expression is false

Outputtrue
true
true

Dans le premier cas,fmt.Println((9 > 7) && (2 < 4)),9 > 7 et2 < 4 devaient être évalués à vrai puisque l'opérateurand était utilisé.

Dans le second cas,fmt.Println((8 == 8) || (6 != 6)), puisque8 == 8 est évalué à vrai, cela n'a pas fait de différence que6 != 6 évalue à faux car l'opérateuror a été utilisé. Si vous aviez utilisé l'opérateurand, cela donnerait la valeur false.

Dans le troisième cas,fmt.Println(!(3 <= 1)), l'opérateurnot annule la valeur fausse que3 <=1 renvoie.

Remplaçons les nombres entiers par un flotteur et visons les fausses évaluations:

fmt.Println((-0.2 > 1.4) && (0.8 < 3.1))  // One original expression is false
fmt.Println((7.5 == 8.9) || (9.2 != 9.2)) // Both original expressions are false
fmt.Println(!(-5.7 <= 0.3))               // The original expression is true

Dans cet exemple:

and doit avoir au moins une expression fausse évaluée à fausse.
or doit avoir les deux expressions évaluées à false.
! doit avoir son expression interne à true pour que la nouvelle expression soit évaluée à false.

Si ces résultats ne vous semblent pas clairs, passez par quelquestruth tables pour plus de précisions.

Vous pouvez également écrire des instructions composées en utilisant&&,|| et!:

!((-0.2 > 1.4) && ((0.8 < 3.1) || (0.1 == 0.1)))

Jetez d'abord un œil à l'expression la plus interne:(0.8 < 3.1) || (0.1 == 0.1). Cette expression est évaluée àtrue car les deux instructions mathématiques sonttrue.

Ensuite, Go prend la valeur renvoyéetrue et la combine avec l'expression interne suivante:(-0.2 > 1.4) && (true). Cet exemple renvoiefalse car l'instruction mathématique-0.2 > 1.4 est fausse et (false) et (true) renvoiefalse.

Enfin, nous avons l'expression externe:!(false), qui évalue àtrue, donc la valeur finale retournée si nous imprimons cette instruction est:

Outputtrue

Les opérateurs logiques&&,|| et! évaluent les expressions et renvoient des valeurs booléennes.

Tables de vérité

Il y a beaucoup à apprendre sur la branche logique des mathématiques, mais vous pouvez en apprendre de manière sélective pour améliorer votre pensée algorithmique lors de la programmation.

Voici les tables de vérité pour l'opérateur de comparaison== et chacun des opérateurs logiques&&,|| et!. Bien que vous puissiez les raisonner, il peut également être utile de les mémoriser, car cela peut accélérer le processus de prise de décision en matière de programmation.

Table de vérité`==` (égal)

x	==	y	Retour
true	==	true	true
true	==	faux	faux
faux	==	true	faux
faux	==	faux	true

Retour

true

faux

true

faux

true

Table de vérité`&&` (et)

x	and	y	Retour
true	and	true	true
true	and	faux	faux
faux	and	true	faux
faux	and	faux	faux

and

Retour

true

and

true

and

faux

and

true

faux

and

faux

Table de vérité`||` (ou)

x	or	y	Retour
true	or	true	true
true	or	faux	true
faux	or	true	true
faux	or	faux	faux

Retour

true

faux

true

faux

true

faux

Table de vérité`!` (pas)

not	x	Retour
not	true	faux
not	faux	true

not

Retour

not

true

faux

not

faux

true

Les tables de vérité sont des tables mathématiques couramment utilisées en logique et qu'il est utile de garder à l'esprit lors de la construction d'algorithmes (instructions) en programmation informatique.

Utilisation d'opérateurs booléens pour le contrôle de flux

Pour contrôler le flux et les résultats d'un programme sous la forme d'instructions de contrôle de flux, vous pouvez utiliser uncondition suivi d'unclause.

Uncondition évalue jusqu'à une valeur booléenne de vrai ou faux, présentant un point où une décision est prise dans le programme. Autrement dit, une condition vous dirait si quelque chose est évalué comme étant vrai ou faux.

Leclause est le bloc de code qui suit lescondition et dicte le résultat du programme. Autrement dit, il s'agit de la partie «faire ceci» de la construction «Six esttrue, alors faites-le.»

Le bloc de code ci-dessous montre un exemple d'opérateurs de comparaison travaillant en tandem avec des instructions conditionnelles pour contrôler le flux d'un programme Go:

if grade >= 65 {                 // Condition
    fmt.Println("Passing grade") // Clause
} else {
    fmt.Println("Failing grade")
}

Ce programme évaluera si chaque élève a réussi ou échoué. Dans le cas d'un élève avec une note de83, la première instruction sera évaluée àtrue, et l'instruction d'impression dePassing grade sera déclenchée. Dans le cas d'un étudiant avec une note de59, la première instruction sera évaluée àfalse, donc le programme passera à exécuter l'instruction d'impression liée à l'expression else:Failing grade .

Les opérateurs booléens présentent des conditions qui peuvent être utilisées pour décider du résultat final d'un programme via des instructions de contrôle de flux.

Conclusion

Ce tutoriel est passé en revue et comparé des opérateurs logiques appartenant au type booléen, ainsi que des tables de vérité et utilisant des booléens pour le contrôle de flux de programme.

TOC

Comprendre la logique booléenne en Go

Opérateurs de comparaison

Opérateurs logiques

Tables de vérité

Table de vérité`==` (égal)

Table de vérité`&&` (et)

Table de vérité`||` (ou)

Table de vérité`!` (pas)

Utilisation d'opérateurs booléens pour le contrôle de flux

Conclusion

Related

TOC

Comprendre la logique booléenne en Go

Opérateurs de comparaison

Opérateurs logiques

Tables de vérité

Table de vérité== (égal)

Table de vérité&& (et)

Table de vérité|| (ou)

Table de vérité! (pas)

Utilisation d'opérateurs booléens pour le contrôle de flux

Conclusion

Related

Table de vérité`==` (égal)

Table de vérité`&&` (et)

Table de vérité`||` (ou)

Table de vérité`!` (pas)