Tous (ou presque tous ?) les langages de programmation
permettent de noter une donnée qui n'existe pas, le rien, le
néant. Mais chacun utilise un symbole
différent.
En SQL, c'est le
NULL. Ainsi, un booléen en
SQL est tri-valué : vrai, faux ou
NULL. Cela agace prodigieusement certains
théoriciens comme Date. Voici un
exemple avec une valeur égale à NULL :
CREATE TABLE Data (Name TEXT, Ready BOOLEAN);
CREATE TABLE
tests=> INSERT INTO DATA Values ('toto', false);
INSERT 0 1
tests=> INSERT INTO DATA Values ('tata', true);
INSERT 0 1
tests=> INSERT INTO DATA (Name) Values ('truc');
INSERT 0 1
tests=> SELECT * FROM Data;
name | ready
------+-------
toto | f
tata | t
truc |
(3 rows)
tests=> SELECT * FROM Data WHERE Ready IS NULL;
name | ready
------+-------
truc |
(1 row)
]]>
Et un exemple illustrant bien que NULL n'est ni
vrai ni faux. La troisième ligne, avec le nom truc, n'apparaitra pas :
SELECT * FROM Data WHERE Ready;
name | ready
------+-------
tata | t
(1 row)
tests=> SELECT * FROM Data WHERE NOT Ready;
name | ready
------+-------
toto | f
(1 row)
]]>
PHP utilise également NULL.
Python utilise
None. N'importe quelle variable peut prendre la
valeur None. Par contre, Python est typé, même
si c'est dynamiquement typé, et on ne peut pas effectuer n'importe
quelle opération sur None :
>> 2 + None
Traceback (most recent call last):
File "", line 1, in ?
TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'
]]>
Si on essaie avec des booléns, None a un
comportement qui peut être déroutant : il est quelque part entre
True et False.
>> x = True and False
>>> print x
False
>>> x = True and None
>>> print x
None
>>> x = False and None
>>> print x
False
>>> x = False or None
>>> print x
None
]]>
Perl utilise
undef. N'importe quelle variable peut prendre
cette valeur. Contrairement à Python, toutes les combinaisons sont
possibles avec undef :
% perl
print 2 + undef, "\n";
2
% perl
print 2 and undef, "\n";
2
Lisp utilise traditionnellement
nil, qui sert aussi à noter le booléen
Faux (merci à Emmanuel Saint-James pour son aide sur Lisp). #f qui sert à noter « faux » et uniquement
« faux » a été introduit par Scheme, qui a
supprimé la confusion qui existait dans Lisp sur ce sujet. La liste vide () convient aussi. Voici un exemple en Common Lisp :
; Renvoie Faux donc nil
> (or (= 2 3) (= 2 1))
NIL
> (or (= 2 3) (= 2 2))
T
; La liste vide est fausse
> ()
NIL
; On peut l'utiliser avec les opérateurs booléens
> (or (= 2 3) ())
NIL
> (or (= 2 2) ())
T
Pascal désigne les pointeurs invalides par
nil. Pascal est statiquement et assez fortement typé et les
variables des autres types n'ont pas de valeur
nil possible. Ada est très proche de Pascal sur ce point, mais utilise null au lieu de nil.
Ruby utilise également
nil.
Haskell est typé et ne permet pas de valeur
« nulle » sauf si on utilise la monade Maybe qui permet d'avoir une valeur
Nothing. Peu de fonctions sont définies sur les
variables Maybe (à part tester si elles
contiennent quelque chose et, si oui, quoi).
Visual Basic a le même terme,
Nothing.
C utilisait
traditionnellement 0, valable aussi bien pour les
entiers, les caractères et les pointeurs. Aujourd'hui, la bonne pratique
est plutôt d'utiliser la macroNULL.
À noter que les langues, pas seulement les langages de
programmation, peuvent avoir ce souci de noter l'inexistence. Le
lojban a zo'e
pour cela. Pour dire « je parle en lojban », où il faut normalement
spécifier le public et le sujet avant la langue
utilisée, une des méthodes est d'indiquer les arguments manquants par
zo'e donc, ici mi tavla zo'e zo'e la lojban.
Merci à Bertrand Petit pour sa suggestion originale.