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

Qu'est-ce que l'utilisation de:

var flag = new Boolean(false);

par rapport à:

var flag = false;

Quand souhaitez-vous réellement utiliser new Boolean?

Voir aussi Quel est le point de l'Objet Booléen?

InformationsquelleAutor zeroin23 | 2009-05-13

boolean javascript

64

De la fonction globale Boolean() peut être utilisé pour la conversion de type lorsqu'il est appelé sans new, par exemple,
```
var foo = Boolean(bar); //equivalent to `var foo = !!bar`
```
Lorsqu'il est appelé avec new, un objet wrapper seront créés en outre, ce qui signifie que vous pouvez assigner des propriétés de l'objet:
```
var foo = new Boolean(bar); //equivalent to `var foo = Object(Boolean(bar));`
foo.baz = 'quux';
alert(foo.baz);
```
Ce n'est pas possible avec des valeurs primitives comme primitives ne peuvent pas tenir propriétés:
```
var foo = true;
foo.baz = 'quux';
alert(foo.baz); //`foo.baz` is `undefined`
```
L'attribution d'une propriété à une primitive de ne pas produire une erreur à cause de l'auto-boxing, c'est à dire
```
foo.baz = 'quux';
```
sera interprété comme
```
//create and immediately discard a wrapper object:
(new Boolean(foo)).baz = 'quux';
```
Pour obtenir la valeur primitive de retour, vous aurez pour appeler le valueOf() méthode. Cette opération est nécessaire si vous souhaitez utiliser le enveloppés de la valeur, car les objets d'évaluer à true booléennes contextes - même si le enveloppés valeur est false.

Je n'ai jamais rencontré une application utile d'être en mesure d'attribuer des propriétés à valeurs booléennes, mais la boxe pourrait être utile dans les cas où une référence à une valeur primitive est nécessaire.
- Appel Boolean(someVar) peut être utile de jeter un booléen primative, mais n'oubliez pas que Boolean(false) == faux, mais new Boolean(false) == vrai, parce que c'est un objet
- Vous n'avez pas toujours besoin d'utiliser valueOf--il sera automatiquement appelée lors de la primitive est nécessaire. Par exemple, boolean_object === true forcera l'objet de son sous-jacent primitive (mais !boolean_object ne va pas).
- ne pas forcer - new Boolean(true) === true est faux
- Désolé, mon erreur. Cependant, boolean_object == true (deux signes égal, et non pas trois) VA forcer (je suis sûr que, juste testé).
- ne forcer - l'algorithme est décrit dans ECMA-262 ed5, section 11.9.3; la traduction de la new Boolean(false) == false retour à Javascript, la comparaison réalisée est Number(new Boolean(false).valueOf()) === Number(false); l'algorithme a quelques intéressantes conséquences, par exemple, new Number(0) == false même si Boolean(new Number(0)) === true
- Modernizr cela pour créer des booléens pour les fonctionnalités qui ont des sous-entités. bool = new Boolean(bool); bool.ogg = ...; bool.h264 = ...; bool.webm = ...;
InformationsquelleAutor Christoph
21

Tandis que d'autres ont mentionné la théorie, permettez-moi de parler de la partie pratique:

Parce que Boolean des objets (comme des objets en général) sont toujours truthy, il est considéré comme une mauvaise pratique à utiliser. Dans de nombreuses années de JS programmation, je n'ai jamais utilisé, et je ne me souviens pas de voir Booleans dans d'autres peuples code. Même pas une fois.

À l'aide de primitives valeurs d'éviter la confusion et à faire de votre code un peu plus courte.

Si jamais vous avez besoin d'un bool enveloppé dans un objet, vous pourriez aussi bien utiliser un Object objet comme suit:
```
foo = { value: false };
```
Aussi, l'appel de la Boolean() constructeur comme une fonction (comme dans foo = Boolean(bar)) a le même effet qu'explicite typecasting à l'aide de !!, et le dernier est généralement privilégié par rapport à l'ancien.
- Vous réclamez une préférence générale pour une paire de pas opérateurs !!. Mais le but et l'effet de !! semble moins évident que le classique Boolean() convertisseur, et je me demande si le code de clarté est une préoccupation ici.
- Une seule note. Ne jamais utiliser new ce qui résulte en une Boolean Objet. Puis, à chaque fois que vous aurez à utiliser foo.valueOf() dans des conditions. Au lieu de cela viens de l'appeler Boolean comme une fonction qui conduit à une conversion de type, c'est à dire Boolean(bar) === !!bar
InformationsquelleAutor user123444555621
4

La classe Boolean rochers. Au lieu de ce code spaghetti :
```
if (foo===true) this.launch();
else this.dontLaunch();
```
Vous pouvez faire ce que tout programmeur et n'é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));
```
Beaucoup mieux maintenant.
- Je préfère parfois expression ? this.launch() : this.dontLaunch() Pensez que votre deuxième exemple est encore pire spaghetti
- Bien des Booléens prototype serait prolongée tout en haut du fichier, les foo serait déclaré à l'endroit où les variables sont déclarées, et le ifTrue méthodes serait, le cas échéant. De toute façon---cette réponse n'est pas vraiment sérieux. Une sorte de satire sur la programmation fonctionnelle et de l'élargissement du prototype.
- Quelle merveille! Suivra cette pratique à partir de maintenant 🙂
InformationsquelleAutor Nick Manning
1

Avant la question ci-dessus d'abord la fonction Booléenne, Boolean ()
```
Boolean(10 > 4) //return true
Boolean(4 > 9) //return false
```
Suivant: tout avec une réelle valeur return true. E. g
```
100
-4
4.4
"hello"
"false" //note even the string value false return true.
```
tout sans réelle valeur return false E. g
```
NaN 
var x = 10 / "H"; //Boolean(x); return false.
undefined
"" 
0
-0
false 
null
```
Maintenant la Boolean objet est un objet wrapper pour une valeur booléenne. La valeur passée comme premier paramètre est converti 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 faux. Toutes les autres valeurs, y compris n'importe quel objet ou la chaîne "false", créer un objet avec une valeur initiale de vrai.

Cela permet très puissant astuces.

InformationsquelleAutor Lawrence Oputa
-2

Question intéressante:

Vous d'utiliser les nouvelles Booléen pour créer un objet boolean. Il peut y avoir beaucoup de scénarios, mais j'ai discuté ci-dessous un scénario.

Supposons que vous voulez une comparaison dans votre code où vous voulez faire correspondre la chaîne de valeur et son type de données et il a pour booléen (vrai/faux), alors vous allez utiliser un nouveau boolean plutôt que d'attribuer une simple valeur false.
```
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");
}
```
InformationsquelleAutor Sohail Arif

Vous devez vous connecter pour publier un commentaire.