Langage de programmation - Mathématiques appliquées - Variables et constantes booléennes

Variables et constantes booléennes

Les variables et les constantes booléennes constituent les éléments les plus fondamentaux de l'algèbre de Boole. Elles permettent de représenter une information ne possédant que deux états possibles, généralement désignés par les valeurs vrai et faux.

Dans une notation mathématique ou électronique, ces deux états sont souvent représentés par :

et :

Dans les langages de programmation, ils sont généralement écrits :

TRUE
FALSE

ou :

true
false

Une variable booléenne peut changer de valeur au cours de l'exécution d'un programme. Elle peut, par exemple, indiquer si un utilisateur est connecté, si un fichier existe, si une opération a réussi ou si une condition particulière est satisfaite. Une constante booléenne représente au contraire une valeur fixe qui ne change pas.

Les variables booléennes sont utilisées dans les expressions logiques, les instructions conditionnelles, les boucles, les validations, les filtres, les contrôles d'accès, les circuits numériques et les algorithmes de décision. Elles permettent à un programme de choisir entre différentes actions selon l'état du système ou des données.

Définition d'une valeur booléenne

Une valeur booléenne est une valeur appartenant à un domaine contenant exactement deux éléments.

Ce domaine est généralement noté :

B = {0,1}

ou :

B = {FAUX,VRAI}

Les deux représentations sont équivalentes dans l'algèbre de Boole classique :

0 = FAUX

1 = VRAI

Domaine booléen

Le domaine booléen est un ensemble fini comportant deux valeurs opposées.

B = {0,1}

Une variable booléenne :

satisfait donc :

x ∈ B

Cela signifie obligatoirement que :

x = 0

ou :

x = 1

Dans le modèle booléen classique, aucune troisième valeur n'est admise.

Interprétation logique

Dans une interprétation logique :

représente une proposition fausse, tandis que :

représente une proposition vraie.

Valeur booléenne	Valeur logique	Interprétation
0	FAUX	La proposition n'est pas satisfaite
1	VRAI	La proposition est satisfaite

Interprétation numérique

Les valeurs :

et :

peuvent être utilisées comme représentations numériques des états logiques.

Toutefois, les opérations booléennes ne suivent pas nécessairement les mêmes règles que les opérations arithmétiques.

Par exemple, si le symbole `+` désigne le OU logique :

1 + 1 = 1

alors qu'en arithmétique ordinaire :

1 + 1 = 2

Interprétation électronique

Dans un circuit numérique, les deux valeurs booléennes peuvent représenter deux niveaux électriques.

Valeur	État électronique possible
0	Tension basse
1	Tension haute

La tension exacte dépend de la technologie électronique utilisée.

Les valeurs booléennes ne désignent donc pas nécessairement une tension particulière, mais plutôt deux intervalles de tension interprétés comme des états logiques distincts.

Autres interprétations

Les valeurs booléennes peuvent représenter de nombreuses oppositions.

Valeur fausse	Valeur vraie
Désactivé	Activé
Absent	Présent
Fermé	Ouvert
Arrêté	En fonctionnement
Incorrect	Correct
Refusé	Autorisé
Échec	Réussite
Invisible	Visible
Non sélectionné	Sélectionné
Non initialisé	Initialisé
Aucun signal	Signal présent
Condition non satisfaite	Condition satisfaite

La signification dépend toujours du contexte dans lequel la valeur est utilisée.

Variable booléenne

Une variable booléenne est un symbole ou un emplacement mémoire pouvant contenir l'une des deux valeurs du domaine booléen.

Par exemple :

A ∈ {0,1}

La variable :

peut donc contenir :

ou :

Dans un programme, sa valeur peut être modifiée pendant l'exécution.

Exemple simple

Considérons une variable :

CompteActif

Elle peut valoir :

VRAI

lorsque le compte peut être utilisé, ou :

FAUX

lorsque le compte est désactivé.

CompteActif ← VRAI

Plus tard, le programme peut modifier son état :

CompteActif ← FAUX

Constante booléenne

Une constante booléenne est une valeur fixe appartenant au domaine booléen.

Les deux constantes fondamentales sont :

FAUX

et :

VRAI

Dans une expression mathématique, elles peuvent également être écrites :

et :

Contrairement à une variable, une constante ne reçoit pas une nouvelle valeur pendant l'évaluation de l'expression.

Différence entre variable et constante

Élément	Peut changer	Exemples
Variable booléenne	Oui	CompteActif, FichierExiste
Constante booléenne	Non	VRAI, FAUX, 1, 0

Dans l'expression :

CompteActif ET VRAI

`CompteActif` est une variable, tandis que `VRAI` est une constante.

Affectation d'une valeur

L'affectation consiste à placer une valeur dans une variable.

En pseudocode :

EstConnecté ← VRAI

Cette instruction signifie que la variable :

EstConnecté

reçoit la valeur :

VRAI

Une affectation ne doit pas être confondue avec une comparaison.

Affectation et comparaison

Dans plusieurs langages, les symboles employés pour l'affectation et l'égalité sont différents.

Par exemple :

x ← VRAI

représente une affectation.

x = VRAI

peut représenter une comparaison logique.

Dans certains langages de programmation :

est utilisé pour l'affectation, tandis que :

est utilisé pour la comparaison.

Initialisation

L'initialisation consiste à attribuer une première valeur à une variable lors de sa création.

Par exemple :

ErreurDétectée ← FAUX

Cette initialisation indique qu'aucune erreur n'a encore été rencontrée.

Une variable booléenne correctement initialisée possède un état connu dès le début de son utilisation.

Variable non initialisée

Une variable non initialisée peut contenir une valeur indéterminée dans certains langages ou environnements.

Cela peut provoquer :

un comportement imprévisible ;
une condition incorrecte ;
une erreur d'exécution ;
une décision incohérente ;
une vulnérabilité de sécurité.

Il est donc recommandé d'initialiser explicitement les variables booléennes lorsque le langage ne le fait pas automatiquement.

Exemple d'initialisation

MODULE Rechercher(Tableau, Valeur)

   Trouvé ← FAUX

   POUR CHAQUE Élément DANS Tableau

      SI Élément = Valeur ALORS
         Trouvé ← VRAI
      FIN SI

   FIN POUR

   RETOURNER Trouvé

