I am aware of Boolean(), String() and Number() casting, and the '' + ..., !!... and +... casting approaches.

I am wondering if there is any reason to not use the function constructors?

I am aware of Boolean(), String() and Number() casting, and the '' + ..., !!... and +... casting approaches.

I am wondering if there is any reason to not use the function constructors?

• javascript

• 3 !! and others are unintentional syntactic sugar. I prefer the constructor approach as it is more readable. If you run it through a pressor/minifier, it can convert it into the uglier yet more pact version. – Travis Webb Commented Mar 14, 2011 at 18:31
• 9 !! is perfectly readable in my opinion. I prefer those shortcuts. – pimvdb Commented Mar 14, 2011 at 18:32
• 2 No, both methods produce the same result. – Šime Vidas Commented Mar 14, 2011 at 18:32
• 1 @Travis: That's a bad example to be honest. That one looks ugly because that are just four ugly tokens together. Also you just remove the spaces in the first one. I mean, e.g. !!someVariable is really pact and nice. – pimvdb Commented Mar 14, 2011 at 18:35
• 2 The !! and such are also available in other languages like PHP, btw. – Tower Commented Mar 14, 2011 at 18:59

7 Answers 7

In general the use of !! is often discouraged, as it's not clear to those who haven't seen it before what the actual purpose of it is. That said, it is less than a third the characters of Boolean().

Further, I'm not sure how often you actually need to cast to a boolean in Javascript, as it is often implicitly cast since Javascript is weakly typed.

Using the new operator with those function constructors can have unreliable effects on the typeof operator. (Edit: As the ments correctly note, this is only when using new Boolean() instead of Boolean())

For example,

var f = new Boolean(true);
if(typeof(f)==="boolean") {//false, since its an object, not boolean
 ....
}

JavaScript Garden has some great examples.

I can think of 7:

1. B
2. o
3. o
4. l
5. e
6. a
7. n

This shouldn't be an issue, but someone could replace the Boolean function with their own making the two ways not equivalent. For example:

Boolean = function(x) {
    alert('Evil');
    return !x; // Oops
}

var x = 0;
console.log(!!x); // false
console.log(Boolean(x)); // true

That's mostly a theoretical difference, since you shouldn't be replacing built in constructors, but it is a difference.

There could also be a small performance difference because of the name lookup and function call overhead. I wouldn't worry about either of those though in most cases. Just use whichever version you prefer.

It might just be a case of using less characters, making for a more pact script.

I find using new with these types can lead to easy confusion or tricky bugs:

var x = new Boolean(true);
console.log( x ); // true
console.log( typeof x ); // "object"

var y = new Boolean('false');
console.log( y ); // true
console.log( typeof y ); // "object"

var z = false;
console.log( z ); // false
console.log( typeof z ); // "boolean"

The Boolean(...) syntax is probably the best option, especially if you’re working on a large application with multiple developers. Code should be as readable as possible for any developer who joins the project.

Just as you should avoid using acronyms in your munication to ensure clarity for a wider audience, your code should also be easily understandable for most developers without needing additional research.

This time, we’re discussing the !! syntax, but there are many strange syntaxes in JavaScript. Reading such code for the first time can be challenging if efforts aren’t made to ensure readability. Moreover, even for experienced developers, it’s easier to work with clear and readable code.

This debate makes sense at the scale of !!, but at the level of an entire codebase, there’s no debate for me, so !! should be avoided.