Booléen

Dans les langages de programmation avec un type de données booléen, comme le Pascal ou le Java, les opérateurs de comparaison tels que > et ≠ sont généralement définis pour retourner une valeur booléenne. Les structures conditionnelles et itératives peuvent être définies afin de tester des expressions booléennes.

Les langages sans type de données booléen, comme C90 et Lisp, peuvent quand même représenter la vérité des valeurs par un autre type de données. Common Lisp utilise une liste vide pour faux et toute autre valeur pour vrai. Le langage C quant à lui utilise le type de données entier, où les expressions relationnelles telles que i > j et les expressions logiques reliées par && et || sont définies de façon à avoir la valeur 1 si la valeur est vrai et 0 si elle est fausse, alors que les tests effectués par if, while, for, etc., considèrent toutes les valeurs non nulles comme vrai[1].

En effet, un booléen peut être considéré (et implémenté) en tant que variable numérique avec un bit, pouvant stocker deux valeurs. Cependant, l'implémentation des booléens dans l'architecture des processeurs est plus susceptible d'être représentée par des mots, plutôt que par un bit. Cela est dû à la manière dont les ordinateurs transfèrent des blocs d'informations.

La plupart des langages de programmation, y compris ceux n'ayant pas explicitement le type booléen, supportent les opérations booléennes et l'algèbre de Boole telles que la conjonction (AND, ET, &, *), la disjonction (OR, OU, |, +), l'équivalence (EQ, EQV, =, ==), ou exclusif/non-équivalence (XOR, NEQV, ^, !=), et la négation (NOT, PAS, ~, !)

Dans certains autres langages, comme le Ruby, le Smalltalk, ou le Alice les valeurs vrai et faux appartiennent à des classes séparées, c'est-à-dire, Vrai et Faux, respectivement, il n'y a donc pas de type booléen.

En SQL, qui utilise une logique ternaire pour les comparaisons explicites en raison de son traitement particulier pour les valeurs NULL, le booléen (introduit en SQL:1999) est également défini pour inclure plus de deux valeurs, de sorte que les booléens dans SQL peuvent stocker toutes les valeurs logiques résultant de l'évaluation des prédicats dans SQL. Une colonne de type booléen peut cependant être uniquement restreinte aux valeurs TRUE et FALSE .

L'un des premiers langages de programmation à intégrer explicitement le type booléen fut le ALGOL 60 (1960) avec des valeurs vrai et faux et des opérateurs logiques indiqués par les symboles '${\displaystyle \wedge }$' (et), '${\displaystyle \vee }$' (ou), '${\displaystyle \supset }$' (implique), '${\displaystyle \equiv }$' (équivalence), et '${\displaystyle \neg }$' (non). En raison des limites des périphériques d'entrée et du jeu de caractères de l'époque, la plupart des compilateurs utilisaient des représentations alternatives et pour la plupart, AND, ou "AND".

Cette approche booléenne comme type de données (prédéfini) a été adopté plus tard par beaucoup de langages de programmation, tels que (entre autres) Simula 67 (1967), ALGOL 68 (1970)[2], Pascal (1970), Ada (1980), Java (1995), et C# (2000).

La première version du FORTRAN (1957) et son successeur, FORTRAN II (1958) n'avaient pas de valeurs ou d'opérations logiques; même le conditionnel SI prenait une expression arithmétique et se ramifiait en trois situations en fonction de son signe. Le FORTRAN IV (1962), cependant, suivit l'exemple d'ALGOL 60 en fournissant un type de données booléen (LOGICAL) avec comme états (.TRUE. et .FALSE.), comme opérateurs de comparaison de valeurs booléennes (.EQ., .GT., etc.), et d'opérateurs logiques (.NOT., .AND., .OR.). Dans les déclarations FORMAT, un caractère de contrôle ('L') était fourni pour l'analyse syntaxique ou de la mise en forme de valeurs logiques[3].