La variable :

Trouvé

est initialisée à faux avant le début de la recherche.

Modification d'une variable booléenne

Une variable booléenne peut changer d'état à la suite d'un événement ou d'un calcul.

PorteOuverte ← FAUX

Après l'ouverture de la porte :

PorteOuverte ← VRAI

Sa valeur représente alors l'état actuel du système.

Basculement d'une valeur

Le basculement consiste à remplacer une valeur booléenne par son contraire.

État ← NON État

Si :

État = FAUX

alors l'instruction produit :

État = VRAI

Si :

État = VRAI

elle produit :

État = FAUX

Algorithme de basculement

MODULE Basculer(État)

État ← NON État

RETOURNER État

Ce principe est utilisé pour les interrupteurs logiciels, les cases à cocher et les options activables.

Nom des variables booléennes

Le nom d'une variable booléenne devrait indiquer clairement une condition ou un état.

Des préfixes ou formulations fréquentes sont :

Est...
A...
Peut...
Doit...
Possède...
Existe...
Contient...
Autorise...

Exemples de noms explicites

EstConnecté
EstVisible
EstValide
EstTerminé
AUneErreur
PeutModifier
DoitEnregistrer
PossèdePermission
FichierExiste
ContientRésultat

Ces noms peuvent généralement être lus directement comme des questions auxquelles la réponse est vraie ou fausse.

Noms moins explicites

Des noms comme :

État
Indicateur
Valeur
Donnée
Option

sont souvent trop vagues.

Un nom comme :

EstApplicationActive

est plus précis que :

ÉtatApplication

car il indique clairement ce que signifie la valeur vraie.

Convention positive

Il est généralement préférable d'utiliser une formulation positive.

Par exemple :

EstValide

est souvent plus facile à comprendre que :

NestPasInvalide

Les doubles négations rendent les conditions difficiles à lire.

Exemple de double négation

La condition :

NON EstDésactivé

peut souvent être remplacée par :

EstActivé

De même :

NON FichierAbsent

peut être exprimé plus clairement par :

FichierPrésent

Littéral booléen

Un littéral booléen est une valeur booléenne écrite directement dans le code source.

Exemples :

true
false

ou :

True
False

selon le langage.

Un littéral n'est pas entouré de guillemets.

Booléen et chaîne de caractères

La valeur booléenne :

true

ne doit pas être confondue avec la chaîne :

"true"

La première est une valeur logique.

La seconde est une suite de caractères contenant les lettres :

t
r
u
e

Comparaison

Écriture	Type probable
true	Booléen
"true"	Chaîne de caractères
1	Entier
"1"	Chaîne de caractères

Ces valeurs peuvent avoir des représentations similaires, mais elles appartiennent à des types différents.

Constante symbolique

Un programme peut définir une constante symbolique de type booléen.

Par exemple :

CONST MODE_DIAGNOSTIC = VRAI

Une constante symbolique permet d'associer un nom significatif à une valeur fixe.

Elle améliore la lisibilité et évite la répétition de valeurs littérales.

Exemple de constante de configuration

CONST JOURNALISATION_ACTIVE = VRAI

SI JOURNALISATION_ACTIVE ALORS
ÉcrireJournal
FIN SI

Si la constante ne doit jamais changer pendant l'exécution, son utilisation exprime clairement cette intention.

Constante à la compilation

Certaines constantes sont évaluées lors de la compilation.

Elles peuvent servir à :

activer des fonctionnalités ;
sélectionner une plateforme ;
inclure du code de diagnostic ;
choisir un comportement ;
désactiver des composants expérimentaux.

Le compilateur peut parfois éliminer les branches qui ne seront jamais exécutées.

Drapeau booléen

Une variable booléenne utilisée pour mémoriser un état est souvent appelée drapeau, ou flag.

Par exemple :

ErreurDétectée

peut être initialisée à :

FAUX

puis placée à :

VRAI

lorsqu'une erreur survient.

Exemple de drapeau

ErreurDétectée ← FAUX

POUR CHAQUE Valeur DANS Tableau

   SI Valeur < 0 ALORS
      ErreurDétectée ← VRAI
   FIN SI

FIN POUR

À la fin de la boucle, la variable indique si au moins une valeur négative a été rencontrée.

Drapeau de terminaison

Une variable booléenne peut contrôler la terminaison d'une boucle.

Terminé ← FAUX

TANT QUE NON Terminé

   LireCommande

   SI Commande = "QUITTER" ALORS
      Terminé ← VRAI
   FIN SI

FIN TANT QUE

La boucle continue tant que le drapeau reste faux.

Drapeau de succès

Une fonction peut employer une variable booléenne pour mémoriser la réussite d'une opération.

Succès ← FAUX

SI ConnexionDisponible ALORS

EffectuerOpération
Succès ← VRAI

FIN SI

La variable finale peut ensuite être retournée à l'appelant.

Variable booléenne calculée

Une variable booléenne peut recevoir le résultat d'une comparaison.

EstMajeur ← Âge >= 18

L'expression :

Âge >= 18

produit directement une valeur booléenne.

Il n'est donc pas nécessaire d'utiliser une structure conditionnelle complète.

Forme inutilement longue

SI Âge >= 18 ALORS
EstMajeur ← VRAI
SINON
EstMajeur ← FAUX
FIN SI

Cette écriture fonctionne, mais elle peut être simplifiée en :

EstMajeur ← Âge >= 18

Comparaisons produisant un booléen

Les opérateurs de comparaison retournent généralement une valeur booléenne.

A = B
A ≠ B
A < B
A ≤ B
A > B
A ≥ B

Par exemple :

TempératureÉlevée ← Température > 30

Fonction booléenne

Une fonction booléenne retourne une valeur vraie ou fausse.

MODULE EstPair(Nombre)

RETOURNER
Nombre MOD 2 = 0

Cette fonction peut être utilisée directement dans une condition :

SI EstPair(10) ALORS
AFFICHER "Nombre pair"
FIN SI

Prédicat booléen

