Boolean

Description

Les valeurs boolennes sont gnralement produites par les oprateurs relationnels, les oprateurs d'galit et l'oprateur logique NOT (!). Elles peuvent aussi tre produites par des fonctions qui reprsentent des conditions, comme Array.isArray(). Notez que les oprateurs logiques binaires tels que && et || retournent les valeurs des oprandes, qui peuvent ou non tre des valeurs boolennes.

Les valeurs boolennes sont gnralement utilises dans des tests conditionnels, comme la condition des instructions if...else et while, l'oprateur conditionnel (? :) ou la valeur de retour prdicat de Array.prototype.filter().

Vous aurez rarement besoin de convertir explicitement quelque chose en une valeur boolenne, car JavaScript le fait automatiquement dans les contextes boolens, vous pouvez donc utiliser n'importe quelle valeur comme si c'tait un boolen, en fonction de son quivalent vrai. Il est conseill d'utiliser if (condition) et if (!condition) plutt que if (condition === true) ou if (condition === false) dans votre code afin de profiter de cette convention. Cependant, veiller ce que les valeurs reprsentant des conditions soient toujours des boolens peut aider clarifier l'intention de votre code.

// Faites ceci :
// a retourne toujours une valeur boolenne
const isObject = (obj) => !!obj && typeof obj === "object";

// Ou ceci :
const isObject = (obj) => Boolean(obj) && typeof obj === "object";

// Ou ceci :
const isObject = (obj) => obj !== null && typeof obj === "object";

// Au lieu de ceci :
// Cela peut retourner des valeurs falsy qui ne sont pas gales  false
const isObject = (obj) => obj && typeof obj === "object";

Primitives boolennes et objets Boolean

Pour convertir des valeurs non boolennes en boolen, utilisez Boolean comme fonction ou l'oprateur de double ngation. N'utilisez pas le constructeur Boolean() avec new.

const good = Boolean(expression);
const good2 = !!expression;

const bad = new Boolean(expression); // n'utilisez pas ceci !

En effet, tous les objets, y compris un objet Boolean dont la valeur encapsule est false, sont quivalent vrai et sont valus true dans des endroits comme les instructions conditionnelles. (Voir aussi la section coercition boolenne cidessous.)

if (new Boolean(true)) {
  console.log("Ce journal est affich.");
}

if (new Boolean(false)) {
  console.log("Ce journal est AUSSI affich.");
}

const myFalse = new Boolean(false); // myFalse est un objet Boolean (pas la valeur primitive false)
const g = Boolean(myFalse); // g vaut true
const myString = new String("Hello"); // myString est un objet String
const s = Boolean(myString); // s vaut true

Coercition boolenne

De nombreuses oprations intgres qui attendent des boolens convertissent d'abord leurs arguments en boolens. L'opration (angl.) peut tre rsume ainsi :

• Les boolens sont retourns tels quels.
• undefined devient false.
• null devient false.
• 0, -0 et NaN deviennent false ; les autres nombres deviennent true.
• 0n devient false ; les autres BigInts deviennent true.
• La chane vide "" devient false ; les autres chanes de caractres deviennent true.
• Symboles deviennent true.
• Tous les objets deviennent true.

En d'autres termes, seules quelques valeurs sont converties en false ce sont les valeurs quivalentes faux. Toutes les autres valeurs sont des valeurs quivalentes vrai. L'quivalence vrai d'une valeur est importante lorsqu'elle est utilise avec des oprateurs logiques, des instructions conditionnelles ou tout contexte boolen.

Il existe deux faons d'obtenir le mme effet en JavaScript.

• Double ngation : !!x fait la ngation de x deux fois, ce qui convertit x en boolen en utilisant le mme algorithme que ci-dessus.
• La fonction Boolean() : Boolean(x) utilise le mme algorithme que ci-dessus pour convertir x.

Notez que l'quivalent vrai n'est pas la mme chose que d'tre faiblement gal true ou false.

if ([]) {
  console.log("[] est quivalent  vrai");
}
if ([] == false) {
  console.log("[] == false");
}
// [] est quivalent  vrai
// [] == false

[] est quivalent vrai, mais il est aussi faiblement gal false. Il est quivalent vrai, car tous les objets sont quivalents vrai. Cependant, lors d'une comparaison avec false, qui est une valeur primitive, [] est aussi converti en une valeur primitive, qui est "" via Array.prototype.toString(). Comparer des chanes de caractres et des boolens fait que les deux sont convertis en nombres, et ils deviennent tous deux 0, donc [] == false vaut true. En gnral, l'quivalence faux et == false diffrent dans les cas suivants :

• NaN, undefined et null sont quivalents faux mais ne sont pas faiblement gaux false.
• "0" (et d'autres littraux de chane de caractres qui ne sont pas "" mais sont convertis en 0) est quivalent vrai mais faiblement gal false.
• Les objets sont toujours quivalents vrai, mais leur reprsentation primitive peut tre faiblement gale false.

Les valeurs quivalentes vrai sont encore moins susceptibles d'tre faiblement gales true. Toutes les valeurs sont soit quivalentes vrai, soit quivalentes faux, mais la plupart des valeurs ne sont faiblement gales ni true ni false.

Constructeur

Boolean()

Cre un nouvel objet Boolean.

Proprits d'instance

Ces proprits sont dfinies sur Boolean.prototype et partages par toutes les instances de Boolean.

Boolean.prototype.constructor

La fonction constructeur qui a cr l'objet instance. Pour les instances de Boolean, la valeur initiale est le constructeur Boolean().

Mthodes d'instances

Boolean.prototype.toString()

Retourne une chane de caractres qui est "true" ou "false" selon la valeur de l'objet. Il s'agit d'une surcharge de la mthode Object.prototype.toString().

Boolean.prototype.valueOf()

Retourne la valeur primitive de l'objet Boolean. Il s'agit d'une surcharge de la mthode Object.prototype.valueOf().

Exemples

Les valeurs false

const bSansParam = Boolean();
const bZero = Boolean(0);
const bNull = Boolean(null);
const bChaineVide = Boolean("");
const bfalse = Boolean(false);

Les valeurs true

const btrue = Boolean(true);
const bChaineTrue = Boolean("true");
const bChaineFalse = Boolean("false");
const bSuLin = Boolean("Su Lin");
const bArrayProto = Boolean([]);
const bObjProto = Boolean({});

Spcifications

Compatibilit des navigateurs

Voir aussi

• L'entre de glossaire Boolen
• Valeurs primitives boolennes
• Le type de donnes boolen sur Wikipdia