Booléen

Un article de Wikipédia, l'encyclopédie libre.
Sauter à la navigation Sauter à la recherche

En informatique, un booléen est un type de variable à deux états (généralement notée vrai et faux), destiné à représenter les valeurs de vérité de la logique et l'algèbre Booléenne. Il est nommé ainsi d'après George Boole, fondateur de l'algèbre de Boole dans le milieu du XIXe siècle. Le type de données Booléen est principalement associé à états conditionnels. C'est un cas particulier du type de données logique, la logique ne devant pas toujours être de type Booléen.

Généralités[modifier | modifier le code]

Dans les langages de programmation avec un type de données Booléen, comme Pascal et 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 donne entier, où les expressions relationnel telles que i > j et les expressions logiques reliés 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'information.

La plupart des langages de programmation, y comprit 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 (ET, &, *), la disjonction (OU, |, +), l'équivalence (EQV, =, ==), ou exclusif/non-équivalence (XOR, NEQV, ^, !=), et la négation (PAS, ~, !).

Dans certaines langues, comme le Rubis, Smalltalk, et Alice les valeurs vrai et faux appartiennent à des classes séparés, 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 Nuls, 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 .

Algorithmie et le type booléen intégré[modifier | modifier le code]

L'un des premiers langages de programmation à intégrer explicitement le type booléen fut ALGOL 60 (1960) avec des valeurs vrai et faux et des opérateurs logiques indiqué par les symboles '' (et), '' (ou), '' (implique), '' (équivalence), et '' (non). En raison des limites des périphériques d'entrées 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ée intégré (prédéfinis) 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).

Fortran[modifier | modifier le code]

La première version de FORTRAN (1957) et son successeur, FORTRAN II (1958) n'avait 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. 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 fournie pour l'analyse syntaxique ou de la mise en forme de valeurs logiques[3].

Lisp et Scheme[modifier | modifier le code]

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ées 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 varient d'un langage à l'autre. Dans Scheme par exemple, la valeur fausse est un atome distinct de la liste vide, de sorte que ce dernier est interprété comme vrai.

Pascal, Ada, et Haskell[modifier | modifier le code]

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.

C, C++, Objective-C, AWK[modifier | modifier le code]

Les implémentations initiales du langage C (1972) n'ont fourni aucun type booléen, et à ce jour, les valeurs booléennes sont souvent représentées par des entiers (int) dans les programmes en C. 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) aient été ajoutés à l' American National Standards Institute version de C, C ANSI (1989), de nombreux programmeurs C est habitué à la définition de leurs propres les types booléen, pour des raisons de lisibilité. Cependant, les types énumérés sont équivalentes à 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.

Standard C (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 toutes les deux valeurs vraies se comparerai comme égales (ce qui était impossible à atteindre avant l'introduction du type). Les valeurs booléennes continuent de se comporter comme des entiers, peuvent être stockées dans des variables de type entier, et utilisé n'importe où un entier serait valide, y compris pour l'indexation, l'arithmétique, l'analyse et le formatage. Cette approche (valeurs booléennes sont juste des entiers) fut conservée dans toutes les versions ultérieures de C.

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 de C. Cette approche fut aussi adoptée plus tard par beaucoup d'autres langages, en particulier par certains langages de script tels que AWK.

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 et Lua[modifier | modifier le code]

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ée à vrai.

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

Tcl[modifier | modifier le code]

Tcl 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 a la valeur '1'

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

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

Python, Ruby et JavaScript[modifier | modifier le code]

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), le  chaîne de caractères videet 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 pouvent définir la manière dont les instances sont traités 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.

En Ruby, en revanche, 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.

SQL[modifier | modifier le code]

Le standard SQL:1999 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 langues. Toutefois, dans SQL le type BOOLÉEN prendre la valeur null par défaut comme tous les autres types de données SQL, ce qui veut dire qu'il peut aussi prendre la valeur null.

Bien que le standard SQL définisse trois littéraux pour le type BOOLEAN – TRUE, FALSE et UNKNOWN – il dit aussi que la valeur NULL BOOLEAN et UNKNOWN "peut être utilisé 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ègles 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 systèmes SQL implémente l'option T031[14]. PostgreSQL est une exception notable, bien qu'il implémente pas de littéral UNKNOWN; NULL peut être utilisé à la place[15].

Voir aussi[modifier | modifier le code]

Références[modifier | modifier le code]

  1. Brian W Kernighan et Dennis M Ritchie, The C Programming Language, Englewood Cliffs, NJ, Prentice Hall, (ISBN 0-13-110163-3), p. 41
  2. « Report on the Algorithmic Language ALGOL 68, Section 10.2.2. » [archive du ] [PDF], (consulté le 30 avril 2007)
  3. Digital Equipment Corporation, DECSystem10 FORTRAN IV Programmers Reference Manual. Reprinted in Mathematical Languages Handbook. Online version « https://web.archive.org/web/20110814003524/http://www.bitsavers.org/pdf/tymshare/tymcom-x/Tymcom-X_Reference_Series_Fortran_IV_Jan73.pdf »(ArchiveWikiwixArchive.isGoogleQue faire ?), accessed 2011-11-16.
  4. « Guides and Sample Code » [archive du ], sur developer.apple.com (consulté le 1er mai 2018)
  5. « perlsyn - Perl Syntax / Truth and Falsehood » [archive du ] (consulté le 10 septembre 2013)
  6. « PEP 285 -- Adding a bool type » [archive du ], (consulté le 28 mars 2018)
  7. Guido Van Rossum, « PEP 285 -- Adding a bool type » [archive du ], (consulté le 15 mai 2013)
  8. « Expressions » [archive du ], sur Python v3.3.2 documentation (consulté le 15 mai 2013)
  9. « ECMAScript Language Specification » [archive du ], p. 43
  10. « The Elements of JavaScript Style » [archive du ], Douglas Crockford (consulté le 5 mars 2011)
  11. C. Date, SQL and Relational Theory: How to Write Accurate SQL Code, O'Reilly Media, Inc., (ISBN 978-1-4493-1640-2, lire en ligne), p. 83
  12. ISO/IEC 9075-2:2011 §4.5
  13. Martyn Prigmore, Introduction to Databases With Web Applications, Pearson Education Canada, (ISBN 978-0-321-26359-9, lire en ligne), p. 197
  14. Troels Arvin, Survey of BOOLEAN data type implementation « https://web.archive.org/web/20050309010315/http://troels.arvin.dk/db/rdbms/ »(ArchiveWikiwixArchive.isGoogleQue faire ?),
  15. « PostgreSQL: Documentation: 10: 8.6. Boolean Type » [archive du ], sur www.postgresql.org (consulté le 1er mai 2018)