Une fonction retournant une valeur booléenne est souvent appelée un prédicat.

Exemples :

EstVide(Chaîne)
EstValide(Date)
Contient(Tableau, Valeur)
Existe(Fichier)
PeutAccéder(Utilisateur)

Un prédicat exprime une propriété de ses paramètres.

Paramètre booléen

Une fonction peut recevoir une valeur booléenne comme paramètre.

MODULE AfficherMessage(Message, AvecDate)

   SI AvecDate ALORS
      AFFICHER DateCourante
   FIN SI

   AFFICHER Message

Le paramètre :

AvecDate

contrôle une option de fonctionnement.

Limite des paramètres booléens

Un appel comportant plusieurs littéraux booléens peut être difficile à comprendre.

CréerRapport(VRAI, FAUX, VRAI)

Il est difficile de connaître la signification de chaque valeur sans consulter la déclaration de la fonction.

Des paramètres nommés, des constantes symboliques ou une structure d'options peuvent améliorer la lisibilité.

Constantes nommées comme paramètres

Au lieu de :

CréerRapport(VRAI, FAUX)

on peut employer :

CréerRapport(
INCLURE_TITRE,
SANS_GRAPHIQUE
)

Cette formulation indique plus clairement l'intention du programme.

Retour booléen

Une fonction peut retourner un booléen pour indiquer :

le succès d'une opération ;
l'existence d'un élément ;
la validité d'une donnée ;
la satisfaction d'une condition ;
la disponibilité d'une ressource.

Par exemple :

SI EnregistrerFichier() ALORS
AFFICHER "Enregistrement réussi"
SINON
AFFICHER "Échec de l'enregistrement"
FIN SI

Succès et information d'erreur

Un simple booléen indique seulement si une opération a réussi ou échoué.

Il ne précise pas nécessairement la cause de l'échec.

Pour les opérations complexes, il peut être préférable de retourner :

un code d'erreur ;
une exception ;
un objet résultat ;
une valeur optionnelle ;
une énumération décrivant plusieurs états.

Booléen nullable

Certains langages permettent à une variable booléenne de contenir une valeur supplémentaire représentant l'absence de valeur.

Les états deviennent alors :

VRAI
FAUX
NUL

Cette variable n'appartient plus strictement au domaine booléen classique à deux valeurs.

Exemple conceptuel

RéponseConfirmée = VRAI

signifie que la réponse est affirmative.

RéponseConfirmée = FAUX

signifie que la réponse est négative.

RéponseConfirmée = NUL

peut signifier qu'aucune réponse n'a encore été fournie.

État inconnu

Une valeur absente ne doit pas automatiquement être interprétée comme fausse.

Par exemple, si l'on ne connaît pas l'état d'un appareil :

AppareilFonctionnel = INCONNU

n'équivaut pas nécessairement à :

AppareilFonctionnel = FAUX

L'appareil pourrait fonctionner sans que l'information ait encore été obtenue.

Logique binaire et logique ternaire

Logique	Valeurs possibles
Booléenne classique	VRAI, FAUX
Logique ternaire	VRAI, FAUX, INCONNU
Booléen nullable	VRAI, FAUX, NUL

La logique ternaire nécessite des règles supplémentaires pour les opérations ET, OU et NON.

Valeur NULL dans SQL

Dans SQL, une comparaison avec :

NULL

produit généralement la valeur :

UNKNOWN

et non directement :

FALSE

Par exemple :



Age = NULL

n'est généralement pas la bonne façon de vérifier une absence de valeur.

On utilise plutôt :



Age IS NULL

Représentation en mémoire

Une valeur booléenne représente seulement deux états, ce qui pourrait théoriquement être stocké dans un seul bit.

Cependant, un langage ou un processeur peut réserver :

un octet ;
deux octets ;
quatre octets ;
une unité d'adressage propre à la plateforme.

La taille réelle dépend donc de l'implémentation.

Pourquoi utiliser plus d'un bit ?

Les processeurs accèdent généralement plus facilement à des octets ou à des mots complets qu'à un bit isolé.

L'utilisation d'une unité plus grande peut :

simplifier l'adressage ;
accélérer certains accès ;
respecter l'alignement mémoire ;
faciliter les opérations du processeur.

L'espace non utilisé peut être accepté en échange d'un accès plus efficace.

Regroupement de booléens

Lorsqu'un programme doit stocker un grand nombre d'états binaires, il peut les regrouper dans un tableau de bits.

Par exemple, un entier de 8 bits peut représenter huit indicateurs distincts.

Bit 0 : Visible
Bit 1 : Modifiable
Bit 2 : Sélectionné
Bit 3 : Verrouillé
...

Chaque état est lu ou modifié à l'aide d'un masque de bits.

Booléen et bit

Un bit est une unité physique ou numérique pouvant contenir `0` ou `1`.

Un booléen est une valeur logique représentant `FAUX` ou `VRAI`.

Les deux concepts sont étroitement liés, mais ils ne sont pas toujours identiques :

un booléen peut occuper plusieurs bits en mémoire ;
un bit peut appartenir à une représentation numérique sans représenter une condition indépendante.

Opération de négation

La négation transforme une valeur booléenne en son complément.

NON FAUX = VRAI

NON VRAI = FAUX

Pour une variable :

on peut écrire :

A ← NON A

afin d'inverser son état.

Double négation

Appliquer deux négations successives restitue la valeur initiale.

NON NON A = A

Par exemple :

NON NON VRAI = VRAI

et :

NON NON FAUX = FAUX

Cette propriété est appelée loi d'involution.

Variable et complément

Pour toute variable booléenne :

son complément est noté :

NON A

¬A

ou :

Ā

Les deux valeurs sont toujours opposées.

A	NON A
0	1
1	0

Propriété de complémentarité

Une variable et son complément ne peuvent pas être vrais simultanément.

A ET NON A = FAUX

Ils ne peuvent pas non plus être faux simultanément dans la logique classique :

A OU NON A = VRAI

Constante vraie

La constante :

VRAI

représente l'élément neutre de l'opération ET.

A ET VRAI = A

Elle représente également l'élément absorbant de l'opération OU.

A OU VRAI = VRAI

Constante fausse

