Is there any reason to do boolean casting with !! instead of Boolean() in JavaScript?

Using the new operator with those function constructors can have unreliable effects on the typeof operator. (Edit: As the comments 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 compact 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 communication 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.