是什么 ！！ JavaScript 中的（不是不是）运算符？

它只是逻辑 NOT 运算符，两次 - 它用于将某些内容转换为布尔值，例如：

true === !!10

false === !!0

它将后缀转换为布尔值。

这是一个双 not 操作。第一个 ! 将值转换为布尔值并反转其逻辑值。第二个 ! 反转逻辑值。

似乎 !! 运算符导致双重否定。

var foo = "Hello World!";

!foo // Result: false
!!foo // Result: true

它模拟 Boolean() 转换函数的行为。无论给出什么操作数，第一个 NOT 都会返回一个布尔值。第二个 NOT 否定 Boolean 值，因此给出变量的 true 布尔值。最终结果与对值使用 Boolean() 函数相同。

!! 它同时使用了 NOT 操作两次，! 将值转换为 boolean 并将其反转，因此使用它两次，显示该值的布尔值（false 或 true）。下面是一个简单的例子，看看 !! 是如何工作的：

首先，你有的地方：

var zero = 0;

然后你做!0，它将被转换为布尔值并被评估为true，因为0是falsy，所以你得到反转的值并转换为布尔值，所以它被评估为true。

!zero; //true

但是我们不想要值的反转布尔版本，所以我们可以再次反转它来得到我们的结果！这就是我们使用另一个 ! 的原因。

基本上，!! 确保我们得到的值是布尔值，而不是假值、真值或字符串等......

所以这就像在 javascript 中使用 Boolean 函数，但是将值转换为布尔值的简单且更短的方法：

var zero = 0;
!!zero; //false

！是“布尔非”，它本质上将“启用”的值类型转换为其布尔值的对立面。第二 ！翻转这个值。因此，!!enable 表示“未启用”，将 enable 的值作为布尔值提供给您。

我认为值得一提的是，与逻辑 AND/OR 结合的条件不会返回布尔值，而是在 && 的情况下最后成功或第一次失败，在 || 的情况下第一次成功或最后失败的条件链。

res = (1 && 2); // res is 2
res = (true && alert) // res is function alert()
res = ('foo' || alert) // res is 'foo'

为了将条件转换为真正的布尔文字，我们可以使用双重否定：

res = !!(1 && 2); // res is true
res = !!(true && alert) // res is true
res = !!('foo' || alert) // res is true

!! 构造是一种将任何 JavaScript 表达式转换为其等效布尔值的简单方法。

例如：!!"he shot me down" === true 和 !!0 === false。

这不是一个操作员，而是两个。它等效于以下内容，是一种将值转换为布尔值的快速方法。

val.enabled = !(!enable);

这个问题已经得到了相当彻底的回答，但我想添加一个我希望尽可能简化的答案，使 !!尽可能简单地掌握。

因为 javascript 具有所谓的“真”和“假”值，所以有些表达式在其他表达式中求值时会产生真或假条件，即使正在检查的值或表达式实际上不是 true 或 {2 }。

例如：

if (document.getElementById('myElement')) {
    // code block
}

如果该元素确实存在，则表达式将评估为真，并且将执行代码块。

然而：

if (document.getElementById('myElement') == true) {
    // code block
}

...不会产生真条件，并且即使元素确实存在，代码块也不会被执行。

为什么？因为 document.getElementById() 是一个“真实”表达式，在此 if() 语句中将评估为真，但它不是 true 的实际布尔值。

在这种情况下，双重“不”非常简单。它只是两个not背靠背。

第一个简单地“反转”真值或假值，产生一个实际的布尔类型，然后第二个“反转”它再次回到它的原始状态，但现在是一个实际的布尔值。这样你就有了一致性：

if (!!document.getElementById('myElement')) {}

和

if (!!document.getElementById('myElement') == true) {}

正如预期的那样，两者都会返回true。

我怀疑这是 C++ 的遗留物，人们会覆盖 !运算符，但不是布尔运算符。

因此，在这种情况下，要获得否定（或肯定）答案，您首先需要使用 !运算符获取布尔值，但如果您想检查肯定的情况，请使用 !!。