La constante :

FAUX

représente l'élément neutre de l'opération OU.

A OU FAUX = A

Elle représente l'élément absorbant de l'opération ET.

A ET FAUX = FAUX

Tableau des interactions avec les constantes

Expression	Résultat
A ET VRAI	A
A ET FAUX	FAUX
A OU VRAI	VRAI
A OU FAUX	A
NON VRAI	FAUX
NON FAUX	VRAI

Ces identités sont fondamentales pour la simplification des expressions.

Variable toujours vraie

Une variable ne devrait normalement pas être utilisée lorsqu'elle possède toujours une valeur fixe.

Par exemple :

ModeActif ← VRAI

si cette valeur ne peut jamais changer, il peut être plus approprié d'utiliser une constante.

Cela indique au lecteur et au compilateur que la valeur est immuable.

Variable temporaire

Une variable booléenne temporaire peut améliorer la lisibilité d'une expression complexe.

Au lieu de :

SI
   Âge ≥= 18
   ET CompteActif
   ET NON CompteSuspendu
ALORS
   ...
FIN SI

on peut écrire :

EstMajeur ← Âge >= 18

PeutAccéder ←
   EstMajeur
   ET CompteActif
   ET NON CompteSuspendu

Puis :

SI PeutAccéder ALORS
...
FIN SI

Risque de variable redondante

Une variable temporaire peut toutefois devenir redondante si elle ne fait que répéter une expression très simple.

Par exemple :

EstSupérieur ← A > B

SI EstSupérieur ALORS

peut être remplacé par :

SI A > B ALORS

Le choix dépend de la lisibilité et de la réutilisation de la valeur.

Portée d'une variable booléenne

La portée détermine les parties du programme pouvant accéder à une variable.

Une variable peut être :

locale à une fonction ;
locale à un bloc ;
membre d'un objet ;
globale au programme ;
partagée entre plusieurs composants.

Une portée limitée réduit les risques de modification accidentelle.

Variable locale

MODULE VérifierMotDePasse(MotDePasse)

   EstAssezLong ←
      LONGUEUR(MotDePasse) >= 12

   RETOURNER EstAssezLong

La variable :

EstAssezLong

n'existe que pendant l'exécution de la fonction.

Variable d'état

Une variable booléenne peut être conservée plus longtemps afin de représenter l'état d'un objet.

Par exemple :

Fenêtre.EstVisible

Connexion.EstOuverte

Document.EstModifié

Ces variables sont souvent appelées propriétés booléennes.

Immutabilité

Une variable déclarée immuable reçoit une valeur une seule fois.

Par exemple :

EstProduction ←
Environnement = "Production"

Si la variable est immuable, sa valeur ne pourra pas être modifiée accidentellement après son calcul.

Cette pratique facilite le raisonnement sur le programme.

Constante globale

Une constante globale est accessible depuis plusieurs parties d'un programme.

CONST VERSION_EXPERIMENTALE = FAUX

Son utilisation doit rester raisonnable, car un trop grand nombre de constantes globales peut compliquer l'organisation du code.

Exemple en Pascal



Program VariablesBooleennes;

 
const

  JournalisationActive: Boolean = True;

 
var

  CompteActif: Boolean;

  EstMajeur: Boolean;

  AccesAutorise: Boolean;

  Age: Integer;

 
BEGIN

  Age := 25;

  CompteActif := True;

 
  EstMajeur := Age >= 18;

 
  AccesAutorise :=

    EstMajeur and CompteActif;

 
  if JournalisationActive then

    WriteLn(

      'État de l''accès calculé.'

    );

 
  if AccesAutorise then

    WriteLn('Accès autorisé')

  else

    WriteLn('Accès refusé');

END.

Analyse de l'exemple Pascal

La constante :

JournalisationActive

est fixée à vrai.

Les variables :

CompteActif
EstMajeur
AccesAutorise

peuvent recevoir des valeurs au cours de l'exécution.

La variable :

EstMajeur

reçoit directement le résultat de la comparaison :

Age >= 18

Exemple en Java


public final class VariablesBooleennes {
 
    private static final boolean
        JOURNALISATION_ACTIVE = true;
 
    private VariablesBooleennes() {
    }
 
    public static void main(String[] args) {
        int age = 25;
        boolean compteActif = true;
 
        boolean estMajeur =
            age >= 18;
 
        boolean accesAutorise =
            estMajeur && compteActif;
 
        if (JOURNALISATION_ACTIVE) {
            System.out.println(
                "État de l'accès calculé."
            );
        }
 
        if (accesAutorise) {
            System.out.println(
                "Accès autorisé"
            );
        } else {
            System.out.println(
                "Accès refusé"
            );
        }
    }
}

Constante en Java

En Java, une constante est généralement déclarée à l'aide de :


static final

Par convention, son nom est écrit en majuscules :


JOURNALISATION_ACTIVE

Le mot-clef :


final

empêche une nouvelle affectation après l'initialisation.

Exemple en C



#include <stdbool.h>

#include <stdio.h>

 
int main(void)

{

    const bool journalisation_active = true;

 
    int age = 25;

    bool compte_actif = true;

 
    bool est_majeur = age >= 18;

 
    bool acces_autorise =

        est_majeur && compte_actif;

 
    if (journalisation_active)

    {

        printf(

            "Etat de l'acces calcule.&#92;n"

        );

    }

 
    if (acces_autorise)

    {

        printf("Acces autorise&#92;n");

    }

    else

    {

        printf("Acces refuse&#92;n");

    }

 
    return 0;

}

Type bool en C

L'en-tête :



#include <stdbool.h>

fournit notamment :



bool

true

false

Le type repose sur le type interne :



_Bool

Une valeur nulle représente faux, tandis qu'une valeur convertie en `_Bool` devient généralement `0` ou `1`.

Exemple en C++



#include <iostream>

 
int main()

{

    constexpr bool journalisationActive =

        true;

 
    int age = 25;

    bool compteActif = true;

 
    bool estMajeur =

        age >= 18;

 
    bool accesAutorise =

        estMajeur && compteActif;

 
    if (journalisationActive)

    {

        std::cout

            << "État de l'accès calculé.&#92;n";

    }

 
    std::cout

        << std::boolalpha

        << accesAutorise

        << '\n';

 
    return 0;

}

