Quel est le but de new Boolean() dans Javascript?



js convert string to boolean (4)

La fonction globale Boolean() peut être utilisée pour lancer un type quand elle est appelée sans new , par ex.

var foo = Boolean(bar); // equivalent to `var foo = !!bar`

Lorsqu'il est appelé avec new , un objet wrapper sera créé en plus, ce qui signifie que vous pouvez assigner des propriétés arbitraires à l'objet:

var foo = new Boolean(bar); // equivalent to `var foo = Object(Boolean(bar));`
foo.baz = 'quux';
alert(foo.baz);

Cela n'est pas possible avec les valeurs primitives car les primitives ne peuvent pas contenir de propriétés:

var foo = true;
foo.baz = 'quux';
alert(foo.baz); // `foo.baz` is `undefined`

L'affectation d'une propriété à une primitive ne génère pas d'erreur à cause de la saisie automatique, c'est-à-dire

foo.baz = 'quux';

sera interprété comme

// create and immediately discard a wrapper object:
(new Boolean(foo)).baz = 'quux';

Pour récupérer la valeur primitive, vous devrez appeler la méthode valueOf() . Cela est nécessaire si vous voulez réellement utiliser la valeur encapsulée, car les objets sont toujours true dans les contextes booléens, même si la valeur encapsulée est false .

Je n'ai jamais rencontré une application utile de pouvoir affecter des propriétés à des booléens, mais la boxe pourrait être utile dans les cas où une référence à une valeur primitive est nécessaire.

Quelle est l'utilisation de:

var flag = new Boolean(false); 

par rapport à:

var flag = false;

Quand utiliseriez-vous réellement un new Boolean ?


Avant la question ci-dessus d'abord la fonction Boolean () , Boolean ()

Boolean(10 > 4) // return true
Boolean(4 > 9) // return false

Suivant: tout avec une valeur réelle retourne vrai. Par exemple

100
-4
4.4
"hello"
"false" // note even the string value false return true.

everthing sans valeur réelle return false

NaN 
var x = 10 / "H"; // Boolean(x); return false.
undefined
"" 
0
-0
false 
null

L'objet Boolean est maintenant un wrapper d'objet pour une valeur booléenne. La valeur transmise en tant que premier paramètre est convertie en une valeur booléenne, si nécessaire. Si la valeur est omise ou est 0, -0, null, false, NaN, undefined ou la chaîne vide ( "" ), l'objet a une valeur initiale de false. Toutes les autres valeurs, y compris tout objet ou la chaîne "false", créent un objet avec une valeur initiale de true.

Cela permet des astuces très puissantes.


Les roches de la classe booléenne. Au lieu de ce code spaghetti 🍝:

if (foo===true) this.launch();
else this.dontLaunch();

Vous pouvez faire ce que tout bon programmeur ferait et étendre le prototype!

Boolean.prototype.ifTrue=function(ifFunc,elseFunc){
    if (this.valueOf()===true) ifFunc(); 
    else elseFunc();
}
var foo=new Boolean(/*expression*/);
foo.ifTrue(this.launch.bind(this),this.dontLaunch.bind(this));

Bien mieux maintenant.


Question interessante:

Vous utilisez new Boolean pour créer un objet booléen. Il peut y avoir beaucoup de scénarios mais j'ai discuté ci-dessous un scénario.

Supposons que vous vouliez une comparaison dans votre code où vous voulez faire correspondre la valeur de chaîne et son type de données et qu'elle booléenne (vrai / faux) alors vous utiliserez new boolean au lieu d'assigner une simple fausse valeur.

var flag = false;  
var flag2 = new Boolean (false);
alert(typeof flag);  //boolean object
alert(typeof flag2); //simple object

if (flag === flag2){
    alert("Value and datatype match");
}
else{
    alert("Value and datatype do not match");
}




boolean