Le langage Lisp (1958) n'a jamais eu un type booléen intégré. Au lieu de cela, les structures conditionnelles comme les cond supposent que la valeur logique faux est représentée par la liste vide (), définie de la même façon que l'atome nil ou NIL, alors que les autres s-expression sont interprétées comme vrai. Pour plus de commodité, la plupart des dialectes modernes de Lisp prédéfinissent l'atome t à la valeur t, de sorte que t peut être utilisé comme une notation mnémonique pour vrai (ou true en anglais).

Cette approche (toute valeur peut être utilisée comme une valeur booléenne) fut réutilisée dans la plupart des dialectes: Lisp (Common Lisp, Scheme, Emacs Lisp), et des modèles similaires ont été adoptés par de nombreux langages de script, même ceux ayant un type booléen distinct ou des valeurs booléennes; la manière dont les valeurs sont interprétées comme fausses ou vraies varie d'un langage à l'autre. Dans le Scheme par exemple, la valeur fausse est un atome distinct de la liste vide, de sorte que ce dernier est interprété comme vrai.

Le langage Pascal (1970) a introduit le concept de types énumérés défini du point de vue du développeur. Un booléen intégré a ensuite été introduit comme un type énuméré prédéfini avec les valeurs FALSE et TRUE. Par définition, toutes les comparaisons, les opérations logiques et les instructions conditionnelles donnent des valeurs booléennes. Sinon, le type booléen avait toutes les installations disponibles pour les types énumérés en général, telles que la commande et l'utilisation en tant qu'indice. En revanche, la conversion entre les booléens et les nombres entiers (ou tout autre type) demandait toujours des tests explicites ou des appels de fonction comme dans ALGOL 60. Cette approche (le booléen est un type énuméré) fut adoptée plus tard par la plupart des langages qui avait des types énumérés, tels que Modula, Ada, et Haskell.

Les implémentations initiales du langage C (1972) n'ont fourni aucun type booléen, et à ce jour, les valeurs booléennes dans les programmes en C sont souvent représentées par d'autres types de données, notamment les entiers (int). Les opérateurs de comparaison (>, ==, etc.) sont définis pour retourner un entier signé avec comme résultat, soit 0 (faux) ou 1 (vrai). Les opérateurs logiques (&&, ||, !, etc.) et les tests (if, while) supposent que le zéro est faux et que toutes les autres valeurs sont vraies.

Après que les types énumérés (enum) ont été ajoutés à l' American National Standards Institute version de C (1989), de nombreux programmeurs C se sont habitués à définir leurs propres types booléens pour des raisons de lisibilité. Cependant, les types énumérés sont équivalents à des entiers selon les normes linguistiques; de sorte que l'efficacité de l'identité entre les Booléens et les nombres entiers est encore valable pour les programmes en C.

Le C standard (depuis C99) fournit un type booléen, appelé _Bool. En incluant l'en-tête stdbool.h, on peut utiliser le nom plus intuitif de bool et les constantes true et false. Le langage garantit que deux variables booléennes de valeur « vraie » seront considérées comme égales (ce qui n'était pas possible avant l'arrivée du type). Les valeurs booléennes continuent de se comporter comme des entiers, elles peuvent être stockées dans des variables de type entier, et utiliser n'importe où un entier serait valide, y compris pour l'indexation, l'arithmétique, l'analyse ou le formatage. Cette approche (valeurs booléennes sont juste des entiers) fut conservée dans toutes les versions ultérieures du C.

Le C++ dispose d'un type de données booléen bool, mais avec des conversions automatiques de scalaires et de valeurs de pointeur qui sont très semblables à ceux du C. Cette approche fut aussi adoptée plus tard par beaucoup d'autres langages, en particulier par certains langages de script tels que AWK.

L'Objective-C a également un type de données booléen BOOL intégré, dont les valeurs possibles sont YES ou NO, respectivement équivalents à vrai et faux[4]. D'autre part, dans les compilateurs Objective-C qui prennent en charge C99, le type _Bool C peut être utilisé, puisque Objective-C est un sur-ensemble de C.