Constante en C++

Le mot-clef :



const

déclare une valeur qui ne peut plus être modifiée après son initialisation.

Le mot-clef :



constexpr

indique qu'une valeur peut être évaluée comme constante à la compilation lorsqu'elle respecte les conditions requises.

Exemple en C#



const bool JournalisationActive = true;

 
int age = 25;

bool compteActif = true;

 
bool estMajeur =

    age >= 18;

 
bool accesAutorise =

    estMajeur && compteActif;

 
if (JournalisationActive)

{

    Console.WriteLine(

        "État de l'accès calculé."

    );

}

 
Console.WriteLine(

    accesAutorise

        ? "Accès autorisé"

        : "Accès refusé"

);

Booléen nullable en C#

C# permet de déclarer un booléen nullable :



bool? reponse = null;

Cette variable peut contenir :



true

false

null

Elle doit être traitée avec précaution, car une condition attend généralement une valeur booléenne non nullable.

Exemple en Visual Basic



Const JournalisationActive As Boolean = True

 
Dim Age As Integer = 25

Dim CompteActif As Boolean = True

 
Dim EstMajeur As Boolean =

    Age >= 18

 
Dim AccesAutorise As Boolean =

    EstMajeur AndAlso CompteActif

 
If JournalisationActive Then

    Console.WriteLine(

        "État de l'accès calculé."

    )

End If

 
If AccesAutorise Then

    Console.WriteLine("Accès autorisé")

Else

    Console.WriteLine("Accès refusé")

End If

Exemple en Python



JOURNALISATION_ACTIVE = True

 
age = 25

compte_actif = True

 
est_majeur = age >= 18

 
acces_autorise = (

    est_majeur

    and compte_actif

)

 
if JOURNALISATION_ACTIVE:

    print("État de l'accès calculé.")

 
if acces_autorise:

    print("Accès autorisé")

else:

    print("Accès refusé")

Constantes en Python

Python ne possède pas de mécanisme général empêchant techniquement la réaffectation d'une constante.

Par convention, un nom écrit entièrement en majuscules indique une valeur qui ne devrait pas être modifiée :



JOURNALISATION_ACTIVE

Cette convention repose sur la discipline du programmeur.

Exemple en JavaScript



const JOURNALISATION_ACTIVE = true;

 
const age = 25;

let compteActif = true;

 
const estMajeur =

    age >= 18;

 
const accesAutorise =

    estMajeur && compteActif;

 
if (JOURNALISATION_ACTIVE) {

    console.log(

        "État de l'accès calculé."

    );

}

 
console.log(

    accesAutorise

        ? "Accès autorisé"

        : "Accès refusé"

);

Conversion implicite en JavaScript

JavaScript permet d'utiliser de nombreuses valeurs dans un contexte booléen.

Certaines valeurs sont considérées comme fausses, notamment :



false

0

-0

""

null

undefined

NaN

De nombreuses autres valeurs sont considérées comme vraies.

Cette conversion implicite doit être distinguée du type booléen lui-même.

Valeurs truthy et falsy

Dans certains langages dynamiques, une valeur peut être interprétée comme vraie ou fausse sans être un booléen.

On parle souvent de valeurs :

truthy

et :

falsy

Cette souplesse peut raccourcir le code, mais elle peut aussi produire des erreurs lorsque la conversion n'est pas clairement comprise.

Exemple de chaîne vide

Dans certains langages :

est interprété comme faux.

Cependant, la chaîne :

"false"

est généralement considérée comme vraie, car elle n'est pas vide.

Son contenu textuel ne la transforme pas automatiquement en valeur booléenne fausse.

Conversion explicite

Une conversion explicite indique clairement que l'on souhaite obtenir une valeur booléenne.

Exemples conceptuels :

Booléen(Valeur)

ConvertirEnBooléen(Valeur)

Cette conversion doit suivre les règles définies par le langage ou l'application.

Conversion d'une chaîne

Lorsqu'une chaîne doit être convertie en booléen, il faut généralement reconnaître explicitement les valeurs acceptées.

Par exemple :

"true"
"false"
"1"
"0"
"oui"
"non"

La comparaison devrait tenir compte :

de la casse ;
des espaces ;
de la langue ;
des valeurs invalides.

Algorithme de conversion

MODULE ConvertirChaîneEnBooléen(Texte)

   Texte ←
      MINUSCULE(
         SUPPRIMER_ESPACES(Texte)
      )

   SI Texte = "true"
      OU Texte = "vrai"
      OU Texte = "1"
      OU Texte = "oui"
   ALORS
      RETOURNER VRAI
   FIN SI

   SI Texte = "false"
      OU Texte = "faux"
      OU Texte = "0"
      OU Texte = "non"
   ALORS
      RETOURNER FAUX
   FIN SI

   PRODUIRE ERREUR
      "Valeur booléenne invalide"

Sérialisation

Lorsqu'une valeur booléenne est enregistrée ou transmise, sa représentation dépend du format.

En JSON, les littéraux sont généralement :



true

false

Ils sont écrits en minuscules et ne sont pas placés entre guillemets.

Exemple JSON



{

  "compteActif": true,

  "administrateur": false

}

L'écriture suivante représenterait plutôt des chaînes :



{

  "compteActif": "true",

  "administrateur": "false"

}

Valeurs booléennes dans une base de données

Les bases de données peuvent représenter les booléens de différentes manières :

type booléen natif ;
bit ;
entier `0` ou `1` ;
caractère `O` ou `N` ;
chaîne `TRUE` ou `FALSE`.

Le choix dépend du système de gestion de base de données et du schéma utilisé.

Colonne booléenne

Une colonne peut représenter un état comme :

CompteActif

Chaque enregistrement peut alors contenir :

VRAI

ou :

FAUX

Si la colonne autorise `NULL`, un troisième état implicite devient possible.

Valeur par défaut

Une variable, une propriété ou une colonne booléenne peut posséder une valeur par défaut.

Par exemple :

CompteActif = FAUX

La valeur par défaut doit correspondre au comportement le plus sûr et le plus logique pour l'application.