if 和 while 语句以及 ? 运算符使用真值来确定要运行的代码分支。例如，零和 NaN 数字和空字符串为假，但其他数字和字符串为真。对象为真，但未定义值和 null 均为假。

双重否定运算符 !! 计算一个值的真值。它实际上是两个运算符，其中 !!x 表示 !(!x)，其行为如下：

如果 x 为假值，则 !x 为真，而 !!x 为假。

如果 x 为真值，!x 为假，!!x 为真。

在布尔上下文（if、while 或 ?）的顶层使用时，!! 运算符在行为上是无操作的。例如，if (x) 和 if (!!x) 表示相同的意思。

实际用途

然而，它有几个实际用途。

一种用途是将对象有损地压缩为其真值，这样您的代码就不会持有对大对象的引用并使其保持活动状态。将 !!some_big_object 分配给变量而不是 some_big_object 可以让垃圾收集器放弃它。这对于生成对象或错误值（例如 null）或未定义值（例如浏览器功能检测）的情况很有用。

我在 answer about C's corresponding !! operator 中提到的另一个用途是使用“lint”工具来查找常见的拼写错误和打印诊断。例如，在 C 和 JavaScript 中，布尔运算的一些常见拼写错误会产生其他行为，其输出与布尔运算不同：

if (a = b) 是赋值，然后使用 b 的真值； if (a == b) 是相等比较。

if (a & b) 是按位与； if (a && b) 是逻辑与。 2 & 5 为 0（假值）； 2 && 5 为真。

!! 运算符向 lint 工具保证您所写的就是您的意思：执行此操作，然后取结果的真值。

第三种用途是产生逻辑 XOR 和逻辑 XNOR。在 C 和 JavaScript 中，a && b 执行逻辑与（如果双方都为真，则为真），a & b 执行按位与。 a || b 执行逻辑 OR（如果至少有一个为真，则为真），而 a | b 执行按位 OR。 a ^ b 有一个按位 XOR（异或），但没有用于逻辑 XOR 的内置运算符（如果恰好一侧为真，则为真）。例如，您可能希望允许用户在两个字段之一中输入文本。您可以做的是将每个转换为真值并进行比较：!!x !== !!y。

双布尔否定。通常用于检查值是否未定义。

我只是想补充一点

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

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

上面的返回 undefined 但是如果你有一个空字符串，false, null, 0, undefined 这些值将返回，并且一旦我们在链中遇到它们——[] 和 {} 都是“真实的”，我们将继续沿着所谓的“&& 链”向下到右边的下一个值。

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

因此，(b || {}).foo 与 b && b.foo 相同，((b || {}).foo || {}).bar 与 b && b.foo && b.foo.bar 相同。

!!x 是 Boolean(x) 的简写

第一个 bang 强制 js 引擎运行 Boolean(x) 但也有反转值的副作用。所以第二次爆炸消除了副作用。

它强制所有东西都是布尔值。

例如：

console.log(undefined); // -> undefined
console.log(!undefined); // -> true
console.log(!!undefined); // -> false

console.log('abc'); // -> abc
console.log(!'abc'); // -> false
console.log(!!'abc'); // -> true

console.log(0 === false); // -> undefined
console.log(!0 === false); // -> false
console.log(!!0 === false); // -> true

这里有很多很好的答案，但如果你已经读到这里，这有助于我“明白”。在 Chrome（等）上打开控制台，然后开始输入：

!(!(1))
!(!(0))
!(!('truthy')) 
!(!(null))
!(!(''))
!(!(undefined))
!(!(new Object())
!(!({}))
woo = 'hoo'
!(!(woo))
...etc, etc, until the light goes on ;)

当然，这些都与仅键入 !!someThing 相同，但添加的括号可能有助于使其更易于理解。

在看到所有这些很棒的答案之后，我想添加另一个使用 !! 的原因。目前我正在使用 Angular 2-4 (TypeScript)，当我的用户未通过身份验证时，我想返回一个布尔值作为 false。如果他未通过身份验证，则令牌字符串将为 null 或 ""。我可以通过使用下一个代码块来做到这一点：

public isAuthenticated(): boolean {
   return !!this.getToken();
}

这是来自angular js的一段代码

