是什么意思啊！！运算符在 JavaScript 中做什么？

Question

我看到了这段代码：

this.vertical = vertical !== undefined ? !!vertical : this.vertical;

它似乎使用 !! 作为操作符，我不认识。它有什么作用？

Answer 1

它将Object 转换为boolean。如果它是假的（例如，0、null、undefined等），那么它将是false，否则，true。

!object  // Inverted Boolean
!!object // Noninverted Boolean, so true Boolean representation

所以 !! 不是一个运算符；只是两次 ! 运算符。

通常更简单：

Boolean(object) // Boolean

现实世界示例“测试 IE 版本”：

const isIE8 = !! navigator.userAgent.match(/MSIE 8.0/);
console.log(isIE8); // Returns true or false

如果您 ⇒

console.log(navigator.userAgent.match(/MSIE 8.0/));
// Returns either an Array or null

但如果您 ⇒

console.log(!!navigator.userAgent.match(/MSIE 8.0/));
// Returns either true or false

Answer 2

这是一种非常晦涩的类型转换方式。

! 表示NOT。所以 !true 是 false，!false 是 true。 !0 为 true，!1 为 false。

因此，您要将一个值转换为布尔值，将其反转，然后再次反转。

    // Maximum Obscurity:
    val.enabled = !!userId;

    // Partial Obscurity:
    val.enabled = (userId != 0) ? true : false;

    // And finally, much easier to understand:
    val.enabled = (userId != 0);

    // Or just
    val.enabled = Boolean(userId);

注意：当涉及到某些边缘情况时（当 userId 为 []，例如）由于 != 运算符的工作方式以及哪些值被视为真实。

Answer 3

!!expr （两个 ! 运算符后跟一个表达式）根据 表达式的真实性。

当用于非布尔表达式时它是有意义的。一些示例：

注意：< code>Boolean 函数产生完全相同的结果，并且更具可读性。

          !!false // false
           !!true // true

              !!0 // false
!!parseInt("foo") // false — NaN is falsy
              !!1 // true
             !!-1 // true  — negative number 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

Answer 4

泡些茶：

!! 不是操作员。它是 ! 的双重使用——逻辑“非”运算符。

---

理论上：

! 确定某个值不为“真”：

• 事实是 假 不是 true （这就是为什么 !false 结果
在true）

  


• 事实是 true 不是 false （这就是为什么 !true 结果
  在假）

---

!! 确定值的“真实性”不 not:

• 事实是 true 不是 not true （这就是为什么 !!true 结果在true）

• 事实是 false 不是不是 false（这就是为什么 !!false 结果为 false)

---

我们希望在比较中确定的是关于引用值的“真相”，而不是值参考本身。有一个用例，我们可能想知道某个值的真实情况，即使我们期望该值是 false （或 falsey），或者如果我们期望该值不能是 boolean 类型。

---

实践：

考虑一个简洁的函数，通过动态类型（又名“鸭子类型”）。我们希望编写一个函数，如果用户的浏览器支持 HTML5 元素，则返回 true，但我们不希望该函数在以下情况下抛出错误： code>

---

以下是三种方法：

// 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

每个函数接受一个 参数和一个要查找的 attribute ，但它们各自根据比较确定的内容返回不同的值。

但是等等，还有更多！

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

// 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

我们离题了...

无论这些情况多么罕见，都可能存在一些场景，其中最简洁、最高效，因此也是获得的首选方法。 >true 来自非布尔值、可能未定义的值确实是通过使用 !! 实现的。希望这可笑地澄清了这一点。

Answer 5

!! 将其右侧的值转换为其等效的布尔值。 （想想穷人的“类型转换”方式。）它的意图通常是向读者传达代码并不关心变量中的值是什么，但是它的“真相”值是什么。

Answer 6

!!foo 应用一元 not 运算符两次，用于转换为布尔类型，类似于使用一元加 +foo 进行转换转换为数字并连接空字符串 ''+foo 以转换为字符串。