Choix sécuritaire par défaut

Dans les mécanismes d'autorisation, une valeur par défaut fausse est souvent préférable.

AccèsAutorisé ← FAUX

Le programme accorde ensuite l'accès uniquement après avoir validé toutes les conditions nécessaires.

Cette stratégie correspond au principe de refus par défaut.

Exemple d'autorisation

AccèsAutorisé ← FAUX

SI
   UtilisateurAuthentifié
   ET CompteActif
   ET PossèdePermission
ALORS
   AccèsAutorisé ← VRAI
FIN SI

Une erreur ou une condition manquante ne devrait pas accorder automatiquement l'accès.

État booléen et événements

Une variable booléenne peut être modifiée en réponse à un événement.

AU CLIC SUR BoutonDémarrer
EstEnMarche ← VRAI

AU CLIC SUR BoutonArrêter
EstEnMarche ← FAUX

Elle représente alors l'état courant de l'interface ou du système.

Case à cocher

Une case à cocher est souvent liée à une valeur booléenne.

Case	Valeur
Non cochée	FAUX
Cochée	VRAI

Certaines interfaces autorisent également un état indéterminé, ce qui crée un modèle à trois états.

Bouton bascule

Un bouton bascule change alternativement entre deux états.

Activé
Désactivé

Son comportement peut être représenté par :

État ← NON État

Cette opération est une application directe du complément booléen.

Capteurs numériques

Un capteur peut produire une valeur booléenne.

Par exemple :

PrésenceDétectée
PorteFermée
PressionSuffisante
TempératureCritique

Ces valeurs peuvent ensuite être combinées pour contrôler une machine ou déclencher une alarme.

Exemple de contrôle

PeutDémarrer ←
   PorteFermée
   ET PressionSuffisante
   ET NON ArrêtUrgence

La machine peut démarrer uniquement lorsque toutes les conditions de sécurité sont satisfaites.

Variables booléennes dans une machine à états

Une variable booléenne peut représenter un état simple, mais elle devient insuffisante lorsqu'un système possède plusieurs états mutuellement exclusifs.

Par exemple, une connexion peut être :

Déconnectée
ConnexionEnCours
Connectée
Erreur

Plusieurs booléens pourraient représenter des combinaisons incohérentes.

États incohérents

Considérons :

EstDéconnecté
EstEnConnexion
EstConnecté
AUneErreur

Il serait possible d'obtenir accidentellement :

EstDéconnecté = VRAI
EstConnecté = VRAI

Ces deux états sont contradictoires.

Une énumération peut être plus appropriée lorsqu'un seul état parmi plusieurs doit être actif.

Booléen ou énumération

Un booléen convient lorsque la réponse est réellement binaire :

FichierExiste

Une énumération convient mieux lorsqu'il existe plusieurs situations :

ÉtatFichier =
   Absent
   Disponible
   Verrouillé
   Corrompu

Le choix du bon type améliore la précision du modèle.

Obsession des booléens

L'utilisation excessive de variables booléennes peut compliquer un programme.

Plusieurs indicateurs indépendants peuvent produire :

2ⁿ

combinaisons possibles.

Avec quatre booléens, on obtient :

2⁴ = 16

combinaisons, dont plusieurs peuvent être invalides.

Validation des combinaisons

Lorsque plusieurs variables booléennes décrivent un même état, il faut parfois vérifier leur cohérence.

Par exemple :

NON(
EstOuvert
ET EstFermé
)

Cette condition interdit qu'un objet soit considéré simultanément ouvert et fermé.

Une meilleure modélisation peut toutefois supprimer la possibilité même de cet état incohérent.

Variable dérivée

Une variable booléenne dérivée peut être calculée à partir d'autres données plutôt que mémorisée séparément.

Par exemple :

EstVide ← NombreÉléments = 0

Si `NombreÉléments` est déjà connu, mémoriser également `EstVide` peut créer une incohérence si l'une des deux valeurs est modifiée sans l'autre.

État calculé ou enregistré

Il est souvent préférable de calculer :

EstVide

à partir de :

NombreÉléments

plutôt que de stocker les deux valeurs.

Toutefois, l'enregistrement d'une valeur dérivée peut être justifié pour des raisons de performance, à condition de maintenir la synchronisation.

Variable volatile

Dans certains environnements concurrents ou matériels, une variable booléenne peut être modifiée par :

un autre fil d'exécution ;
une interruption ;
un périphérique ;
un autre processeur.

Des mécanismes spéciaux peuvent être requis pour garantir que les modifications sont visibles et correctement synchronisées.

Accès concurrent

L'écriture et la lecture d'un booléen ne suffisent pas toujours à coordonner plusieurs fils d'exécution.

Une variable comme :

DoitArrêter

peut nécessiter :

une opération atomique ;
une barrière mémoire ;
un verrou ;
un mécanisme d'annulation ;
une primitive de synchronisation.

La solution dépend du langage et de la plateforme.

Exemple conceptuel de terminaison

DoitArrêter ← FAUX

PARALLÈLEMENT :

   TANT QUE NON DoitArrêter
      EffectuerTravail
   FIN TANT QUE

AUTRE FIL :

   DoitArrêter ← VRAI

Sans synchronisation appropriée, le premier fil pourrait ne pas observer immédiatement la modification.

Variable booléenne dans une structure

Une structure peut regrouper plusieurs propriétés booléennes.

Utilisateur
   EstActif
   EstAdministrateur
   EstVérifié
   PeutPublier

Chaque propriété représente un aspect distinct de l'utilisateur.

Leur relation doit être clairement définie pour éviter les états contradictoires.

Masque de permissions

Lorsque le nombre de permissions est élevé, des indicateurs peuvent être regroupés dans un masque de bits.

LECTURE = 0001 ÉCRITURE = 0010 SUPPRESSION = 0100 ADMINISTRATION = 1000

Une valeur peut contenir plusieurs permissions simultanément.

Ce modèle diffère d'un booléen unique, mais repose sur les mêmes opérations logiques.

Test d'une permission

PossèdeÉcriture ←
   (
      Permissions
      ET MASQUE_ÉCRITURE
   )
   ≠ 0