var requestAnimationFrame = $window.requestAnimationFrame ||
                                $window.webkitRequestAnimationFrame ||
                                $window.mozRequestAnimationFrame;

 var rafSupported = !!requestAnimationFrame;

他们的目的是根据 requestAnimationFrame 中函数的可用性将 rafSupported 设置为 true 或 false

通常可以通过以下方式检查来实现：

if(typeof  requestAnimationFrame === 'function')
rafSupported =true;
else
rafSupported =false;

简短的方法可能是使用！

rafSupported = !!requestAnimationFrame ;

因此，如果 requestAnimationFrame 被分配了一个函数，那么 !requestAnimationFrame 将是 false 并且还有一个！这将是真的

如果 requestAnimationFrame 是未定义的，那么 !requestAnimationFrame 将是真的，而且还有一个！这将是错误的

返回变量的布尔值。

相反，可以使用 Boolean 类。

（请阅读代码说明）

var X = "test"; // X value is "test" as a String value
var booleanX = !!X // booleanX is `true` as a Boolean value beacuse non-empty strings evaluates as `true` in boolean
var whatIsXValueInBoolean = Boolean(X) // whatIsXValueInBoolean is `true` again
console.log(Boolean(X) === !!X) // writes `true`

即，Boolean(X) = !!X 正在使用中。

请查看下面的代码片段↓

let a = 0 console.log("a: ", a) // 将值写入其类型 console.log("!a: ", !a) // 将 '0 is NOT true in boolean' 写入 boolean - 这是真的。在布尔值中，0 表示假，1 表示真。 console.log("!!a: ", !!a) // 在布尔值中写入 0 值。 0 表示错误。 console.log("Boolean(a): ", Boolean(a)) // 等于 `!!a` console.log("\n") // 换行 a = 1 console.log("a: ", a) console.log("!a: ", !a) console.log("!!a: ", !!a) // 在布尔值中写入 1 个值 console.log("\n") // 换行 a = "" console.log("a: ", a) console.log("!a: ", !a) // 写 '"" is NOT true in boolean' value as boolean - 所以这是真的。在 boolean empty字符串、空值和未定义值表示假，如果有字符串则表示真。 console.log("!!a: ", !!a) // 将 "" 值写入布尔值 console.log("\n") // 换行 a = "test" console.log("a: ", a ) // 在其类型中写入一个值 console.log("!a: ", !a) console.log("!!a: ", !!a) // 在布尔值中写入“测试”值 console.log( "Boolean(a) === !!a: ", Boolean(a) === !!a) // 写成 true

使用逻辑非运算符两次
表示 !true = false 和 !!true = true

请务必记住 JavaScript 中对 true 和 false 的计算：

带有“值”的所有内容都是真的（即真），例如：101、3.1415、-11、“幸运脑”、new Object()，当然还有真的

101,

3.1415,

-11,

“幸运大脑”，

新对象（）

而且，当然，真的

没有“值”的所有内容都是假的（即假的），例如：0、-0、“”（空字符串）、未定义、空、NaN（不是数字），当然还有假

0,

-0,

"" (空字符串),

不明确的，

无效的，

NaN（不是数字）

当然，错误的

应用“logical not”运算符 (!) 计算操作数，将其转换为 boolean，然后取反。应用它两次将否定否定，有效地将值转换为 boolean。不应用运算符将只是对确切值的常规分配。例子：

var value = 23; // number
var valueAsNegatedBoolean = !value; // boolean falsy (because 23 is truthy)
var valueAsBoolean = !!value; // boolean truthy
var copyOfValue = value; // number 23

var value2 = 0;
var value2AsNegatedBoolean = !value2; // boolean truthy (because 0 is falsy)
var value2AsBoolean = !!value2; // boolean falsy
var copyOfValue2 = value2; // number 0

价值2 =价值；分配确切的对象值，即使它不是布尔值，因此 value2 不一定最终是布尔值。

价值2 = !!价值;作为操作数值的双重否定的结果，分配一个有保证的布尔值，它等价于以下但更短且可读性：

如果（值）{ value2 = true; } 其他 { value2 = false; }