除了这些技巧之外，您还可以使用与原始类型相对应的构造函数（不使用new）来显式转换值，即

Boolean(foo) === !!foo
Number(foo)  === +foo
String(foo)  === ''+foo

Answer 7

这么多答案，事半功倍。是的，!!X 可以理解为“X 的真实性[表示为布尔值]”。但实际上，!! 对于确定单个变量（或者即使许多变量是）真值还是假值来说并不那么重要。 !!myVar === true 与 myVar 相同。将 !!X 与“真正的”布尔值进行比较并不是很有用。

使用 !! 获得的唯一好处是能够以可重复的、标准化的方式（以及 JSLint 友好）时尚。

简单地转换:(

也就是说...

• 0 === false 是 false。
• !!0 === false 是 true 上面的代码

不太有用。 if (!0) 给出的结果与 if (!!0 === false) 相同。考虑将变量转换为布尔值然后与“true”布尔值进行比较的好例子，

请参阅 JSLint 的说明（注意：网站已更改；这是存档副本）了解原因：

== 和 != 运算符在比较之前进行类型强制转换。这很糟糕，因为它会导致 ' \t\r\n' == 0 为真。这可以掩盖类型错误。 JSLint 无法可靠地确定 == 是否正确使用，因此最好根本不使用 == 和 !=，而始终使用更可靠的 === 和 !== 运算符。

如果您只关心某个值是真还是假，那么请使用缩写形式。而不是
(foo != 0)

就说
(foo)

而不是
(foo == 0)

说
(!foo)

请注意，在一些不直观的情况中，布尔值将被转换为将布尔值与数字进行比较时，数字（true 转换为 1，false 转换为 0）。在这种情况下，!! 可能在心理上有用。不过，在这些情况下，您将非布尔值与硬类型布尔值进行比较，在我看来，这是一个严重的错误。 if (-1)< /code> 仍然是这里的方法。

原始	等效	结果	注释
if (-1 == true) console.log("spam" )	if (-1 == 1)	未定义
if (-1 == false) console.log("spam")	if (-1 == 0)	未定义
if (true == -1) console.log("spam")	if (1 == -1)	undefined	顺序并不重要 ...
if (!!-1 == true) console.log("spam")	if (true == true)	垃圾邮件	更好
if (-1) console .log("spam")	if (truthy)	垃圾邮件	仍然是最好的

并且根据您的引擎，事情会变得更加疯狂。例如，WScript 赢得了奖项。

function test()
{
    return (1 === 1);
}
WScript.echo(test());

由于一些历史Windows jive，它将在消息框中输出-1！在 cmd.exe 提示符下尝试一下，看看吧！但是 WScript.echo(-1 == test()) 仍然给你 0，或者 WScript 的 false。 别看别处。这太可怕了。

比较真实性:)

但是如果我有两个值需要检查是否相等真实性/虚假性怎么办？

假设我们有 myVar1 = 0; 和 myVar2 = undefined;。

• myVar1 === myVar2 是 0 === undefined 并且显然是错误的。
• !!myVar1 === !!myVar2 是 !!0 === !!undefined 并且是真的！同样的真实！ （在这种情况下，两者都“具有虚假的真实性”。）

因此，您真正需要使用“布尔转换变量”的唯一地方是，如果您要检查两个变量是否都具有 < em>同样的真实性，对吗？也就是说，如果您需要查看两个变量是都是真值还是都是假（或不是），即相等，则使用!! （或不是）真实性。

我想不出一个很好的、非人为的用例来实现这一点。也许您的表单中有“链接”字段？

if (!!customerInput.spouseName !== !!customerInput.spouseAge ) {
    errorObjects.spouse = "Please either enter a valid name AND age "
        + "for your spouse or leave all spouse fields blank.";
}

因此，现在如果您的配偶姓名和年龄都为真，或者都为假，您就可以继续。否则，您只有一个具有值的字段（或很早的包办婚姻），并且需要在您的 errorObjects 集合上创建一个额外的错误。