Le résultat du test est une valeur booléenne.

Les opérations bit à bit produisent ici une valeur numérique, ensuite transformée en condition logique.

Comparaison explicite avec vrai

Une condition comme :

SI EstActif = VRAI ALORS

peut généralement être simplifiée en :

SI EstActif ALORS

La variable contient déjà une valeur booléenne.

La comparaison explicite est souvent redondante.

Comparaison explicite avec faux

Au lieu de :

SI EstActif = FAUX ALORS

on peut généralement écrire :

SI NON EstActif ALORS

Cette formulation exprime directement la négation de la condition.

Cas où la comparaison peut être utile

Une comparaison explicite peut être utile lorsque :

le type n'est pas strictement booléen ;
une valeur nullable est utilisée ;
trois états doivent être distingués ;
une API retourne un entier ;
la lisibilité exige de distinguer plusieurs valeurs.

Par exemple :

SI Réponse = NUL ALORS

est différent de :

SI Réponse = FAUX ALORS

Conditions toujours vraies ou fausses

Une expression peut devenir constante.

Par exemple :

A OU VRAI

est toujours vraie.

A ET FAUX

est toujours fausse.

Ces expressions peuvent généralement être simplifiées.

Code inaccessible

Une condition toujours fausse peut produire du code inaccessible.

SI FAUX ALORS
ExécuterInstruction
FIN SI

L'instruction ne sera jamais exécutée.

Les compilateurs peuvent détecter ou éliminer ce type de branche.

Activation conditionnelle

Une constante booléenne peut être utilisée pour activer temporairement une fonctionnalité.

CONST FONCTION_EXPÉRIMENTALE = FAUX

Puis :

SI FONCTION_EXPÉRIMENTALE ALORS
UtiliserNouvelAlgorithme
SINON
UtiliserAlgorithmeStable
FIN SI

Dans les grands systèmes, un mécanisme spécialisé de fonctionnalités activables peut être préférable.

Indicateur de fonctionnalité

Un indicateur de fonctionnalité, ou feature flag, contrôle l'activation d'une fonction.

Il peut être :

constant dans le code ;
chargé depuis une configuration ;
modifié à distance ;
différent selon les utilisateurs ;
activé progressivement.

Lorsqu'il peut changer pendant l'exécution, il s'agit d'une variable et non d'une constante.

Test booléen unitaire

Les valeurs booléennes sont fréquemment utilisées dans les tests logiciels.

ASSERTION(
Résultat = VRAI
)

ou simplement :

ASSERTION(Résultat)

Un test réussit lorsque la condition évaluée est vraie.

Exemple de test

MODULE TestEstPair

   ASSERTION(
      EstPair(4)
   )

   ASSERTION(
      NON EstPair(5)
   )

Le premier test vérifie une valeur vraie, tandis que le second vérifie une valeur fausse.

Propriété booléenne

Une propriété booléenne peut exprimer une caractéristique mathématique ou informatique.

EstPremier(Nombre)
EstTrié(Tableau)
EstSymétrique(Matrice)
EstVide(Ensemble)
EstConnexe(Graphe)

Ces propriétés peuvent être combinées dans des expressions plus complexes.

Quantificateurs et variables booléennes

Une propriété appliquée à chaque élément peut produire une série de valeurs booléennes.

L'opération logique :

POUR TOUT

est vraie si toutes les propriétés sont vraies.

L'opération :

IL EXISTE

est vraie si au moins une propriété est vraie.

Exemple avec un tableau

TousPositifs ← VRAI

POUR CHAQUE Valeur DANS Tableau
   SI Valeur ≤ 0 ALORS
      TousPositifs ← FAUX
   FIN SI
FIN POUR

La variable reste vraie seulement si aucun élément invalide n'est rencontré.

Arrêt anticipé

L'algorithme précédent peut s'arrêter dès que le résultat devient définitivement faux.

TousPositifs ← VRAI
POUR CHAQUE Valeur DANS Tableau
   SI Valeur ≤ 0 ALORS
      TousPositifs ← FAUX
      QUITTER BOUCLE
   FIN SI
FIN POUR

Cette optimisation évite les comparaisons restantes.

Accumulateur booléen ET

Pour vérifier que toutes les conditions sont vraies :

Résultat ← VRAI

Puis :

Résultat ←
Résultat ET Condition

La valeur devient fausse dès qu'une condition échoue.

Accumulateur booléen OU

Pour vérifier qu'au moins une condition est vraie :

Résultat ← FAUX

Puis :

Résultat ←
Résultat OU Condition

La valeur devient vraie dès qu'une condition réussit.

Valeurs initiales des accumulateurs

Opération cumulative	Valeur initiale
ET sur plusieurs conditions	VRAI
OU sur plusieurs conditions	FAUX

Ces valeurs correspondent aux éléments neutres des opérations concernées.

Tableau de déclarations selon les langages

Langage	Type	Valeur vraie	Valeur fausse
Pascal	Boolean	True	False
Delphi	Boolean	True	False
C	bool / _Bool	true	false
C++	bool	true	false
C#	bool	true	false
Java	boolean	true	false
JavaScript	boolean	true	false
Python	bool	True	False
Visual Basic	Boolean	True	False
Rust	bool	true	false
Go	bool	true	false
Swift	Bool	true	false
Kotlin	Boolean	true	false

Sensibilité à la casse

Les littéraux booléens doivent respecter la syntaxe du langage.

En Python :



True

False

commencent par une majuscule.

En Java :


true
false

sont écrits en minuscules.

Une écriture incorrecte peut être interprétée comme un identificateur inconnu.

Représentation textuelle

Lorsqu'un booléen est affiché, le résultat peut apparaître sous différentes formes :

True
False

true
false

Vrai
Faux

1
0

La représentation affichée ne modifie pas la valeur logique interne.

Localisation

La valeur interne d'un booléen ne dépend pas de la langue de l'utilisateur.

L'interface peut afficher :

Oui
Non

en français, ou :

Yes
No

en anglais.

Le programme conserve néanmoins une valeur logique commune.

Oui et non

Les mots :

Oui
Non

ne sont pas toujours équivalents à des booléens dans toutes les situations.