Perl n'a pas de type de données booléen. Au lieu de cela, toute valeur peut se comporter comme un booléen dans un contexte booléen (condition de if ou boucle while, l'argument de && ou ||, etc.). Le nombre 0, la chaîne de caractères "0" et "", la liste vide (), et la valeur spéciale undef sont interprétés comme la valeur faux[5]. Tout le reste est évalué à vrai.

Le Lua a un type de données booléen, mais les variables d'un type différent peuvent aussi se comporter comme des booléens. La valeur non nil est interprétée comme faux, alors que tous les autres type de données renvoient toujours vrai, quelle que soit leur valeur.

Le Tcl n'a pas de type booléen. Comme en C, les nombres entiers 0 (faux) et 1 (vrai - en fait n'importe quel entier non nul) sont utilisés[6].

Exemples de codage :

set v 1 if { $v } { puts "V is 1 or true" }

L'exemple ci-dessus va afficher « V est 1 ou true » car l'expression renvoie la valeur 1.

set v "" if { $v } ....

L'exemple ci-dessus renverra une erreur, puisque la variable v ne peut pas être évaluée en tant que 0 ou 1.

Python, à partir de la version 2.3, a un type bool qui est une sous-classe de type int, le standard de type entier[7]. Il y a deux valeurs possibles: True et False, qui sont des versions spéciales de 1 et 0, respectivement, et se comportent comme tel dans le contexte arithmétique. Aussi, une valeur numérique de zéro (entier ou fractionnaire), la valeur nulle (None), la chaîne de caractères vide et les contenants vides (c'est-à-dire les listes, ensembles, etc.) sont considérés comme une valeur booléenne fausse; toutes les autres valeurs sont considérées comme vrai par défaut[8]. Les classes peuvent définir la manière dont les instances sont traitées dans un contexte booléen par le biais de la méthode spéciale __nonzero__ (Python 2) ou __bool__ (Python 3). Pour les conteneurs, __len__ (la méthode spéciale pour la détermination de la longueur de conteneurs) est utilisée si la méthode explicite de conversion booléenne n'est pas définie.

Néanmoins, en Ruby, seulement nil (la valeur nulle de Ruby) et un objet spécial false sont évalués comme faux, tout le reste (y compris l'entier 0 et des tableaux vides) sont vrai.

En JavaScript, la chaîne vide (""), null, undefined, NaN, +0, -0 et false[9] sont parfois appelées falsy, et leur complément, truthy, pour distinguer les booléens de type vérifiés stricts et contraint[10]. Des langages tels que PHP utilisent également cette approche.

Le SQL:1999 standard a introduit un type de données BOOLÉEN en option (T031). Si on le restreint à une contrainte NOT NULL, un BOOLÉEN SQL se comporte comme les booléens dans d'autres langages. Toutefois, en SQL le type BOOLÉEN peut prendre la valeur null par défaut comme tous les autres types de données SQL.

Bien que le SQL standard définisse trois valeurs constantes pour le type BOOLEAN – TRUE, FALSE et UNKNOWN – il dit aussi que les valeurs NULL BOOLEAN et UNKNOWN « peuvent être utilisées de façon interchangeable pour désigner exactement la même chose »[11]^,[12]. Cela a causé une certaine controverse, car cela soumet UNKNOWN à la règle de comparaison d'égalité de la valeur NULL. Plus précisément UNKNOWN = UNKNOWN n'est pas évalué comme TRUE, mais comme UNKNOWN/NULL[13] en 2012, quelques grands SGBD utilisant le SQL implémentent l'option T031[14]. Le PostgreSQL est une exception notable, bien qu'il implémente pas de constante UNKNOWN; NULL peut être utilisée à la place[15].

• Le vrai et le faux (commandes), pour la création de scripts shell
• L'expansion de Shannon
• stdbool.h, C99 définitions pour les booléens

• Portail de l’informatique