使用逻辑not运算符两次。

这意味着！true=false和！！true=真。

!!expr（后跟表达式的两个！运算符）根据表达式的真实性返回布尔值（true或false）。当用于非布尔类型时，它更有意义。考虑以下示例，尤其是第三个示例及其后续示例：

          !!false === false
           !!true === true

              !!0 === false
!!parseInt("foo") === false // NaN is falsy
              !!1 === true
             !!-1 === true  // -1 is truthy
          !!(1/0) === true  // Infinity is truthy

             !!"" === false // empty string is falsy
          !!"foo" === true  // non-empty string is truthy
        !!"false" === true  // ...even if it contains a falsy value

     !!window.foo === false // undefined value is falsy
      !!undefined === false // undefined primitive is falsy
           !!null === false // null is falsy

             !!{} === true  // an (empty) object is truthy
             !![] === true  // an (empty) array is truthy; PHP programmers beware!

沏茶：

!! 不是运算符。这是双重用途！--这是逻辑“not”运算符。

理论上：

! 确定值不是什么的“真相”：

事实是假的不是真的（这就是为什么！假的结果真实）事实是真的不是假的（这就是为什么！真的结果假）

!! 确定值不是什么的“真相”：

事实是真的不是假的（这就是为什么！！真的结果是真的）事实是，假的不是假的（这就是为什么！！假的结果是假的）

我们希望在比较中确定的是参考值的“真相”，而不是参考本身的值。在一个用例中，我们可能想知道值的真实性，即使我们希望值为false（或false），或者如果我们希望值不是布尔类型。

在实践中：

考虑一个简洁的函数，它通过动态类型（也称为“鸭子类型”）来检测特性功能（在本例中，还包括平台兼容性）。如果用户的浏览器支持HTML5＜audio＞元素，我们希望编写一个返回true的函数，但如果＜audio＜未定义，我们不希望该函数抛出错误；我们不想使用try。。。捕捉以处理任何可能的错误（因为它们很严重）；此外，我们也不希望在函数中使用无法始终揭示功能真相的检查（例如，document.createElement（'audio'）仍将创建一个名为<audio>的元素，即使不支持HTML5<audio'）。

以下是三种方法：

// this won't tell us anything about HTML5 `<audio>` as a feature
var foo = function(tag, atr) { return document.createElement(tag)[atr]; }

// this won't return true if the feature is detected (although it works just fine)
var bar = function(tag, atr) { return !document.createElement(tag)[atr]; }

// this is the concise, feature-detecting solution we want
var baz = function(tag, atr) { return !!document.createElement(tag)[atr]; }

foo('audio', 'preload'); // returns "auto"
bar('audio', 'preload'); // returns false
baz('audio', 'preload'); // returns true

每个函数都接受一个<tag>参数和一个要查找的属性，但它们都会根据比较结果返回不同的值。

但等等，还有更多！

你们中的一些人可能注意到，在这个特定的示例中，可以使用稍微更高性能的方法来检查对象是否具有属性。有两种方法可以做到这一点：

// the native `hasOwnProperty` method
var qux = function(tag, atr) { return document.createElement(tag).hasOwnProperty(atr); }

// the `in` operator
var quux = function(tag, atr) { return atr in document.createElement(tag); }

qux('audio', 'preload');  // returns true
quux('audio', 'preload'); // returns true

我们离题了。。。

无论这些情况多么罕见，可能存在一些情况，其中最简洁、最高效，因此最优选的从非布尔值（可能是未定义的值）获得真值的方法确实是使用！！。希望这可笑地澄清了这一点。

!! 不是运算符。这只是！操作员两次。

但使用JavaScript，应用！！在大多数情况下，将Object转换为Boolean是冗余和冗长的，因为：

值未定义或为空的任何对象，包括值为false的布尔对象，传递给有条件的陈述

示例：if（｛｝）｛console.log（“｛｝是true”）｝//logs:“｛}是true”

我只是想补充一下

if(variableThing){
  // do something
}

与

if(!!variableThing){
  // do something
}

但当某些东西未定义时，这可能是一个问题。

// a === undefined, b is an empty object (eg. b.asdf === undefined)
var a, b = {};

// Both of these give error a.foo is not defined etc.
// you'd see the same behavior for !!a.foo and !!b.foo.bar

a.foo 
b.foo.bar

// This works -- these return undefined

a && a.foo
b.foo && b.foo.bar
b && b.foo && b.foo.bar

这里的技巧是，&&s链将返回它找到的第一个假值，这可以被馈送到if语句等。因此，如果b.foo未定义，它将返回undefined并跳过b.foo.bar语句，我们不会得到任何错误。

上面的返回未定义，但如果您有一个空字符串，false，null，0，undefined，这些值将返回，一旦我们在链中遇到它们——[]和｛｝都是“truthy”，我们将沿着所谓的“&&链”继续到右边的下一个值。

P.S.执行上述（b&&b.foo）的另一种方法是（b||{}）.foo。这些方法是等效的，因为如果b未定义，则b||｛｝将为｛}，并且您将访问空对象中的值（无错误），而不是尝试访问“undefined”中的值。

因此，（b||{}）.foo与b&&b.foo相同，（（b||{}）/foo||{}）.bar与b&&b.foo&&b.foo.bar相同。

它模拟Boolean（）转换函数的行为。无论给定什么操作数，第一个NOT都返回布尔值。第二个NOT否定该布尔值，从而给出变量的真正布尔值。最终结果与对值使用Boolean（）函数相同。