尽管即使在这种情况下， !! 确实是多余的。一个 ! 足以转换为布尔值，而您只需检查相等性。

---

编辑 2017 年 10 月 24 日，2 月 6 日：

需要显式布尔值的第三方库

这是一个有趣的案例...当第三方库需要显式布尔值时 !! 可能会很有用显式布尔值。

React

例如，False 在 JSX (React) 中具有特殊含义< /a> 这不是因为简单的错误而触发的。如果您尝试在 JSX 中返回类似以下内容，并且期望 messageCount 中包含 int...

{messageCount &&

你有消息！

}

...当你有零条消息时，你可能会惊讶地看到 React 渲染 0 。您必须显式返回 false 才能使 JSX 不呈现。上面的语句返回 0，JSX 愉快地渲染它，正如它应该的那样。它无法告诉您没有计数：{messageCount}。

• 一个修复涉及 bangbang，它将 0 强制转换为 !!0，即 false：
  {!!messageCount &&

  您有消息！

  }

• JSX 文档建议您更加明确，编写自我注释代码，并使用比较来强制为布尔值。
  <代码>{消息计数> 0 &&

  您有消息！

  }

• 我自己用三元来处理虚假会更自如 --
  <代码>{消息计数？

  您有消息！

  ：假}

TypeScript

TypeScript 中的相同处理：如果您有一个返回布尔值的函数（或者您正在为布尔变量赋值），那么您[通常]无法返回/分配布尔值 - y 值；它必须是强类型布尔值。这意味着，iff myObject 是强类型的，return !myObject; 适用于返回布尔值的函数，但return myObject;< /code> 没有。您必须返回!!myObject（或以另一种方式转换为正确的布尔值）才能满足 TypeScript 的期望。

TypeScript 的例外？如果 myObject 是 any，那么您就回到了 JavaScript 的狂野西部，并且可以在没有 !! 的情况下返回它，即使您的返回类型是布尔值。

请记住，这些是 JSX 和 TypeScript 约定，而不是 JavaScript 固有的。

但是，如果您在渲染的 JSX 中看到奇怪的 0，请考虑松散的虚假管理。

Answer 8

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

true === !!10

false === !!0

Answer 9

它将后缀转换为布尔值。

Answer 10

看来 !! 运算符会导致双重否定。

var foo = "Hello, World!";

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

Answer 11

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

Answer 12

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

Answer 13

!! 一起使用了 NOT 操作两次。 ! 将值转换为布尔值并反转它，因此使用它两次，显示该值的布尔值（假或真）。这是一个简单的例子来看看!!是如何工作的：

首先，你所拥有的地方：

var zero = 0;

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

!zero; //true

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

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

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

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

Answer 14

！是“布尔非”，它本质上将“enable”的值类型转换为其相反的布尔值。第二个！翻转该值。因此，!!enable 表示“不启用”，为您提供布尔值形式的 enable 值。

Answer 15

我认为值得一提的是，与逻辑 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

Answer 16

!! 构造是将任何 JavaScript 表达式转换为
它的布尔等价物。

例如：!!“他击落了我”=== true 和 !!0 === false。

Answer 17

这不是一个单独的操作员；而是一个操作员。是两个。它相当于以下内容，是将值转换为布尔值的快速方法。

val.enabled = !(!enable);

Answer 18

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

例如：

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);   // -> false
console.log(!0 === false);  // -> false
console.log(!!0 === false); // -> true

Answer 19

我怀疑这是 C++ 的遗留问题，人们重写 ! 运算符，但不重写 bool 运算符。

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

Answer 20

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

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

• 如果 x 是 false 值，则 < code>!x 为 true，!!x 为 false。
• 如果 x 为 true 值，则 !x 为 false，!!x 为 true< /代码>。

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

实际用途

然而它有几个实际用途。

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

