Sunday, April 8, 2012

What"s the point of the Boolean Object?

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


  1. 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).

    Note 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"; = 42;

    // 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"); = 42;

    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.

  2. JavaScript language design has quite many dusty corners, the Boolean is one of them.
    Not used in practice.


    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.

  3. Creating a new boolean object "basically" runs the bit of code in the statement and then from there returns the true boolean value.

    From the same docs:

    1 var b = new Boolean(false);
    2 if (b) // this condition evaluates to true

  4. 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.)

  5. From the documentation:

    Do 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

    Imagine the following scenario:


    will be true in scenarios where SomeBoolean is a Boolean object.



    will always be false

    Addendum for clarification.

    var someString = new Boolean("MyNonEmptyString")
    if(someString) //true
    var otherString = new Boolean("")
    if(otherString) //false

  6. You can coerce a true or false from any value with return Boolean(something),

    but its shorter to write return !!something, which forces a true or false as well.

  7. Boolean.prototype.bang = function() {
    return !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.

  8. 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.

    An 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');

    This will alert 'Its alive', 'And still a bool' and 'N'.
    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.

  9. 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:

    var 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.