Une question peut proposer :

Oui
Non
Annuler

Le troisième choix empêche de modéliser la réponse par un simple booléen.

Une énumération ou un type résultat est alors plus précis.

Absence de réponse

Dans un formulaire, une case non cochée peut signifier :

une réponse négative ;
aucune réponse ;
une valeur non applicable.

Ces situations ne doivent pas être confondues.

Le modèle de données doit préciser clairement la signification de chaque état.

Bonnes pratiques

Pour utiliser correctement les variables et constantes booléennes, il est recommandé de :

choisir des noms exprimant clairement une condition ;
initialiser les variables avant leur lecture ;
préférer les formulations positives ;
éviter les doubles négations ;
utiliser une constante lorsque la valeur ne change pas ;
distinguer faux, nul et inconnu ;
éviter les paramètres booléens obscurs ;
calculer les propriétés dérivées lorsque cela évite les incohérences ;
employer une énumération lorsque plus de deux états existent ;
choisir une valeur par défaut sécuritaire ;
distinguer les opérations logiques des opérations bit à bit.

Erreurs fréquentes

Les erreurs courantes comprennent :

confondre affectation et comparaison ;
utiliser une variable non initialisée ;
comparer inutilement un booléen avec `VRAI` ;
interpréter une chaîne "false" comme une valeur fausse ;
confondre NULL et FAUX ;
employer plusieurs booléens pour représenter un état unique ;
utiliser un nom négatif difficile à comprendre ;
oublier qu'une valeur non nulle peut être vraie dans certains langages ;
supposer qu'un booléen occupe toujours un bit ;
oublier les règles de conversion implicite ;
utiliser une constante alors que la valeur doit changer ;
modifier une variable censée rester immuable.

Algorithme général d'utilisation

MODULE UtiliserVariableBooléenne

   Déclarer la variable

   Choisir un nom décrivant
      une question logique

   Initialiser la variable
      à une valeur connue

   Modifier la valeur
      seulement lorsque
      l'état correspondant change

   Lire la variable
      dans une condition

   Éviter les états
      incohérents

   RETOURNER résultat

Exemple complet en pseudocode

MODULE VérifierAccès(Âge,CompteActif,CompteSuspendu,PossèdePermission)

   CONST ÂGE_MINIMUM = 18

   EstMajeur ←
      Âge >= ÂGE_MINIMUM

   EstCompteUtilisable ←
      CompteActif
      ET NON CompteSuspendu

   AccèsAutorisé ←
      EstMajeur
      ET EstCompteUtilisable
      ET PossèdePermission

   RETOURNER AccèsAutorisé

Analyse de l'exemple

La constante :

ÂGE_MINIMUM

ne change pas pendant l'exécution.

Les variables :

EstMajeur
EstCompteUtilisable
AccèsAutorisé

reçoivent les résultats de différentes expressions booléennes.

Chaque nom indique clairement la signification de la valeur vraie.

Tableau récapitulatif

Notion	Description
Domaine booléen	Ensemble `{FAUX,VRAI}` ou `{0,1}`
Variable booléenne	Emplacement pouvant changer entre vrai et faux
Constante booléenne	Valeur logique fixe
Littéral booléen	Valeur vraie ou fausse écrite directement
Affectation	Placement d'une valeur dans une variable
Initialisation	Première affectation d'une variable
Drapeau	Booléen mémorisant un état ou un événement
Prédicat	Fonction ou expression produisant un booléen
Complément	Valeur opposée obtenue par NON
Booléen nullable	Booléen pouvant aussi contenir une absence de valeur
Valeur dérivée	Booléen calculé à partir d'autres données
Masque de bits	Groupe de plusieurs indicateurs dans une valeur binaire

Avantages

Les variables et constantes booléennes présentent plusieurs avantages :

elles représentent simplement des états binaires ;
elles rendent les décisions d'un programme explicites ;
elles peuvent être combinées dans des expressions logiques ;
elles facilitent la lecture des conditions ;
elles permettent de mémoriser le succès ou l'échec d'une opération ;
elles contrôlent les boucles et les structures conditionnelles ;
elles correspondent naturellement aux bits et aux circuits numériques ;
elles permettent de créer des prédicats réutilisables ;
elles facilitent les validations et les contrôles d'accès ;
elles peuvent être stockées et transmises efficacement ;
elles servent de base aux fonctions et aux expressions booléennes.

Limites et précautions

Les variables booléennes possèdent également certaines limites :

elles ne peuvent représenter correctement que deux états ;
elles peuvent masquer une réalité comportant plusieurs situations ;
plusieurs booléens liés peuvent produire des combinaisons incohérentes ;
une valeur nulle ou inconnue ne doit pas toujours être assimilée à faux ;
les conversions implicites varient selon les langages ;
leur représentation mémoire n'est pas nécessairement limitée à un bit ;
une chaîne contenant "false" n'est pas automatiquement fausse ;
les paramètres booléens littéraux peuvent rendre les appels peu lisibles ;
une mauvaise initialisation peut provoquer des décisions erronées ;
un nom négatif peut produire des conditions difficiles à comprendre ;
un booléen simple peut être insuffisant pour décrire précisément un résultat d'erreur.

Remarque

Les variables et les constantes booléennes constituent les unités élémentaires de toute expression logique. Une variable permet de représenter un état susceptible de changer, tandis qu'une constante représente une valeur fixe comme vrai ou faux. Leur apparente simplicité ne doit toutefois pas faire oublier l'importance d'une modélisation précise.

Un booléen convient lorsqu'une question possède réellement deux réponses possibles. Lorsqu'une donnée peut être inconnue, absente, en attente ou appartenir à plusieurs états distincts, un type plus riche peut être nécessaire. Le choix entre un booléen, une valeur nullable, une énumération ou une structure dépend donc de la nature exacte de l'information à représenter.

La maîtrise des variables et constantes booléennes prépare à l'étude des opérations fondamentales NON, ET et OU, des expressions booléennes, des tables de vérité, des lois de simplification, des formes normales, des conditions de programmation et des circuits logiques numériques.

Dernière mise à jour : Jeudi, le 16 juillet 2026