我在关于 C 相应 !! 运算符的答案中提到的另一种用法是“ lint”工具，用于查找常见拼写错误并打印诊断信息。例如，在 C 和 JavaScript 中，布尔运算的一些常见拼写错误会产生其他行为，其输出并不完全是布尔值：

• if (a = b) 是赋值，然后使用真值b； if (a == b) 是相等比较。
• if (a & b) 是按位与； if (a && b) 是逻辑 AND。 <代码>2 & 5 是 0（假值）； <代码>2 && 5 是正确的。

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

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

Answer 21

这个问题已经得到了相当彻底的回答，但我想添加一个答案，我希望尽可能简化，使含义！！尽可能简单易懂。

因为 JavaScript 具有所谓的“true”和“falsy”值，所以有些表达式在其他表达式中计算时将导致 true 或 false 条件，即使正在检查的值或表达式实际上不是 true代码> 或<代码>假。

例如：

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

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

但是：

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

...将不会导致条件为真，并且即使该元素确实存在，代码块也不会被执行。

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

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

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

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

并且

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

将两者返回true，如预期的那样。

Answer 22

我只是想补充一点，这

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 语句，并且我们不会收到错误。

上面的返回未定义，但如果你有一个空字符串、false、null、0、未定义，这些值将返回，当我们在链中遇到它们时 - [] 和 {}< /code> 都是“真实的”，我们将继续沿着所谓的“&&链”向下到达右侧的下一个值。

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

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

Answer 23

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

Answer 24

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

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

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

Answer 25

!!x 是 Boolean(x) 的简写。

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

Answer 26

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

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

Answer 27

请务必记住 JavaScript 中对 true 和 false 的评估：

• 所有具有“值”的内容都是 true< /code>（即truthy），例如：

  • 101，
  • 3.1415，
  • <代码>-11，
  • “幸运大脑”，
  • new Object()
  • 当然，true

• 一切都没有“Value”为false（即falsy），例如：

  • 0,
  • <代码>-0，
  • ""（空字符串），
  • 未定义，
  • 空，
  • NaN（不是数字）
  • 当然还有假

应用“逻辑非”运算符 (!) 计算操作数，将其转换为 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

• value2 = value; 分配精确的对象 value，即使它不是 boolean，因此 value2 不会最终必然是布尔值。
• value2 = !!value; 分配一个有保证的 boolean 作为操作数 value 双重否定的结果，它等价于以下但更短且可读：

if (value) {
  value2 = true;
} else {
  value2 = false;
}

Answer 28

这是来自 AngularJS 的一段代码：

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 将为 true，而其中的一个 ! 将为 false。

Answer 29

使用逻辑非运算符两次。

这意味着 !true = false 和 !!true = true。

Answer 30

它返回变量的布尔值。

相反，可以使用 Boolean 类。

（请阅读代码说明。）

var X = "test"; // The X value is "test" as a String value
var booleanX = !!X // booleanX is `true` as a Boolean value because 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) // Writes a value in its kind
console.log("!a: ", !a) // Writes '0 is NOT true in Boolean' value as Boolean - so that's true. In Boolean, 0 means false and 1 means true.
console.log("!!a: ", !!a) // Writes 0 value in Boolean. 0 means false.
console.log("Boolean(a): ", Boolean(a)) // Equals `!!a`
console.log("\n") // Newline

a = 1
console.log("a: ", a)
console.log("!a: ", !a)
console.log("!!a: ", !!a) // Writes 1 value in Boolean
console.log("\n") // Newline

a = ""
console.log("a: ", a)
console.log("!a: ", !a) // Writes '"" is NOT true in Boolean' value as Boolean - so that's true. In Boolean, empty strings, null and undefined values mean false and if there is a string it means true.
console.log("!!a: ", !!a) // Writes "" value in Boolean
console.log("\n") // Newline

a = "test"
console.log("a: ", a) // Writes a value in its kind
console.log("!a: ", !a)
console.log("!!a: ", !!a) // Writes "test" value in Boolean

console.log("Boolean(a) === !!a: ", Boolean(a) === !!a) // writes true