I am reading through the Mozilla Manual on JavaScript and I come to this point in my reading, Boolean Object and I can't see a single use for them. What's their point? Why would'nt you use just true and false ?
By the way, I don't know Java at all and I'm not afraid of learning new things that consequently why I'm trying to learn JavaScript. I'm a PHP programmer, a back end guy, and I'd like to learn how to do some front end work, so I'm reading the Mozilla JavaScript Guide .
Source: Tips4all
Because this is (somewhat sadly) how the language was defined -- I suspect it was originally for performance/optimization; note the case of assignment to a string property below. (Java works similarly, although Scala and Python largely reject this distinction).
ReplyDeleteNote that Boolean isn't the only "wrapper type". There are also String and Number, for instance.
Because of this there remains a number of quirks (the below could just as much apply to Boolean):
typeof("foo") // string
typeof(new String("foo")) // object
"foo" instanceof String // false
new String("foo") instanceof String // true
// result is undefined: a string is a primitive and silently "ate" the assignment
// this also makes it a much cheaper value as it's not a "real" object
x = "f"; x.bar = 42; x.bar
// result is 42: a String is a "real" object with real properties!
// however, this also means that it may have a good bit more overhead
x = new String("f"); x.bar = 42; x.bar
I know this didn't "answer" the question, but rather chucks some more wood on the fire ;-)
The only real "gotcha" otherwise from the above is that perhaps new Boolean(false) is a truth-y value.
Happy coding.
JavaScript language design has quite many dusty corners, the Boolean is one of them.
ReplyDeleteNot used in practice.
This:
var a = [];
alert( a instanceof Array );
will tell you "true". But this:
var b = true;
alert( b instanceof Boolean );
for some reason will show "false".
To be short: forget about it.
Perhaps because Javascript Objects are extensible in ways that primitives aren't? (I'm just guessing here, I've never had a need for Boolean.)
ReplyDeleteFrom the documentation:
ReplyDeleteDo not confuse the primitive Boolean
values true and false with the true
and false values of the Boolean
object. Any object whose value is not
undefined , null, 0, NaN, or the empty
string , including a Boolean object
whose value is false, evaluates to
true when passed to a conditional
statement.
Imagine the following scenario:
if(SomeBoolean){...}
will be true in scenarios where SomeBoolean is a Boolean object.
Contrapositively:
if(false){...}
will always be false
Addendum for clarification.
var someString = new Boolean("MyNonEmptyString")
if(someString) //true
var otherString = new Boolean("")
if(otherString) //false
You can coerce a true or false from any value with return Boolean(something),
ReplyDeletebut its shorter to write return !!something, which forces a true or false as well.
Boolean.prototype.bang = function() {
ReplyDeletereturn !this.valueOf();
}
true.bang(); // false
Everything in JavaScript is an object. But at the same time we also have primitives. It's really confusing, just don't overthink it.
I would have to side with most of the people here that there isn't much need for the Boolean object but I do want to point out a couple things.
ReplyDeleteAn explicit comparison will still evaluate like a boolean:
var someBool = new Boolean(false);
if (someBool == false) alert('Got here'); //Alerts 'Got here'
Because of this, you could sort of extend it to a subclass and still be able to have the comparison work as above:
var classExtension = {
toYN: function(){
return this == false ? 'N' : 'Y';
}
};
function getNewClass(val){
var newBool = new Boolean(val);
jQuery.extend(newBool, classExtension);
return newBool;
}
var newTest = getNewClass(false);
if (newTest) alert('Its alive');
if (newTest == false) alert('And still a bool');
alert(newTest.toYN());
This will alert 'Its alive', 'And still a bool' and 'N'.
http://jsfiddle.net/fkJuk/
But again, would you ever really need this? Even if you did, it would probably be better just to have your own separate class with a boolean property that gets checked. In the end, it's probably here for consistency, every primitive has direct constructor and prototype access in JavaScript.
Going back to the spec (ECMA-262.pdf page 151), note that when Boolean is called as a function rather than as a constructor, it does type conversion. Thus:
ReplyDeletevar t = 5
, f = 0
console.log(Boolean(t)) //prints true
console.log(Boolean(f)) //prints false
Of course, being a JS object, you can use it as a prototype using the 'new' operator, as others have noted, but I don't see any reason for doing that.