Double exclamation points? [duplicate]

Answer 1

This converts a value to a boolean and ensures a boolean type.

"foo"      // Evaluates to "foo".
!"foo"     // Evaluates to false.
!!"foo"    // Evaluates to true.

If foo.bar is passed through, then it may not be 0 but some other falsy value. See the following truth table:

Truth Table for javascript

''        ==   '0'           // false
0         ==   ''            // true
0         ==   '0'           // true
false     ==   'false'       // false
false     ==   '0'           // true
false     ==   undefined     // false
false     ==   null          // false
null      ==   undefined     // true
" \t\r\n" ==   0             // true

Source: Doug Crockford

Javascript also gets really weird when it comes to NaN values. And this is the only case I can think of off the top of my head where !! would behave differently to ===.

NaN   ===  NaN     //false
!!NaN === !!NaN    //true

// !!NaN is false

Answer 2

As stated above, it forces an object with a boolean type. You can see for yourself:

(function typecheck() {
  var a = "a";
  var b = !a;
  var c = !!a;

  alert("var a = " + typeof(a) + "\n" +
        "var b = " + typeof(b) + "\n" +
        "var c = " + typeof(c));
})();

If you are simply doing comparisons, the conversion merely saves you a type coercion later on.

FYI, the following values are coerced to FALSE in JavaScript:

• false
• 0
• ""
• null
• undefined

Answer 3

I think the answer is that there isn't really much point. We can speculate about how it came about:

• maybe an earlier version of the function used someVar in multiple places, or in ways that genuinely benefited from having true or false, so this made more sense.
• maybe the person who wrote the function is so used to using !! to convert to true/false that (s)he didn't even notice that it wasn't necessary here.
• maybe the person who wrote the function feels that every computation (in this case, Boolean conversion) should be given a meaningful name by assigning some variable to its result.
• maybe, since Boolean conversion in JavaScript is surprisingly error-prone (in that e.g. new Boolean(false) is a true-valued value), the person who wrote the function feels that it should always be done explicitly rather than implicitly — even though the effect is the same — just to call attention to it as a potential point of error.
  • this, of course, presupposes that the person who wrote the function thinks of !! as an "explicit" Boolean conversion. Technically it's not — it uses the same implicit Boolean conversion that if does — but if you're used to this idiom, then it amounts to an explicit conversion.

but in my subjective opinion, none of those reasons is a very good one!